diff --git a/Cargo.lock b/Cargo.lock index 4515f57f7b9..d8124ac1734 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -63,6 +63,732 @@ version = "0.2.21" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "683d7910e743518b0e34f1186f92494becacb047c7b6bf616c96772180fef923" +[[package]] +name = "alloy" +version = "0.15.10" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3a0be470ab41e3aaed6c54dbb2b6224d3048de467d8009cf9d5d32a8b8957ef7" +dependencies = [ + "alloy-consensus", + "alloy-contract", + "alloy-core", + "alloy-eips", + "alloy-genesis", + "alloy-network", + "alloy-provider", + "alloy-pubsub", + "alloy-rpc-client", + "alloy-rpc-types", + "alloy-serde", + "alloy-signer", + "alloy-signer-local", + "alloy-transport", + "alloy-transport-http", + "alloy-transport-ipc", + "alloy-transport-ws", +] + +[[package]] +name = "alloy-chains" +version = "0.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7734aecfc58a597dde036e4c5cace2ae43e2f8bf3d406b022a1ef34da178dd49" +dependencies = [ + "alloy-primitives", + "num_enum", + "strum 0.27.1", +] + +[[package]] +name = "alloy-consensus" +version = "0.15.10" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3a4fbb5e716faa10fc4e7a122307afcf55bae7272fc69286ee3eee881f757c66" +dependencies = [ + "alloy-eips", + "alloy-primitives", + "alloy-rlp", + "alloy-serde", + "alloy-trie", + "auto_impl", + "c-kzg", + "derive_more 2.0.1", + "either", + "k256", + "once_cell", + "rand 0.8.5", + "secp256k1 0.30.0", + "serde", + "serde_with 3.12.0", + "thiserror 2.0.12", +] + +[[package]] +name = "alloy-consensus-any" +version = "0.15.10" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "42c04d03d9ee6b6768cad687df5a360fc58714f39a37c971b907a8965717636d" +dependencies = [ + "alloy-consensus", + "alloy-eips", + "alloy-primitives", + "alloy-rlp", + "alloy-serde", + "serde", +] + +[[package]] +name = "alloy-contract" +version = "0.15.10" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e0ff39ab8bf0d23caa41ec1898d80ad1bcb037c94a048141ac4a961980164e65" +dependencies = [ + "alloy-consensus", + "alloy-dyn-abi", + "alloy-json-abi", + "alloy-network", + "alloy-network-primitives", + "alloy-primitives", + "alloy-provider", + "alloy-pubsub", + "alloy-rpc-types-eth", + "alloy-sol-types", + "alloy-transport", + "futures 0.3.30", + "futures-util", + "thiserror 2.0.12", +] + +[[package]] +name = "alloy-core" +version = "1.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "24b2817489e4391d8c0bdf043c842164855e3d697de7a8e9edf24aa30b153ac5" +dependencies = [ + "alloy-dyn-abi", + "alloy-json-abi", + "alloy-primitives", + "alloy-rlp", + "alloy-sol-types", +] + +[[package]] +name = "alloy-dyn-abi" +version = "1.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4f90b63261b7744642f6075ed17db6de118eecbe9516ea6c6ffd444b80180b75" +dependencies = [ + "alloy-json-abi", + "alloy-primitives", + "alloy-sol-type-parser", + "alloy-sol-types", + "const-hex", + "itoa", + "serde", + "serde_json", + "winnow 0.7.9", +] + +[[package]] +name = "alloy-eip2124" +version = "0.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "741bdd7499908b3aa0b159bba11e71c8cddd009a2c2eb7a06e825f1ec87900a5" +dependencies = [ + "alloy-primitives", + "alloy-rlp", + "crc", + "serde", + "thiserror 2.0.12", +] + +[[package]] +name = "alloy-eip2930" +version = "0.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7b82752a889170df67bbb36d42ca63c531eb16274f0d7299ae2a680facba17bd" +dependencies = [ + "alloy-primitives", + "alloy-rlp", + "serde", +] + +[[package]] +name = "alloy-eip7702" +version = "0.6.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "804cefe429015b4244966c006d25bda5545fa9db5990e9c9079faf255052f50a" +dependencies = [ + "alloy-primitives", + "alloy-rlp", + "k256", + "serde", + "thiserror 2.0.12", +] + +[[package]] +name = "alloy-eips" +version = "0.15.10" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "22c3699f23cea35d97a0a911b42c3cfd54dd95233df09307f5ebe52e0a74ad6e" +dependencies = [ + "alloy-eip2124", + "alloy-eip2930", + "alloy-eip7702", + "alloy-primitives", + "alloy-rlp", + "alloy-serde", + "auto_impl", + "c-kzg", + "derive_more 2.0.1", + "either", + "serde", + "sha2", +] + +[[package]] +name = "alloy-genesis" +version = "0.15.10" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "24c5a4e3f60f0b53b5dbd13904694e775a23ff98a43d6dd640b753b72669b993" +dependencies = [ + "alloy-eips", + "alloy-primitives", + "alloy-serde", + "alloy-trie", + "serde", +] + +[[package]] +name = "alloy-json-abi" +version = "1.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0068ae277f5ee3153a95eaea8ff10e188ed8ccde9b7f9926305415a2c0ab2442" +dependencies = [ + "alloy-primitives", + "alloy-sol-type-parser", + "serde", + "serde_json", +] + +[[package]] +name = "alloy-json-rpc" +version = "0.15.10" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ea71d308c1f3e42172c7fe9dccc6e63d97fa0cfd21d21f73c04d5e2640826f64" +dependencies = [ + "alloy-primitives", + "alloy-sol-types", + "serde", + "serde_json", + "thiserror 2.0.12", + "tracing", +] + +[[package]] +name = "alloy-network" +version = "0.15.10" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ddd432f53775e6ef85cfc8a3c90f174786bdc15d5cac379dcea01bd0e6f93edc" +dependencies = [ + "alloy-consensus", + "alloy-consensus-any", + "alloy-eips", + "alloy-json-rpc", + "alloy-network-primitives", + "alloy-primitives", + "alloy-rpc-types-any", + "alloy-rpc-types-eth", + "alloy-serde", + "alloy-signer", + "alloy-sol-types", + "async-trait", + "auto_impl", + "derive_more 2.0.1", + "futures-utils-wasm", + "serde", + "serde_json", + "thiserror 2.0.12", +] + +[[package]] +name = "alloy-network-primitives" +version = "0.15.10" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0b2dea138d01f0e9739dee905a9e40a0f2347dd217360d813b6b7967ee8c0a8e" +dependencies = [ + "alloy-consensus", + "alloy-eips", + "alloy-primitives", + "alloy-serde", + "serde", +] + +[[package]] +name = "alloy-primitives" +version = "1.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6a12fe11d0b8118e551c29e1a67ccb6d01cc07ef08086df30f07487146de6fa1" +dependencies = [ + "alloy-rlp", + "bytes", + "cfg-if 1.0.0", + "const-hex", + "derive_more 2.0.1", + "foldhash", + "hashbrown 0.15.2", + "indexmap 2.9.0", + "itoa", + "k256", + "keccak-asm", + "paste", + "proptest", + "rand 0.9.1", + "ruint", + "rustc-hash 2.1.1", + "serde", + "sha3", + "tiny-keccak 2.0.2", +] + +[[package]] +name = "alloy-provider" +version = "0.15.10" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0c1e1dc8a0a368a62455b526a037557b1e57c7fda652748e5e2c66db517906ed" +dependencies = [ + "alloy-chains", + "alloy-consensus", + "alloy-eips", + "alloy-json-rpc", + "alloy-network", + "alloy-network-primitives", + "alloy-primitives", + "alloy-pubsub", + "alloy-rpc-client", + "alloy-rpc-types-anvil", + "alloy-rpc-types-debug", + "alloy-rpc-types-eth", + "alloy-rpc-types-trace", + "alloy-rpc-types-txpool", + "alloy-signer", + "alloy-sol-types", + "alloy-transport", + "alloy-transport-http", + "alloy-transport-ipc", + "alloy-transport-ws", + "async-stream", + "async-trait", + "auto_impl", + "dashmap", + "either", + "futures 0.3.30", + "futures-utils-wasm", + "lru", + "parking_lot", + "pin-project", + "reqwest", + "serde", + "serde_json", + "thiserror 2.0.12", + "tokio", + "tracing", + "url", + "wasmtimer", +] + +[[package]] +name = "alloy-pubsub" +version = "0.15.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7622a767f5db7bb0165895e821a643c9903e6422f9986663b754cce6b9e972d7" +dependencies = [ + "alloy-json-rpc", + "alloy-primitives", + "alloy-transport", + "bimap", + "futures 0.3.30", + "parking_lot", + "serde", + "serde_json", + "tokio", + "tokio-stream", + "tower 0.5.2 (registry+https://github.com/rust-lang/crates.io-index)", + "tracing", + "wasmtimer", +] + +[[package]] +name = "alloy-rlp" +version = "0.3.11" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3d6c1d995bff8d011f7cd6c81820d51825e6e06d6db73914c1630ecf544d83d6" +dependencies = [ + "alloy-rlp-derive", + "arrayvec 0.7.4", + "bytes", +] + +[[package]] +name = "alloy-rlp-derive" +version = "0.3.11" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a40e1ef334153322fd878d07e86af7a529bcb86b2439525920a88eba87bcf943" +dependencies = [ + "proc-macro2", + "quote", + "syn 2.0.101", +] + +[[package]] +name = "alloy-rpc-client" +version = "0.15.10" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "97da6111d0232cc890aa4d334b5e427aa25491cf34adbe9806fa440a6f32650f" +dependencies = [ + "alloy-json-rpc", + "alloy-primitives", + "alloy-pubsub", + "alloy-transport", + "alloy-transport-http", + "alloy-transport-ipc", + "alloy-transport-ws", + "async-stream", + "futures 0.3.30", + "pin-project", + "reqwest", + "serde", + "serde_json", + "tokio", + "tokio-stream", + "tower 0.5.2 (registry+https://github.com/rust-lang/crates.io-index)", + "tracing", + "tracing-futures", + "url", + "wasmtimer", +] + +[[package]] +name = "alloy-rpc-types" +version = "0.15.10" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "835291d2f5423e02f755872b329c0bae97743936f596749f6fb6f0cf4de1324e" +dependencies = [ + "alloy-primitives", + "alloy-rpc-types-anvil", + "alloy-rpc-types-engine", + "alloy-rpc-types-eth", + "alloy-rpc-types-trace", + "alloy-rpc-types-txpool", + "alloy-serde", + "serde", +] + +[[package]] +name = "alloy-rpc-types-anvil" +version = "0.15.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "329177b79cc1db6a82477cb470fe5fa1a07d06a13425392edc254c664536caed" +dependencies = [ + "alloy-primitives", + "alloy-rpc-types-eth", + "alloy-serde", + "serde", +] + +[[package]] +name = "alloy-rpc-types-any" +version = "0.15.10" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "43c8536c15442b001046dcaff415067600231261e7c53767e74e69d15f72f651" +dependencies = [ + "alloy-consensus-any", + "alloy-rpc-types-eth", + "alloy-serde", +] + +[[package]] +name = "alloy-rpc-types-debug" +version = "0.15.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e2838ef592345b46b4aeffbb8dd4c857a84d4d7e6f14a8edef34197d74bc1d39" +dependencies = [ + "alloy-primitives", + "serde", +] + +[[package]] +name = "alloy-rpc-types-engine" +version = "0.15.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3e228902dd802e9af385ca9d511f1556b647bf651d65574ae5e198447db96eaf" +dependencies = [ + "alloy-consensus", + "alloy-eips", + "alloy-primitives", + "alloy-rlp", + "alloy-serde", + "derive_more 2.0.1", + "jsonwebtoken", + "rand 0.8.5", + "serde", + "strum 0.27.1", +] + +[[package]] +name = "alloy-rpc-types-eth" +version = "0.15.10" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "da690eafe37fe096037f8820b6bf2382f3ea68120d06a4253e4ac725a7e652dd" +dependencies = [ + "alloy-consensus", + "alloy-consensus-any", + "alloy-eips", + "alloy-network-primitives", + "alloy-primitives", + "alloy-rlp", + "alloy-serde", + "alloy-sol-types", + "itertools 0.13.0", + "serde", + "serde_json", + "thiserror 2.0.12", +] + +[[package]] +name = "alloy-rpc-types-trace" +version = "0.15.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4bc246ec9df92018d7be5bb3da2be87a2b9e35d076afa7c0f4dbeaefd2ba9ac0" +dependencies = [ + "alloy-primitives", + "alloy-rpc-types-eth", + "alloy-serde", + "serde", + "serde_json", + "thiserror 2.0.12", +] + +[[package]] +name = "alloy-rpc-types-txpool" +version = "0.15.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f66c7991d20ac2dfbf2fe1aeb303e20abbdb1ee85b3eaf0cf8512deef2f2e5f7" +dependencies = [ + "alloy-primitives", + "alloy-rpc-types-eth", + "alloy-serde", + "serde", +] + +[[package]] +name = "alloy-serde" +version = "0.15.10" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "261be2da2ef0bbbf80eed153c995822725cbef193e49eb251e2bf72cac29dbaf" +dependencies = [ + "alloy-primitives", + "serde", + "serde_json", +] + +[[package]] +name = "alloy-signer" +version = "0.15.10" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6fdf929ce72d18aa40974ecaa2cd77c5062a0baa105fdb95e6aa5609642d7210" +dependencies = [ + "alloy-primitives", + "async-trait", + "auto_impl", + "either", + "elliptic-curve", + "k256", + "thiserror 2.0.12", +] + +[[package]] +name = "alloy-signer-local" +version = "0.15.10" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "94910e0d75f086d4ed15d6a884170f648c28d06e4a8516156ea90204c0560595" +dependencies = [ + "alloy-consensus", + "alloy-network", + "alloy-primitives", + "alloy-signer", + "async-trait", + "k256", + "rand 0.8.5", + "thiserror 2.0.12", +] + +[[package]] +name = "alloy-sol-macro" +version = "1.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5d3ef8e0d622453d969ba3cded54cf6800efdc85cb929fe22c5bdf8335666757" +dependencies = [ + "alloy-sol-macro-expander", + "alloy-sol-macro-input", + "proc-macro-error2", + "proc-macro2", + "quote", + "syn 2.0.101", +] + +[[package]] +name = "alloy-sol-macro-expander" +version = "1.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f0e84bd0693c69a8fbe3ec0008465e029c6293494df7cb07580bf4a33eff52e1" +dependencies = [ + "alloy-json-abi", + "alloy-sol-macro-input", + "const-hex", + "heck 0.5.0", + "indexmap 2.9.0", + "proc-macro-error2", + "proc-macro2", + "quote", + "syn 2.0.101", + "syn-solidity", + "tiny-keccak 2.0.2", +] + +[[package]] +name = "alloy-sol-macro-input" +version = "1.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f3de663412dadf9b64f4f92f507f78deebcc92339d12cf15f88ded65d41c7935" +dependencies = [ + "alloy-json-abi", + "const-hex", + "dunce", + "heck 0.5.0", + "macro-string", + "proc-macro2", + "quote", + "serde_json", + "syn 2.0.101", + "syn-solidity", +] + +[[package]] +name = "alloy-sol-type-parser" +version = "1.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "251273c5aa1abb590852f795c938730fa641832fc8fa77b5478ed1bf11b6097e" +dependencies = [ + "serde", + "winnow 0.7.9", +] + +[[package]] +name = "alloy-sol-types" +version = "1.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5460a975434ae594fe2b91586253c1beb404353b78f0a55bf124abcd79557b15" +dependencies = [ + "alloy-json-abi", + "alloy-primitives", + "alloy-sol-macro", + "const-hex", + "serde", +] + +[[package]] +name = "alloy-transport" +version = "0.15.10" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4b4f3654d5195c0c3f502bfd6ed299ea9eb5cb275d7a88d04ce0d189bca416b2" +dependencies = [ + "alloy-json-rpc", + "alloy-primitives", + "base64 0.22.1", + "derive_more 2.0.1", + "futures 0.3.30", + "futures-utils-wasm", + "parking_lot", + "serde", + "serde_json", + "thiserror 2.0.12", + "tokio", + "tower 0.5.2 (registry+https://github.com/rust-lang/crates.io-index)", + "tracing", + "url", + "wasmtimer", +] + +[[package]] +name = "alloy-transport-http" +version = "0.15.10" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "70a9372fba202370973748d76c2891344cbacfb012d44a8ed62135ba53d4408e" +dependencies = [ + "alloy-json-rpc", + "alloy-transport", + "reqwest", + "serde_json", + "tower 0.5.2 (registry+https://github.com/rust-lang/crates.io-index)", + "tracing", + "url", +] + +[[package]] +name = "alloy-transport-ipc" +version = "0.15.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e8722fa30fc71c11f7626b35712ffba266497f304ede4fe09fc2a3c130c1eee5" +dependencies = [ + "alloy-json-rpc", + "alloy-pubsub", + "alloy-transport", + "bytes", + "futures 0.3.30", + "interprocess", + "pin-project", + "serde", + "serde_json", + "tokio", + "tokio-util 0.7.11", + "tracing", +] + +[[package]] +name = "alloy-transport-ws" +version = "0.15.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "fadcf1dc3105a51ac24070fed1a696334c7f77f639501e580c243490d0ba3d18" +dependencies = [ + "alloy-pubsub", + "alloy-transport", + "futures 0.3.30", + "http 1.1.0", + "rustls", + "serde_json", + "tokio", + "tokio-tungstenite", + "tracing", + "ws_stream_wasm", +] + +[[package]] +name = "alloy-trie" +version = "0.8.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "983d99aa81f586cef9dae38443245e585840fcf0fc58b09aee0b1f27aed1d500" +dependencies = [ + "alloy-primitives", + "alloy-rlp", + "arrayvec 0.7.4", + "derive_more 2.0.1", + "nybbles", + "serde", + "smallvec", + "tracing", +] + [[package]] name = "android-tzdata" version = "0.1.1" @@ -145,6 +871,130 @@ version = "1.7.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "69f7f8c3906b62b754cd5326047894316021dcfe5a194c8ea52bdd94934a3457" +[[package]] +name = "ark-ff" +version = "0.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6b3235cc41ee7a12aaaf2c575a2ad7b46713a8a50bda2fc3b003a04845c05dd6" +dependencies = [ + "ark-ff-asm 0.3.0", + "ark-ff-macros 0.3.0", + "ark-serialize 0.3.0", + "ark-std 0.3.0", + "derivative", + "num-bigint 0.4.6", + "num-traits", + "paste", + "rustc_version 0.3.3", + "zeroize", +] + +[[package]] +name = "ark-ff" +version = "0.4.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ec847af850f44ad29048935519032c33da8aa03340876d351dfab5660d2966ba" +dependencies = [ + "ark-ff-asm 0.4.2", + "ark-ff-macros 0.4.2", + "ark-serialize 0.4.2", + "ark-std 0.4.0", + "derivative", + "digest 0.10.7", + "itertools 0.10.5", + "num-bigint 0.4.6", + "num-traits", + "paste", + "rustc_version 0.4.0", + "zeroize", +] + +[[package]] +name = "ark-ff-asm" +version = "0.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "db02d390bf6643fb404d3d22d31aee1c4bc4459600aef9113833d17e786c6e44" +dependencies = [ + "quote", + "syn 1.0.109", +] + +[[package]] +name = "ark-ff-asm" +version = "0.4.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3ed4aa4fe255d0bc6d79373f7e31d2ea147bcf486cba1be5ba7ea85abdb92348" +dependencies = [ + "quote", + "syn 1.0.109", +] + +[[package]] +name = "ark-ff-macros" +version = "0.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "db2fd794a08ccb318058009eefdf15bcaaaaf6f8161eb3345f907222bac38b20" +dependencies = [ + "num-bigint 0.4.6", + "num-traits", + "quote", + "syn 1.0.109", +] + +[[package]] +name = "ark-ff-macros" +version = "0.4.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7abe79b0e4288889c4574159ab790824d0033b9fdcb2a112a3182fac2e514565" +dependencies = [ + "num-bigint 0.4.6", + "num-traits", + "proc-macro2", + "quote", + "syn 1.0.109", +] + +[[package]] +name = "ark-serialize" +version = "0.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1d6c2b318ee6e10f8c2853e73a83adc0ccb88995aa978d8a3408d492ab2ee671" +dependencies = [ + "ark-std 0.3.0", + "digest 0.9.0", +] + +[[package]] +name = "ark-serialize" +version = "0.4.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "adb7b85a02b83d2f22f89bd5cac66c9c89474240cb6207cb1efc16d098e822a5" +dependencies = [ + "ark-std 0.4.0", + "digest 0.10.7", + "num-bigint 0.4.6", +] + +[[package]] +name = "ark-std" +version = "0.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1df2c09229cbc5a028b1d70e00fdb2acee28b1055dfb5ca73eea49c5a25c4e7c" +dependencies = [ + "num-traits", + "rand 0.8.5", +] + +[[package]] +name = "ark-std" +version = "0.4.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "94893f1e0c6eeab764ade8dc4c0db24caf4fe7cbbaafc0eba0a9030f447b5185" +dependencies = [ + "num-traits", + "rand 0.8.5", +] + [[package]] name = "arrayref" version = "0.3.7" @@ -162,6 +1012,9 @@ name = "arrayvec" version = "0.7.4" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "96d30a06541fbafbc7f82ed10c06164cfbd2c401138f6addd8404629c4b16711" +dependencies = [ + "serde", +] [[package]] name = "ascii" @@ -248,8 +1101,8 @@ dependencies = [ "proc-macro-crate", "proc-macro2", "quote", - "strum", - "syn 2.0.87", + "strum 0.26.3", + "syn 2.0.101", "thiserror 1.0.61", ] @@ -285,7 +1138,7 @@ checksum = "3b43422f69d8ff38f95f1b2bb76517c91589a924d1559a0e935d7c8ce0274c11" dependencies = [ "proc-macro2", "quote", - "syn 2.0.87", + "syn 2.0.101", ] [[package]] @@ -307,7 +1160,7 @@ checksum = "c7c24de15d275a1ecfd47a380fb4d5ec9bfe0933f309ed5e705b775596a3574d" dependencies = [ "proc-macro2", "quote", - "syn 2.0.87", + "syn 2.0.101", ] [[package]] @@ -318,7 +1171,18 @@ checksum = "6e0c28dcc82d7c8ead5cb13beb15405b57b8546e93215673ff8ca0349a028107" dependencies = [ "proc-macro2", "quote", - "syn 2.0.87", + "syn 2.0.101", +] + +[[package]] +name = "async_io_stream" +version = "0.3.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b6d7b9decdf35d8908a7e3ef02f64c5e9b1695e230154c0e8de3969142d9b94c" +dependencies = [ + "futures 0.3.30", + "pharos", + "rustc_version 0.4.0", ] [[package]] @@ -333,6 +1197,17 @@ version = "0.1.13" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "41e67cd8309bbd06cd603a9e693a784ac2e5d1e955f11286e355089fcab3047c" +[[package]] +name = "auto_impl" +version = "1.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ffdcb70bdbc4d478427380519163274ac86e52916e10f0a8889adf0f96d3fee7" +dependencies = [ + "proc-macro2", + "quote", + "syn 2.0.101", +] + [[package]] name = "autocfg" version = "1.3.0" @@ -464,6 +1339,12 @@ version = "0.2.11" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "4cbbc9d0964165b47557570cce6c952866c2678457aca742aafc9fb771d30270" +[[package]] +name = "base16ct" +version = "0.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4c7f02d4ea65f2c1853089ffd8d2787bdbc63de2f0d29dedbcf8ccdfa0ccd4cf" + [[package]] name = "base64" version = "0.13.1" @@ -491,6 +1372,12 @@ dependencies = [ "base64 0.22.1", ] +[[package]] +name = "base64ct" +version = "1.7.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "89e25b6adfb930f02d1981565a6e5d9c547ac15a96606256d3b59040e5cd4ca3" + [[package]] name = "beef" version = "0.5.2" @@ -523,6 +1410,12 @@ dependencies = [ "num-traits", ] +[[package]] +name = "bimap" +version = "0.6.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "230c5f1ca6a325a32553f8640d31ac9b49f2411e901e427570154868b46da4f7" + [[package]] name = "bincode" version = "1.3.3" @@ -532,6 +1425,37 @@ dependencies = [ "serde", ] +[[package]] +name = "bit-set" +version = "0.8.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "08807e080ed7f9d5433fa9b275196cfc35414f66a0c79d864dc51a0d825231a3" +dependencies = [ + "bit-vec", +] + +[[package]] +name = "bit-vec" +version = "0.8.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5e764a1d40d510daf35e07be9eb06e75770908c27d411ee6c92109c9840eaaf7" + +[[package]] +name = "bitcoin-io" +version = "0.1.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0b47c4ab7a93edb0c7198c5535ed9b52b63095f4e9b45279c6736cec4b856baf" + +[[package]] +name = "bitcoin_hashes" +version = "0.14.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "bb18c03d0db0247e147a21a6faafd5a7eb851c743db062de72018b6b7e8e4d16" +dependencies = [ + "bitcoin-io", + "hex-conservative", +] + [[package]] name = "bitflags" version = "1.3.2" @@ -602,6 +1526,18 @@ dependencies = [ "generic-array", ] +[[package]] +name = "blst" +version = "0.3.14" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "47c79a94619fade3c0b887670333513a67ac28a6a7e653eb260bf0d4103db38d" +dependencies = [ + "cc", + "glob", + "threadpool", + "zeroize", +] + [[package]] name = "bs58" version = "0.4.0" @@ -654,6 +1590,21 @@ dependencies = [ "serde", ] +[[package]] +name = "c-kzg" +version = "2.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7318cfa722931cb5fe0838b98d3ce5621e75f6a6408abc21721d80de9223f2e4" +dependencies = [ + "blst", + "cc", + "glob", + "hex", + "libc", + "once_cell", + "serde", +] + [[package]] name = "cc" version = "1.2.16" @@ -736,7 +1687,7 @@ dependencies = [ "heck 0.5.0", "proc-macro2", "quote", - "syn 2.0.87", + "syn 2.0.101", ] [[package]] @@ -777,6 +1728,25 @@ dependencies = [ "windows-sys 0.59.0", ] +[[package]] +name = "const-hex" +version = "1.14.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4b0485bab839b018a8f1723fc5391819fea5f8f0f32288ef8a735fd096b6160c" +dependencies = [ + "cfg-if 1.0.0", + "cpufeatures", + "hex", + "proptest", + "serde", +] + +[[package]] +name = "const-oid" +version = "0.9.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c2459377285ad874054d797f3ccebf984978aa39129f6eafde5cdc8315b612f8" + [[package]] name = "constant_time_eq" version = "0.1.5" @@ -966,6 +1936,21 @@ dependencies = [ "wasmtime-types", ] +[[package]] +name = "crc" +version = "3.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "69e6e4d7b33a94f0991c26729976b10ebde1d34c3ee82408fb536164fa10d636" +dependencies = [ + "crc-catalog", +] + +[[package]] +name = "crc-catalog" +version = "2.4.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "19d374276b40fb8bbdee95aef7c7fa6b5316ec764510eb64b8dd0e2ed0d7e7f5" + [[package]] name = "crc32fast" version = "1.4.2" @@ -1037,6 +2022,18 @@ version = "0.2.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "7a81dae078cea95a014a339291cec439d2f232ebe854a9d672b796c6afafa9b7" +[[package]] +name = "crypto-bigint" +version = "0.5.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0dc92fb57ca44df6db8059111ab3af99a63d5d0f8375d9972e319a379c6bab76" +dependencies = [ + "generic-array", + "rand_core 0.6.4", + "subtle", + "zeroize", +] + [[package]] name = "crypto-common" version = "0.1.6" @@ -1099,7 +2096,7 @@ dependencies = [ "proc-macro2", "quote", "strsim", - "syn 2.0.87", + "syn 2.0.101", ] [[package]] @@ -1108,9 +2105,23 @@ version = "0.20.10" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "d336a2a514f6ccccaa3e09b02d41d35330c07ddf03a62165fcec10bb561c7806" dependencies = [ - "darling_core", - "quote", - "syn 2.0.87", + "darling_core", + "quote", + "syn 2.0.101", +] + +[[package]] +name = "dashmap" +version = "6.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5041cc499144891f3790297212f32a74fb938e5136a14943f338ef9e0ae276cf" +dependencies = [ + "cfg-if 1.0.0", + "crossbeam-utils", + "hashbrown 0.14.5", + "lock_api", + "once_cell", + "parking_lot_core", ] [[package]] @@ -1172,6 +2183,16 @@ version = "0.2.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "930c7171c8df9fb1782bdf9b918ed9ed2d33d1d22300abb754f9085bc48bf8e8" +[[package]] +name = "der" +version = "0.7.10" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7c1832837b905bbfb5101e07cc24c8deddf52f93225eee6ead5f4d63d53ddcb" +dependencies = [ + "const-oid", + "zeroize", +] + [[package]] name = "deranged" version = "0.3.11" @@ -1202,8 +2223,8 @@ dependencies = [ "convert_case 0.4.0", "proc-macro2", "quote", - "rustc_version", - "syn 2.0.87", + "rustc_version 0.4.0", + "syn 2.0.101", ] [[package]] @@ -1224,7 +2245,7 @@ dependencies = [ "convert_case 0.7.1", "proc-macro2", "quote", - "syn 2.0.87", + "syn 2.0.101", "unicode-xid", ] @@ -1257,7 +2278,7 @@ dependencies = [ "heck 0.4.1", "proc-macro2", "quote", - "syn 2.0.87", + "syn 2.0.101", ] [[package]] @@ -1279,7 +2300,7 @@ dependencies = [ "dsl_auto_type", "proc-macro2", "quote", - "syn 2.0.87", + "syn 2.0.101", ] [[package]] @@ -1299,7 +2320,7 @@ version = "0.2.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "209c735641a413bc68c4923a9d6ad4bcb3ca306b794edaa7eb0b3228a99ffb25" dependencies = [ - "syn 2.0.87", + "syn 2.0.101", ] [[package]] @@ -1330,6 +2351,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "9ed9a281f7bc9b7576e61468ba615a66a5c8cfdff42420a70aa82701a3b1e292" dependencies = [ "block-buffer 0.10.4", + "const-oid", "crypto-common", "subtle", ] @@ -1394,9 +2416,15 @@ checksum = "97369cbbc041bc366949bc74d34658d6cda5621039731c6310521892a3a20ae0" dependencies = [ "proc-macro2", "quote", - "syn 2.0.87", + "syn 2.0.101", ] +[[package]] +name = "doctest-file" +version = "1.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "aac81fa3e28d21450aa4d2ac065992ba96a1d7303efbce51a95f4fd175b67562" + [[package]] name = "dsl_auto_type" version = "0.1.1" @@ -1408,14 +2436,58 @@ dependencies = [ "heck 0.5.0", "proc-macro2", "quote", - "syn 2.0.87", + "syn 2.0.101", +] + +[[package]] +name = "dunce" +version = "1.0.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "92773504d58c093f6de2459af4af33faa518c13451eb8f2b5698ed3d36e7c813" + +[[package]] +name = "ecdsa" +version = "0.16.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ee27f32b5c5292967d2d4a9d7f1e0b0aed2c15daded5a60300e4abb9d8020bca" +dependencies = [ + "der", + "digest 0.10.7", + "elliptic-curve", + "rfc6979", + "serdect", + "signature", + "spki", ] [[package]] name = "either" -version = "1.13.0" +version = "1.15.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "48c757948c5ede0e46177b7add2e67155f70e33c07fea8284df6576da70b3719" +dependencies = [ + "serde", +] + +[[package]] +name = "elliptic-curve" +version = "0.13.8" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "60b1af1c220855b6ceac025d3f6ecdd2b7c4894bfe9cd9bda4fbb4bc7c0d4cf0" +checksum = "b5e6043086bf7973472e0c7dff2142ea0b680d30e18d9cc40f267efbf222bd47" +dependencies = [ + "base16ct", + "crypto-bigint", + "digest 0.10.7", + "ff", + "generic-array", + "group", + "pkcs8", + "rand_core 0.6.4", + "sec1", + "serdect", + "subtle", + "zeroize", +] [[package]] name = "encode_unicode" @@ -1472,7 +2544,7 @@ checksum = "d4291f0c7220b67ad15e9d5300ba2f215cee504f0924d60e77c9d1c77e7a69b1" dependencies = [ "proc-macro2", "quote", - "syn 2.0.87", + "syn 2.0.101", ] [[package]] @@ -1515,7 +2587,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "11da94e443c60508eb62cf256243a64da87304c2802ac2528847f79d750007ef" dependencies = [ "crunchy", - "fixed-hash", + "fixed-hash 0.7.0", "impl-rlp", "impl-serde", "tiny-keccak 2.0.2", @@ -1528,10 +2600,10 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "b2827b94c556145446fcce834ca86b7abf0c39a805883fe20e72c5bfdb5a0dc6" dependencies = [ "ethbloom", - "fixed-hash", + "fixed-hash 0.7.0", "impl-rlp", "impl-serde", - "primitive-types", + "primitive-types 0.11.1", "uint 0.9.5", ] @@ -1562,6 +2634,38 @@ version = "2.1.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "9fc0510504f03c51ada170672ac806f1f105a88aa97a5281117e1ddc3368e51a" +[[package]] +name = "fastrlp" +version = "0.3.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "139834ddba373bbdd213dffe02c8d110508dcf1726c2be27e8d1f7d7e1856418" +dependencies = [ + "arrayvec 0.7.4", + "auto_impl", + "bytes", +] + +[[package]] +name = "fastrlp" +version = "0.4.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ce8dba4714ef14b8274c371879b175aa55b16b30f269663f19d576f380018dc4" +dependencies = [ + "arrayvec 0.7.4", + "auto_impl", + "bytes", +] + +[[package]] +name = "ff" +version = "0.13.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c0b50bfb653653f9ca9095b427bed08ab8d75a137839d9ad64eb11810d5b6393" +dependencies = [ + "rand_core 0.6.4", + "subtle", +] + [[package]] name = "firestorm" version = "0.4.6" @@ -1586,6 +2690,18 @@ dependencies = [ "static_assertions", ] +[[package]] +name = "fixed-hash" +version = "0.8.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "835c052cb0c08c1acf6ffd71c022172e18723949c8282f2b9f27efbc51e64534" +dependencies = [ + "byteorder", + "rand 0.8.5", + "rustc-hex", + "static_assertions", +] + [[package]] name = "fixedbitset" version = "0.5.7" @@ -1706,7 +2822,7 @@ checksum = "87750cf4b7a4c0625b1529e4c543c2182106e4dedc60a2a6455e00d212c489ac" dependencies = [ "proc-macro2", "quote", - "syn 2.0.87", + "syn 2.0.101", ] [[package]] @@ -1746,6 +2862,12 @@ dependencies = [ "slab", ] +[[package]] +name = "futures-utils-wasm" +version = "0.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "42012b0f064e01aa58b545fe3727f90f7dd4020f4a3ea735b50344965f5a57e9" + [[package]] name = "fxhash" version = "0.2.1" @@ -1776,6 +2898,7 @@ checksum = "85649ca51fd72272d7821adaf274ad91c288277713d9c18820d8499a7ff69e9a" dependencies = [ "typenum", "version_check", + "zeroize", ] [[package]] @@ -1785,8 +2908,10 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "c4567c8db10ae91089c99af84c68c38da3ec2f087c3f82960bcdbf3656b6f4d7" dependencies = [ "cfg-if 1.0.0", + "js-sys", "libc", "wasi 0.11.0+wasi-snapshot-preview1", + "wasm-bindgen", ] [[package]] @@ -1836,10 +2961,16 @@ dependencies = [ "log", "proc-macro2", "quote", - "syn 2.0.87", + "syn 2.0.101", "time", ] +[[package]] +name = "glob" +version = "0.3.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a8d1add55171497b4705a648c6b583acafb01d58050a51727785f0b2c8e0a2b2" + [[package]] name = "globset" version = "0.4.14" @@ -1858,6 +2989,7 @@ name = "graph" version = "0.36.0" dependencies = [ "Inflector", + "alloy", "anyhow", "async-stream", "async-trait", @@ -1906,7 +3038,7 @@ dependencies = [ "rand 0.9.1", "regex", "reqwest", - "semver", + "semver 1.0.23", "serde", "serde_derive", "serde_json", @@ -1966,6 +3098,8 @@ dependencies = [ name = "graph-chain-ethereum" version = "0.36.0" dependencies = [ + "alloy", + "alloy-rpc-types", "anyhow", "base64 0.22.1", "envconfig", @@ -1977,7 +3111,7 @@ dependencies = [ "jsonrpc-core", "prost", "prost-types", - "semver", + "semver 1.0.23", "serde", "tiny-keccak 1.5.0", "tonic-build", @@ -2011,7 +3145,7 @@ dependencies = [ "lazy_static", "prost", "prost-types", - "semver", + "semver 1.0.23", "serde", "tokio", "tonic-build", @@ -2093,7 +3227,7 @@ dependencies = [ "heck 0.5.0", "proc-macro2", "quote", - "syn 2.0.87", + "syn 2.0.101", ] [[package]] @@ -2105,7 +3239,7 @@ dependencies = [ "graph-runtime-derive", "graph-runtime-wasm", "rand 0.9.1", - "semver", + "semver 1.0.23", "test-store", "wasmtime", ] @@ -2117,13 +3251,12 @@ dependencies = [ "anyhow", "async-trait", "bs58 0.4.0", - "ethabi", "graph", "graph-runtime-derive", "hex", "never", "parity-wasm", - "semver", + "semver 1.0.23", "serde_yaml", "wasm-instrument", "wasmtime", @@ -2221,7 +3354,7 @@ dependencies = [ "graph-runtime-wasm", "graph-server-index-node", "graph-store-postgres", - "secp256k1", + "secp256k1 0.21.3", "serde", "serde_yaml", "slog", @@ -2237,7 +3370,7 @@ dependencies = [ "proc-macro-utils", "proc-macro2", "quote", - "syn 2.0.87", + "syn 2.0.101", ] [[package]] @@ -2286,7 +3419,7 @@ dependencies = [ "anyhow", "chrono", "diesel", - "strum", + "strum 0.26.3", ] [[package]] @@ -2309,7 +3442,18 @@ dependencies = [ "lazy_static", "serde", "serde_json", - "serde_with", + "serde_with 2.3.3", +] + +[[package]] +name = "group" +version = "0.13.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f0f9ef7462f7c099f518d754361858f86d8a07af53ba9af0fe635bbccb151a63" +dependencies = [ + "ff", + "rand_core 0.6.4", + "subtle", ] [[package]] @@ -2397,6 +3541,7 @@ dependencies = [ "allocator-api2", "equivalent", "foldhash", + "serde", ] [[package]] @@ -2456,6 +3601,18 @@ name = "hex" version = "0.4.3" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "7f24254aa9a54b5c858eaee2f5bccdb46aaf0e486a595ed5fd8f86ba55232a70" +dependencies = [ + "serde", +] + +[[package]] +name = "hex-conservative" +version = "0.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5313b072ce3c597065a808dbf612c4c8e8590bdbf8b579508bf7a762c5eae6cd" +dependencies = [ + "arrayvec 0.7.4", +] [[package]] name = "hex-literal" @@ -2822,7 +3979,7 @@ checksum = "1ec89e9337638ecdc08744df490b221a7399bf8d164eb52a665454e60e075ad6" dependencies = [ "proc-macro2", "quote", - "syn 2.0.87", + "syn 2.0.101", ] [[package]] @@ -2929,6 +4086,21 @@ dependencies = [ "serde", ] +[[package]] +name = "interprocess" +version = "2.2.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d941b405bd2322993887859a8ee6ac9134945a24ec5ec763a8a962fc64dfec2d" +dependencies = [ + "doctest-file", + "futures-core", + "libc", + "recvmsg", + "tokio", + "widestring", + "windows-sys 0.52.0", +] + [[package]] name = "ipnet" version = "2.9.0" @@ -3125,6 +4297,35 @@ dependencies = [ "tracing", ] +[[package]] +name = "jsonwebtoken" +version = "9.3.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5a87cc7a48537badeae96744432de36f4be2b4a34a05a5ef32e9dd8a1c169dde" +dependencies = [ + "base64 0.22.1", + "js-sys", + "pem", + "ring", + "serde", + "serde_json", + "simple_asn1", +] + +[[package]] +name = "k256" +version = "0.13.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f6e3919bbaa2945715f0bb6d3934a173d1e9a59ac23767fbaaef277265a7411b" +dependencies = [ + "cfg-if 1.0.0", + "ecdsa", + "elliptic-curve", + "once_cell", + "serdect", + "sha2", +] + [[package]] name = "keccak" version = "0.1.5" @@ -3134,6 +4335,16 @@ dependencies = [ "cpufeatures", ] +[[package]] +name = "keccak-asm" +version = "0.1.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "505d1856a39b200489082f90d897c3f07c455563880bc5952e38eabf731c83b6" +dependencies = [ + "digest 0.10.7", + "sha3-asm", +] + [[package]] name = "lazy_static" version = "1.5.0" @@ -3152,6 +4363,12 @@ version = "0.2.171" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "c19937216e9d3aa9956d9bb8dfc0b0c8beb6058fc4f7a4dc4d850edf86a237d6" +[[package]] +name = "libm" +version = "0.2.14" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a25169bd5913a4b437588a7e3d127cd6e90127b60e0ffbd834a38f1599e016b8" + [[package]] name = "libredox" version = "0.1.3" @@ -3190,6 +4407,15 @@ version = "0.4.22" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "a7a70ba024b9dc04c27ea2f0c0548feb474ec5c54bba33a7f72f873a39d07b24" +[[package]] +name = "lru" +version = "0.13.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "227748d55f2f0ab4735d87fd623798cb6b664512fe979705f829c9f81c934465" +dependencies = [ + "hashbrown 0.15.2", +] + [[package]] name = "lru_time_cache" version = "0.11.11" @@ -3205,6 +4431,17 @@ dependencies = [ "libc", ] +[[package]] +name = "macro-string" +version = "0.1.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1b27834086c65ec3f9387b096d66e99f221cf081c2b738042aa252bcd41204e3" +dependencies = [ + "proc-macro2", + "quote", + "syn 2.0.101", +] + [[package]] name = "maplit" version = "1.0.2" @@ -3437,6 +4674,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "071dfc062690e90b734c0b2273ce72ad0ffa95f0c74596bc250dcfd960262841" dependencies = [ "autocfg", + "libm", ] [[package]] @@ -3449,6 +4687,39 @@ dependencies = [ "libc", ] +[[package]] +name = "num_enum" +version = "0.7.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4e613fc340b2220f734a8595782c551f1250e969d87d3be1ae0579e8d4065179" +dependencies = [ + "num_enum_derive", +] + +[[package]] +name = "num_enum_derive" +version = "0.7.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "af1844ef2428cc3e1cb900be36181049ef3d3193c63e43026cfe202983b27a56" +dependencies = [ + "proc-macro2", + "quote", + "syn 2.0.101", +] + +[[package]] +name = "nybbles" +version = "0.3.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8983bb634df7248924ee0c4c3a749609b5abcb082c28fffe3254b3eb3602b307" +dependencies = [ + "alloy-rlp", + "const-hex", + "proptest", + "serde", + "smallvec", +] + [[package]] name = "object" version = "0.32.2" @@ -3502,9 +4773,9 @@ dependencies = [ [[package]] name = "once_cell" -version = "1.19.0" +version = "1.21.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "3fdb12b2476b595f9358c5161aa467c2438859caa136dec86c26fdd2efe17b92" +checksum = "42f5e15c9953c5e4ccceeb2e7382a716482c34515315f7b03532b8b4e8393d2d" [[package]] name = "opaque-debug" @@ -3535,7 +4806,7 @@ checksum = "a948666b637a0f465e8564c73e89d4dde00d72d4d473cc972f390fc3dcee7d9c" dependencies = [ "proc-macro2", "quote", - "syn 2.0.87", + "syn 2.0.101", ] [[package]] @@ -3632,6 +4903,16 @@ version = "1.0.15" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "57c0d7b74b563b49d38dae00a0c37d4d6de9b432382b2892f0574ddcae73fd0a" +[[package]] +name = "pem" +version = "3.0.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "38af38e8470ac9dee3ce1bae1af9c1671fffc44ddfd8bd1d0a3445bf349a8ef3" +dependencies = [ + "base64 0.22.1", + "serde", +] + [[package]] name = "percent-encoding" version = "2.3.1" @@ -3669,7 +4950,7 @@ dependencies = [ "pest_meta", "proc-macro2", "quote", - "syn 2.0.87", + "syn 2.0.101", ] [[package]] @@ -3705,6 +4986,16 @@ dependencies = [ "serde", ] +[[package]] +name = "pharos" +version = "0.5.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e9567389417feee6ce15dd6527a8a1ecac205ef62c2932bcf3d9f6fc5b78b414" +dependencies = [ + "futures 0.3.30", + "rustc_version 0.4.0", +] + [[package]] name = "phf" version = "0.11.2" @@ -3740,7 +5031,7 @@ checksum = "2f38a4412a78282e09a2cf38d195ea5420d15ba0602cb375210efbc877243965" dependencies = [ "proc-macro2", "quote", - "syn 2.0.87", + "syn 2.0.101", ] [[package]] @@ -3755,6 +5046,16 @@ version = "0.1.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "8b870d8c151b6f2fb93e84a13146138f05d02ed11c7e7c54f8826aaaf7c9f184" +[[package]] +name = "pkcs8" +version = "0.10.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f950b2377845cebe5cf8b5165cb3cc1a5e0fa5cfa3e1f7f55707d8fd82e0a7b7" +dependencies = [ + "der", + "spki", +] + [[package]] name = "pkg-config" version = "0.3.30" @@ -3854,7 +5155,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "5f12335488a2f3b0a83b14edad48dca9879ce89b2edd10e80237e4e852dd645e" dependencies = [ "proc-macro2", - "syn 2.0.87", + "syn 2.0.101", ] [[package]] @@ -3863,13 +5164,24 @@ version = "0.11.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "e28720988bff275df1f51b171e1b2a18c30d194c4d2b61defdacecd625a5d94a" dependencies = [ - "fixed-hash", + "fixed-hash 0.7.0", "impl-codec", "impl-rlp", "impl-serde", "uint 0.9.5", ] +[[package]] +name = "primitive-types" +version = "0.12.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0b34d9fd68ae0b74a41b21c03c2f62847aa0ffea044eee893b4c140b37e244e2" +dependencies = [ + "fixed-hash 0.8.0", + "impl-codec", + "uint 0.9.5", +] + [[package]] name = "priority-queue" version = "2.3.1" @@ -3890,6 +5202,28 @@ dependencies = [ "toml_edit 0.21.1", ] +[[package]] +name = "proc-macro-error-attr2" +version = "2.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "96de42df36bb9bba5542fe9f1a054b8cc87e172759a1868aa05c1f3acc89dfc5" +dependencies = [ + "proc-macro2", + "quote", +] + +[[package]] +name = "proc-macro-error2" +version = "2.0.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "11ec05c52be0a07b08061f7dd003e7d7092e0472bc731b4af7bb1ef876109802" +dependencies = [ + "proc-macro-error-attr2", + "proc-macro2", + "quote", + "syn 2.0.101", +] + [[package]] name = "proc-macro-utils" version = "0.10.0" @@ -3927,6 +5261,26 @@ dependencies = [ "thiserror 1.0.61", ] +[[package]] +name = "proptest" +version = "1.6.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "14cae93065090804185d3b75f0bf93b8eeda30c7a9b4a33d3bdb3988d6229e50" +dependencies = [ + "bit-set", + "bit-vec", + "bitflags 2.6.0", + "lazy_static", + "num-traits", + "rand 0.8.5", + "rand_chacha 0.3.1", + "rand_xorshift", + "regex-syntax", + "rusty-fork", + "tempfile", + "unarray", +] + [[package]] name = "prost" version = "0.13.5" @@ -3953,7 +5307,7 @@ dependencies = [ "prost", "prost-types", "regex", - "syn 2.0.87", + "syn 2.0.101", "tempfile", ] @@ -3967,7 +5321,7 @@ dependencies = [ "itertools 0.13.0", "proc-macro2", "quote", - "syn 2.0.87", + "syn 2.0.101", ] [[package]] @@ -4030,6 +5384,12 @@ dependencies = [ "cc", ] +[[package]] +name = "quick-error" +version = "1.2.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a1d01941d82fa2ab50be1e79e6714289dd7cde78eba4c074bc5a4374f650dfe0" + [[package]] name = "quick-xml" version = "0.36.2" @@ -4066,7 +5426,7 @@ dependencies = [ "bytes", "rand 0.8.5", "ring", - "rustc-hash 2.0.0", + "rustc-hash 2.1.1", "rustls", "slab", "thiserror 1.0.61", @@ -4122,6 +5482,7 @@ dependencies = [ "libc", "rand_chacha 0.3.1", "rand_core 0.6.4", + "serde", ] [[package]] @@ -4132,6 +5493,7 @@ checksum = "9fbfd9d094a40bf3ae768db9361049ace4c0e04a4fd6b359518bd7b73a73dd97" dependencies = [ "rand_chacha 0.9.0", "rand_core 0.9.3", + "serde", ] [[package]] @@ -4170,6 +5532,16 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "99d9a13982dcf210057a8a78572b2217b667c3beacbf3a0d8b454f6f82837d38" dependencies = [ "getrandom 0.3.1", + "serde", +] + +[[package]] +name = "rand_xorshift" +version = "0.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d25bf25ec5ae4a3f1b92f929810509a2f53d7dca2f50b794ff57e3face536c8f" +dependencies = [ + "rand_core 0.6.4", ] [[package]] @@ -4192,6 +5564,12 @@ dependencies = [ "crossbeam-utils", ] +[[package]] +name = "recvmsg" +version = "1.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d3edd4d5d42c92f0a659926464d4cce56b562761267ecf0f469d85b7de384175" + [[package]] name = "redox_syscall" version = "0.1.57" @@ -4322,6 +5700,16 @@ dependencies = [ "windows-registry", ] +[[package]] +name = "rfc6979" +version = "0.4.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f8dd2a808d456c4a54e300a23e9f5a67e122c3024119acbfd73e3bf664491cb2" +dependencies = [ + "hmac", + "subtle", +] + [[package]] name = "ring" version = "0.17.13" @@ -4346,6 +5734,39 @@ dependencies = [ "rustc-hex", ] +[[package]] +name = "ruint" +version = "1.14.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "78a46eb779843b2c4f21fac5773e25d6d5b7c8f0922876c91541790d2ca27eef" +dependencies = [ + "alloy-rlp", + "ark-ff 0.3.0", + "ark-ff 0.4.2", + "bytes", + "fastrlp 0.3.1", + "fastrlp 0.4.0", + "num-bigint 0.4.6", + "num-integer", + "num-traits", + "parity-scale-codec", + "primitive-types 0.12.2", + "proptest", + "rand 0.8.5", + "rand 0.9.1", + "rlp", + "ruint-macro", + "serde", + "valuable", + "zeroize", +] + +[[package]] +name = "ruint-macro" +version = "1.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "48fd7bd8a6377e15ad9d42a8ec25371b94ddc67abe7c8b9127bec79bebaaae18" + [[package]] name = "rustc-demangle" version = "0.1.24" @@ -4360,9 +5781,9 @@ checksum = "08d43f7aa6b08d49f382cde6a7982047c3426db949b1424bc4b7ec9ae12c6ce2" [[package]] name = "rustc-hash" -version = "2.0.0" +version = "2.1.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "583034fd73374156e66797ed8e5b0d5690409c9226b22d87cb7f19821c05d152" +checksum = "357703d41365b4b27c590e3ed91eabb1b663f07c4c084095e60cbed4362dff0d" [[package]] name = "rustc-hex" @@ -4370,13 +5791,22 @@ version = "2.1.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "3e75f6a532d0fd9f7f13144f392b6ad56a32696bfcd9c78f797f16bbb6f072d6" +[[package]] +name = "rustc_version" +version = "0.3.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f0dfe2087c51c460008730de8b57e6a320782fbfb312e1f4d520e6c6fae155ee" +dependencies = [ + "semver 0.11.0", +] + [[package]] name = "rustc_version" version = "0.4.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "bfa0f585226d2e68097d4f95d113b15b83a82e819ab25717ec0590d9584ef366" dependencies = [ - "semver", + "semver 1.0.23", ] [[package]] @@ -4465,6 +5895,18 @@ version = "1.0.17" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "955d28af4278de8121b7ebeb796b6a45735dc01436d898801014aced2773a3d6" +[[package]] +name = "rusty-fork" +version = "0.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cb3dcc6e454c328bb824492db107ab7c0ae8fcffe4ad210136ef014458c1bc4f" +dependencies = [ + "fnv", + "quick-error", + "tempfile", + "wait-timeout", +] + [[package]] name = "ryu" version = "1.0.18" @@ -4504,13 +5946,40 @@ version = "1.2.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "94143f37725109f92c262ed2cf5e59bce7498c01bcc1502d7b9afe439a4e9f49" +[[package]] +name = "sec1" +version = "0.7.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d3e97a565f76233a6003f9f5c54be1d9c5bdfa3eccfb189469f11ec4901c47dc" +dependencies = [ + "base16ct", + "der", + "generic-array", + "pkcs8", + "serdect", + "subtle", + "zeroize", +] + [[package]] name = "secp256k1" version = "0.21.3" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "9c42e6f1735c5f00f51e43e28d6634141f2bcad10931b2609ddd74a86d751260" dependencies = [ - "secp256k1-sys", + "secp256k1-sys 0.4.2", +] + +[[package]] +name = "secp256k1" +version = "0.30.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b50c5943d326858130af85e049f2661ba3c78b26589b8ab98e65e80ae44a1252" +dependencies = [ + "bitcoin_hashes", + "rand 0.8.5", + "secp256k1-sys 0.10.1", + "serde", ] [[package]] @@ -4522,6 +5991,15 @@ dependencies = [ "cc", ] +[[package]] +name = "secp256k1-sys" +version = "0.10.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d4387882333d3aa8cb20530a17c69a3752e97837832f34f6dccc760e715001d9" +dependencies = [ + "cc", +] + [[package]] name = "security-framework" version = "2.11.0" @@ -4558,6 +6036,15 @@ dependencies = [ "libc", ] +[[package]] +name = "semver" +version = "0.11.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f301af10236f6df4160f7c3f04eec6dbc70ace82d23326abad5edee88801c6b6" +dependencies = [ + "semver-parser", +] + [[package]] name = "semver" version = "1.0.23" @@ -4567,6 +6054,21 @@ dependencies = [ "serde", ] +[[package]] +name = "semver-parser" +version = "0.10.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9900206b54a3527fdc7b8a938bffd94a568bac4f4aa8113b209df75a09c0dec2" +dependencies = [ + "pest", +] + +[[package]] +name = "send_wrapper" +version = "0.6.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cd0b0ec5f1c1ca621c432a25813d8d60c88abe6d3e08a3eb9cf37d97a0fe3d73" + [[package]] name = "serde" version = "1.0.204" @@ -4584,7 +6086,7 @@ checksum = "e0cd7e117be63d3c3678776753929474f3b04a43a080c744d6b0ae2a8c28e222" dependencies = [ "proc-macro2", "quote", - "syn 2.0.87", + "syn 2.0.101", ] [[package]] @@ -4660,7 +6162,25 @@ dependencies = [ "indexmap 1.9.3", "serde", "serde_json", - "serde_with_macros", + "serde_with_macros 2.3.3", + "time", +] + +[[package]] +name = "serde_with" +version = "3.12.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d6b6f7f2fcb69f747921f79f3926bd1e203fce4fef62c268dd3abfb6d86029aa" +dependencies = [ + "base64 0.22.1", + "chrono", + "hex", + "indexmap 1.9.3", + "indexmap 2.9.0", + "serde", + "serde_derive", + "serde_json", + "serde_with_macros 3.12.0", "time", ] @@ -4673,7 +6193,19 @@ dependencies = [ "darling", "proc-macro2", "quote", - "syn 2.0.87", + "syn 2.0.101", +] + +[[package]] +name = "serde_with_macros" +version = "3.12.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8d00caa5193a3c8362ac2b73be6b9e768aa5a4b2f721d8f4b339600c3cb51f8e" +dependencies = [ + "darling", + "proc-macro2", + "quote", + "syn 2.0.101", ] [[package]] @@ -4689,6 +6221,16 @@ dependencies = [ "unsafe-libyaml", ] +[[package]] +name = "serdect" +version = "0.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a84f14a19e9a014bb9f4512488d9829a68e04ecabffb0f9904cd1ace94598177" +dependencies = [ + "base16ct", + "serde", +] + [[package]] name = "sha-1" version = "0.9.8" @@ -4734,6 +6276,16 @@ dependencies = [ "keccak", ] +[[package]] +name = "sha3-asm" +version = "0.1.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c28efc5e327c837aa837c59eae585fc250715ef939ac32881bcc11677cd02d46" +dependencies = [ + "cc", + "cfg-if 1.0.0", +] + [[package]] name = "shellexpand" version = "3.1.0" @@ -4758,6 +6310,28 @@ dependencies = [ "libc", ] +[[package]] +name = "signature" +version = "2.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "77549399552de45a898a580c1b41d445bf730df867cc44e6c0233bbc4b8329de" +dependencies = [ + "digest 0.10.7", + "rand_core 0.6.4", +] + +[[package]] +name = "simple_asn1" +version = "0.6.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "297f631f50729c8c99b84667867963997ec0b50f32b2a7dbcab828ef0541e8bb" +dependencies = [ + "num-bigint 0.4.6", + "num-traits", + "thiserror 2.0.12", + "time", +] + [[package]] name = "siphasher" version = "0.3.11" @@ -4852,6 +6426,9 @@ name = "smallvec" version = "1.13.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "3c5e1a9a646d36c3599cd173a41282daf47c44583ad367b8e6837255952e5c67" +dependencies = [ + "serde", +] [[package]] name = "snafu" @@ -4871,7 +6448,7 @@ dependencies = [ "heck 0.5.0", "proc-macro2", "quote", - "syn 2.0.87", + "syn 2.0.101", ] [[package]] @@ -4905,6 +6482,16 @@ version = "0.9.8" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "6980e8d7511241f8acf4aebddbb1ff938df5eebe98691418c4468d0b72a96a67" +[[package]] +name = "spki" +version = "0.7.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d91ed6c858b01f942cd56b37a94b3e0a1798290327d1236e4d9cf4eaca44d29d" +dependencies = [ + "base64ct", + "der", +] + [[package]] name = "sptr" version = "0.3.2" @@ -4992,6 +6579,15 @@ dependencies = [ "strum_macros 0.26.4", ] +[[package]] +name = "strum" +version = "0.27.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f64def088c51c9510a8579e3c5d67c65349dcf755e5479ad3d010aa6454e2c32" +dependencies = [ + "strum_macros 0.27.1", +] + [[package]] name = "strum_macros" version = "0.26.4" @@ -5002,7 +6598,7 @@ dependencies = [ "proc-macro2", "quote", "rustversion", - "syn 2.0.87", + "syn 2.0.101", ] [[package]] @@ -5015,7 +6611,7 @@ dependencies = [ "proc-macro2", "quote", "rustversion", - "syn 2.0.87", + "syn 2.0.101", ] [[package]] @@ -5115,15 +6711,27 @@ dependencies = [ [[package]] name = "syn" -version = "2.0.87" +version = "2.0.101" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "25aa4ce346d03a6dcd68dd8b4010bcb74e54e62c90c573f394c46eae99aba32d" +checksum = "8ce2b7fc941b3a24138a0a7cf8e858bfc6a992e7978a068a5c760deb0ed43caf" dependencies = [ "proc-macro2", "quote", "unicode-ident", ] +[[package]] +name = "syn-solidity" +version = "1.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3d0f0d4760f4c2a0823063b2c70e97aa2ad185f57be195172ccc0e23c4b787c4" +dependencies = [ + "paste", + "proc-macro2", + "quote", + "syn 2.0.101", +] + [[package]] name = "sync_wrapper" version = "0.1.2" @@ -5147,7 +6755,7 @@ checksum = "c8af7666ab7b6390ab78131fb5b0fce11d6b7a6951602017c35fa82800708971" dependencies = [ "proc-macro2", "quote", - "syn 2.0.87", + "syn 2.0.101", ] [[package]] @@ -5246,6 +6854,7 @@ dependencies = [ "lazy_static", "pretty_assertions", "prost-types", + "serde_json", ] [[package]] @@ -5274,7 +6883,7 @@ checksum = "46c3384250002a6d5af4d114f2845d37b57521033f30d5c3f46c4d70e1197533" dependencies = [ "proc-macro2", "quote", - "syn 2.0.87", + "syn 2.0.101", ] [[package]] @@ -5285,7 +6894,7 @@ checksum = "7f7cf42b4507d8ea322120659672cf1b9dbb93f8f2d4ecfd6e51350ff5b17a1d" dependencies = [ "proc-macro2", "quote", - "syn 2.0.87", + "syn 2.0.101", ] [[package]] @@ -5298,6 +6907,15 @@ dependencies = [ "once_cell", ] +[[package]] +name = "threadpool" +version = "1.8.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d050e60b33d41c19108b32cea32164033a9013fe3b46cbd4457559bfbf77afaa" +dependencies = [ + "num_cpus", +] + [[package]] name = "time" version = "0.3.36" @@ -5398,7 +7016,7 @@ checksum = "6e06d43f1345a3bcd39f6a56dbb7dcab2ba47e68e8ac134855e7e2bdbaf8cab8" dependencies = [ "proc-macro2", "quote", - "syn 2.0.87", + "syn 2.0.101", ] [[package]] @@ -5504,8 +7122,12 @@ checksum = "7a9daff607c6d2bf6c16fd681ccb7eecc83e4e2cdc1ca067ffaadfca5de7f084" dependencies = [ "futures-util", "log", + "rustls", + "rustls-pki-types", "tokio", + "tokio-rustls", "tungstenite", + "webpki-roots 0.26.11", ] [[package]] @@ -5636,7 +7258,7 @@ dependencies = [ "prost-build", "prost-types", "quote", - "syn 2.0.87", + "syn 2.0.101", ] [[package]] @@ -5765,7 +7387,7 @@ checksum = "34704c8d6ebcbc939824180af020566b01a7c01f80641264eba0999f6c2b6be7" dependencies = [ "proc-macro2", "quote", - "syn 2.0.87", + "syn 2.0.101", ] [[package]] @@ -5783,6 +7405,8 @@ version = "0.2.5" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "97d095ae15e245a057c8e8451bab9b3ee1e1f68e9ba2b4fbc18d0ac5237835f2" dependencies = [ + "futures 0.3.30", + "futures-task", "pin-project", "tracing", ] @@ -5812,6 +7436,8 @@ dependencies = [ "httparse", "log", "rand 0.9.1", + "rustls", + "rustls-pki-types", "sha1", "thiserror 2.0.12", "utf-8", @@ -5853,6 +7479,12 @@ dependencies = [ "static_assertions", ] +[[package]] +name = "unarray" +version = "0.1.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "eaea85b334db583fe3274d12b4cd1880032beab409c0d774be044d4480ab9a94" + [[package]] name = "unicase" version = "2.7.0" @@ -5987,6 +7619,12 @@ version = "1.15.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "e0f540e3240398cce6128b64ba83fdbdd86129c16a3aa1a3a252efd66eb3d587" +[[package]] +name = "valuable" +version = "0.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ba73ea9cf16a25df0c8caa16c51acb937d5712a8429db78a3ee29d5dcacd3a65" + [[package]] name = "vcpkg" version = "0.2.15" @@ -6005,6 +7643,15 @@ version = "1.0.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "6a02e4885ed3bc0f2de90ea6dd45ebcbb66dacffe03547fadbb0eeae2770887d" +[[package]] +name = "wait-timeout" +version = "0.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "09ac3b126d3914f9849036f826e054cbabdc8519970b8998ddaf3b5bd3c65f11" +dependencies = [ + "libc", +] + [[package]] name = "walkdir" version = "2.5.0" @@ -6067,7 +7714,7 @@ dependencies = [ "log", "proc-macro2", "quote", - "syn 2.0.87", + "syn 2.0.101", "wasm-bindgen-shared", ] @@ -6101,7 +7748,7 @@ checksum = "8ae87ea40c9f689fc23f209965b6fb8a99ad69aeeb0231408be24920604395de" dependencies = [ "proc-macro2", "quote", - "syn 2.0.87", + "syn 2.0.101", "wasm-bindgen-backend", "wasm-bindgen-shared", ] @@ -6162,7 +7809,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "a58e28b80dd8340cb07b8242ae654756161f6fc8d0038123d679b7b99964fa50" dependencies = [ "indexmap 2.9.0", - "semver", + "semver 1.0.23", ] [[package]] @@ -6172,7 +7819,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "77f1154f1ab868e2a01d9834a805faca7bf8b50d041b4ca714d005d0dab1c50c" dependencies = [ "indexmap 2.9.0", - "semver", + "semver 1.0.23", ] [[package]] @@ -6250,7 +7897,7 @@ dependencies = [ "anyhow", "proc-macro2", "quote", - "syn 2.0.87", + "syn 2.0.101", "wasmtime-component-util", "wasmtime-wit-bindgen", "wit-parser", @@ -6438,7 +8085,7 @@ checksum = "f50f51f8d79bfd2aa8e9d9a0ae7c2d02b45fe412e62ff1b87c0c81b07c738231" dependencies = [ "proc-macro2", "quote", - "syn 2.0.87", + "syn 2.0.101", ] [[package]] @@ -6459,6 +8106,20 @@ version = "15.0.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "9b6060bc082cc32d9a45587c7640e29e3c7b89ada82677ac25d87850aaccb368" +[[package]] +name = "wasmtimer" +version = "0.4.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0048ad49a55b9deb3953841fa1fc5858f0efbcb7a18868c899a360269fac1b23" +dependencies = [ + "futures 0.3.30", + "js-sys", + "parking_lot", + "pin-utils", + "slab", + "wasm-bindgen", +] + [[package]] name = "wast" version = "212.0.0" @@ -6514,7 +8175,7 @@ dependencies = [ "pin-project", "reqwest", "rlp", - "secp256k1", + "secp256k1 0.21.3", "serde", "serde_json", "soketto", @@ -6538,6 +8199,24 @@ dependencies = [ "url", ] +[[package]] +name = "webpki-roots" +version = "0.26.11" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "521bc38abb08001b01866da9f51eb7c5d647a19260e00054a8c7fd5f9e57f7a9" +dependencies = [ + "webpki-roots 1.0.0", +] + +[[package]] +name = "webpki-roots" +version = "1.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2853738d1cc4f2da3a225c18ec6c3721abb31961096e9dbf5ab35fa88b19cfdb" +dependencies = [ + "rustls-pki-types", +] + [[package]] name = "which" version = "4.4.2" @@ -6561,6 +8240,12 @@ dependencies = [ "web-sys", ] +[[package]] +name = "widestring" +version = "1.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "dd7cf3379ca1aac9eea11fba24fd7e315d621f8dfe35c8d7d2be8b793726e07d" + [[package]] name = "winapi" version = "0.3.9" @@ -6866,6 +8551,15 @@ dependencies = [ "memchr", ] +[[package]] +name = "winnow" +version = "0.7.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d9fb597c990f03753e08d3c29efbfcf2019a003b4bf4ba19225c158e1549f0f3" +dependencies = [ + "memchr", +] + [[package]] name = "wiremock" version = "0.6.2" @@ -6909,7 +8603,7 @@ dependencies = [ "id-arena", "indexmap 2.9.0", "log", - "semver", + "semver 1.0.23", "serde", "serde_derive", "serde_json", @@ -6928,6 +8622,25 @@ version = "0.5.5" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "1e9df38ee2d2c3c5948ea468a8406ff0db0b29ae1ffde1bcf20ef305bcc95c51" +[[package]] +name = "ws_stream_wasm" +version = "0.7.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7999f5f4217fe3818726b66257a4475f71e74ffd190776ad053fa159e50737f5" +dependencies = [ + "async_io_stream", + "futures 0.3.30", + "js-sys", + "log", + "pharos", + "rustc_version 0.4.0", + "send_wrapper", + "thiserror 1.0.61", + "wasm-bindgen", + "wasm-bindgen-futures", + "web-sys", +] + [[package]] name = "wyz" version = "0.5.1" @@ -6969,7 +8682,7 @@ checksum = "2380878cad4ac9aac1e2435f3eb4020e8374b5f13c296cb75b4620ff8e229154" dependencies = [ "proc-macro2", "quote", - "syn 2.0.87", + "syn 2.0.101", "synstructure", ] @@ -6990,7 +8703,7 @@ checksum = "fa4f8080344d4671fb4e831a13ad1e68092748387dfc4f55e356242fae12ce3e" dependencies = [ "proc-macro2", "quote", - "syn 2.0.87", + "syn 2.0.101", ] [[package]] @@ -7010,7 +8723,7 @@ checksum = "d71e5d6e06ab090c67b5e44993ec16b72dcbaabc526db883a360057678b48502" dependencies = [ "proc-macro2", "quote", - "syn 2.0.87", + "syn 2.0.101", "synstructure", ] @@ -7019,6 +8732,20 @@ name = "zeroize" version = "1.8.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "ced3678a2879b30306d323f4542626697a464a97c0a07c9aebf7ebca65cd4dde" +dependencies = [ + "zeroize_derive", +] + +[[package]] +name = "zeroize_derive" +version = "1.4.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ce36e65b0d2999d2aafac989fb249189a141aee1f53c612c1f37d72631959f69" +dependencies = [ + "proc-macro2", + "quote", + "syn 2.0.101", +] [[package]] name = "zerovec" @@ -7039,7 +8766,7 @@ checksum = "6eafa6dfb17584ea3e2bd6e76e0cc15ad7af12b09abdd1ca55961bed9b1063c6" dependencies = [ "proc-macro2", "quote", - "syn 2.0.87", + "syn 2.0.101", ] [[package]] diff --git a/Cargo.toml b/Cargo.toml index 78694e06d1c..18843d7ac35 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -39,6 +39,8 @@ repository = "https://github.com/graphprotocol/graph-node" license = "MIT OR Apache-2.0" [workspace.dependencies] +alloy = { version = "0.15.10", features = ["full"] } +alloy-rpc-types = "0.15.10" anyhow = "1.0" async-graphql = { version = "7.0.15", features = ["chrono"] } async-graphql-axum = "7.0.15" diff --git a/chain/ethereum/Cargo.toml b/chain/ethereum/Cargo.toml index c72772aaa95..8786914563b 100644 --- a/chain/ethereum/Cargo.toml +++ b/chain/ethereum/Cargo.toml @@ -4,6 +4,8 @@ version.workspace = true edition.workspace = true [dependencies] +alloy.workspace = true +alloy-rpc-types.workspace = true envconfig = "0.11.0" jsonrpc-core = "18.0.0" graph = { path = "../../graph" } diff --git a/chain/ethereum/src/adapter.rs b/chain/ethereum/src/adapter.rs index 93a7fc60781..47ea9950e3d 100644 --- a/chain/ethereum/src/adapter.rs +++ b/chain/ethereum/src/adapter.rs @@ -1,5 +1,5 @@ use anyhow::Error; -use ethabi::{Error as ABIError, ParamType, Token}; +use graph::abi; use graph::blockchain::ChainIdentifier; use graph::components::subgraph::MappingError; use graph::data::store::ethereum::call; @@ -101,13 +101,12 @@ pub enum EthereumRpcError { #[derive(Error, Debug)] pub enum ContractCallError { - #[error("ABI error: {0}")] - ABIError(#[from] ABIError), - /// `Token` is not of expected `ParamType` - #[error("type mismatch, token {0:?} is not of kind {1:?}")] - TypeError(Token, ParamType), - #[error("error encoding input call data: {0}")] - EncodingError(ethabi::Error), + #[error("ABI error: {0:#}")] + ABIError(anyhow::Error), + #[error("type mismatch, decoded value {0:?} is not of kind {1:?}")] + TypeError(abi::DynSolValue, abi::DynSolType), + #[error("error encoding input call data: {0:#}")] + EncodingError(anyhow::Error), #[error("call error: {0}")] Web3Error(web3::Error), #[error("ethereum node took too long to perform call")] @@ -1157,7 +1156,7 @@ pub trait EthereumAdapter: Send + Sync + 'static { logger: &Logger, call: &ContractCall, cache: Arc, - ) -> Result<(Option>, call::Source), ContractCallError>; + ) -> Result<(Option>, call::Source), ContractCallError>; /// Make multiple contract calls in a single batch. The returned `Vec` /// has results in the same order as the calls in `calls` on input. The @@ -1167,7 +1166,7 @@ pub trait EthereumAdapter: Send + Sync + 'static { logger: &Logger, calls: &[&ContractCall], cache: Arc, - ) -> Result>, call::Source)>, ContractCallError>; + ) -> Result>, call::Source)>, ContractCallError>; async fn get_balance( &self, @@ -1196,9 +1195,9 @@ mod tests { use graph::blockchain::TriggerFilter as _; use graph::firehose::{CallToFilter, CombinedFilter, LogFilter, MultiLogFilter}; use graph::petgraph::graphmap::GraphMap; - use graph::prelude::ethabi::ethereum_types::H256; use graph::prelude::web3::types::Address; use graph::prelude::web3::types::Bytes; + use graph::prelude::web3::types::H256; use graph::prelude::EthereumCall; use hex::ToHex; use itertools::Itertools; diff --git a/chain/ethereum/src/data_source.rs b/chain/ethereum/src/data_source.rs index a2da3e6cb4e..551ee21f246 100644 --- a/chain/ethereum/src/data_source.rs +++ b/chain/ethereum/src/data_source.rs @@ -1,5 +1,8 @@ use anyhow::{anyhow, Error}; use anyhow::{ensure, Context}; +use graph::abi; +use graph::abi::EventExt; +use graph::abi::FunctionExt; use graph::blockchain::{BlockPtr, TriggerWithHandler}; use graph::components::metrics::subgraph::SubgraphInstanceMetrics; use graph::components::store::{EthereumCallCache, StoredDynamicDataSource}; @@ -13,8 +16,8 @@ use graph::env::ENV_VARS; use graph::futures03::future::try_join; use graph::futures03::stream::FuturesOrdered; use graph::futures03::TryStreamExt; -use graph::prelude::ethabi::ethereum_types::H160; -use graph::prelude::ethabi::StateMutability; +use graph::prelude::web3::types::Address; +use graph::prelude::web3::types::H160; use graph::prelude::{Link, SubgraphManifestValidationError}; use graph::slog::{debug, error, o, trace}; use itertools::Itertools; @@ -30,9 +33,7 @@ use tiny_keccak::{keccak256, Keccak}; use graph::{ blockchain::{self, Blockchain}, prelude::{ - async_trait, - ethabi::{Address, Event, Function, LogParam, ParamType, RawLog}, - serde_json, warn, + async_trait, serde_json, warn, web3::types::{Log, Transaction, H256}, BlockNumber, CheapClone, EthereumCall, LightEthereumBlock, LightEthereumBlockExt, LinkResolver, Logger, @@ -525,28 +526,28 @@ impl DataSource { } } - /// Returns the contract event with the given signature, if it exists. A an event from the ABI + /// Returns the contract event with the given signature, if it exists. An event from the ABI /// will be matched if: /// 1. An event signature is equal to `signature`. /// 2. There are no equal matches, but there is exactly one event that equals `signature` if all /// `indexed` modifiers are removed from the parameters. - fn contract_event_with_signature(&self, signature: &str) -> Option<&Event> { + fn contract_event_with_signature(&self, signature: &str) -> Option<&abi::Event> { // Returns an `Event(uint256,address)` signature for an event, without `indexed` hints. - fn ambiguous_event_signature(event: &Event) -> String { + fn ambiguous_event_signature(event: &abi::Event) -> String { format!( "{}({})", event.name, event .inputs .iter() - .map(|input| event_param_type_signature(&input.kind)) + .map(|input| input.selector_type().into_owned()) .collect::>() .join(",") ) } // Returns an `Event(indexed uint256,address)` type signature for an event. - fn event_signature(event: &Event) -> String { + fn event_signature(event: &abi::Event) -> String { format!( "{}({})", event.name, @@ -556,40 +557,13 @@ impl DataSource { .map(|input| format!( "{}{}", if input.indexed { "indexed " } else { "" }, - event_param_type_signature(&input.kind) + input.selector_type() )) .collect::>() .join(",") ) } - // Returns the signature of an event parameter type (e.g. `uint256`). - fn event_param_type_signature(kind: &ParamType) -> String { - use ParamType::*; - - match kind { - Address => "address".into(), - Bytes => "bytes".into(), - Int(size) => format!("int{}", size), - Uint(size) => format!("uint{}", size), - Bool => "bool".into(), - String => "string".into(), - Array(inner) => format!("{}[]", event_param_type_signature(inner)), - FixedBytes(size) => format!("bytes{}", size), - FixedArray(inner, size) => { - format!("{}[{}]", event_param_type_signature(inner), size) - } - Tuple(components) => format!( - "({})", - components - .iter() - .map(event_param_type_signature) - .collect::>() - .join(",") - ), - } - } - self.contract_abi .contract .events() @@ -628,7 +602,9 @@ impl DataSource { }) } - fn contract_function_with_signature(&self, target_signature: &str) -> Option<&Function> { + fn contract_function_with_signature(&self, target_signature: &str) -> Option<&abi::Function> { + use abi::StateMutability; + self.contract_abi .contract .functions() @@ -642,7 +618,7 @@ impl DataSource { let mut arguments = function .inputs .iter() - .map(|input| format!("{}", input.kind)) + .map(|input| input.selector_type().into_owned()) .collect::>() .join(","); // `address,uint256,bool) @@ -732,11 +708,7 @@ impl DataSource { .into_iter() .filter_map(|(event_handler, event_abi)| { event_abi - .parse_log(RawLog { - topics: log.topics.clone(), - data: log.data.clone().0, - }) - .map(|log| log.params) + .decode_log(&log) .map_err(|e| { trace!( logger, @@ -841,20 +813,15 @@ impl DataSource { ) })?; - // Parse the inputs - // - // Take the input for the call, chop off the first 4 bytes, then call - // `function.decode_input` to get a vector of `Token`s. Match the `Token`s - // with the `Param`s in `function.inputs` to create a `Vec`. - let tokens = match function_abi.decode_input(&call.input.0[4..]).with_context( - || { + let values = match function_abi + .abi_decode_input(&call.input.0[4..]) + .with_context(|| { format!( "Generating function inputs for the call {:?} failed, raw input: {}", &function_abi, hex::encode(&call.input.0) ) - }, - ) { + }) { Ok(val) => val, // See also 280b0108-a96e-4738-bb37-60ce11eeb5bf Err(err) => { @@ -864,27 +831,22 @@ impl DataSource { }; ensure!( - tokens.len() == function_abi.inputs.len(), + values.len() == function_abi.inputs.len(), "Number of arguments in call does not match \ number of inputs in function signature." ); - let inputs = tokens + let inputs = values .into_iter() .enumerate() - .map(|(i, token)| LogParam { + .map(|(i, value)| abi::DynSolParam { name: function_abi.inputs[i].name.clone(), - value: token, + value, }) .collect::>(); - // Parse the outputs - // - // Take the output for the call, then call `function.decode_output` to - // get a vector of `Token`s. Match the `Token`s with the `Param`s in - // `function.outputs` to create a `Vec`. - let tokens = function_abi - .decode_output(&call.output.0) + let values = function_abi + .abi_decode_output(&call.output.0) .with_context(|| { format!( "Decoding function outputs for the call {:?} failed, raw output: {}", @@ -894,17 +856,17 @@ impl DataSource { })?; ensure!( - tokens.len() == function_abi.outputs.len(), + values.len() == function_abi.outputs.len(), "Number of parameters in the call output does not match \ number of outputs in the function signature." ); - let outputs = tokens + let outputs = values .into_iter() .enumerate() - .map(|(i, token)| LogParam { + .map(|(i, value)| abi::DynSolParam { name: function_abi.outputs[i].name.clone(), - value: token, + value, }) .collect::>(); diff --git a/chain/ethereum/src/ethereum_adapter.rs b/chain/ethereum/src/ethereum_adapter.rs index 1c1d214f6a5..fd230e74517 100644 --- a/chain/ethereum/src/ethereum_adapter.rs +++ b/chain/ethereum/src/ethereum_adapter.rs @@ -1,9 +1,16 @@ +use alloy::primitives::{TxKind, B256, B64}; +use alloy::providers::{Provider, ProviderBuilder}; +use alloy_rpc_types::{ + BlockTransactions, FilterBlockOption, TransactionInput, TransactionRequest, TransactionTrait, +}; use futures03::{future::BoxFuture, stream::FuturesUnordered}; +use graph::abi; +use graph::abi::DynSolValueExt; +use graph::abi::FunctionExt; use graph::blockchain::client::ChainClient; use graph::blockchain::BlockHash; use graph::blockchain::ChainIdentifier; use graph::blockchain::ExtendedBlockPtr; - use graph::components::transaction_receipt::LightTransactionReceipt; use graph::data::store::ethereum::call; use graph::data::store::scalar; @@ -17,10 +24,8 @@ use graph::futures03::future::try_join_all; use graph::futures03::{ self, compat::Future01CompatExt, FutureExt, StreamExt, TryFutureExt, TryStreamExt, }; -use graph::prelude::ethabi::ParamType; -use graph::prelude::ethabi::Token; use graph::prelude::tokio::try_join; -use graph::prelude::web3::types::U256; +use graph::prelude::web3::types::{H2048, H64, U256}; use graph::slog::o; use graph::tokio::sync::RwLock; use graph::tokio::time::timeout; @@ -28,8 +33,7 @@ use graph::{ blockchain::{block_stream::BlockWithTriggers, BlockPtr, IngestorError}, prelude::{ anyhow::{self, anyhow, bail, ensure, Context}, - async_trait, debug, error, ethabi, hex, info, retry, serde_json as json, tiny_keccak, - trace, warn, + async_trait, debug, error, hex, info, retry, serde_json as json, tiny_keccak, trace, warn, web3::{ self, types::{ @@ -50,6 +54,7 @@ use graph::{ use itertools::Itertools; use std::collections::{BTreeMap, BTreeSet, HashMap, HashSet}; use std::convert::TryFrom; +use std::fmt::Formatter; use std::iter::FromIterator; use std::pin::Pin; use std::sync::Arc; @@ -73,23 +78,32 @@ use crate::{ ENV_VARS, }; -#[derive(Debug, Clone)] +#[derive(Clone)] pub struct EthereumAdapter { logger: Logger, provider: String, web3: Arc>, + alloy: Arc, metrics: Arc, supports_eip_1898: bool, call_only: bool, supports_block_receipts: Arc>>, } +// TODO: remove this hacky implementation +impl std::fmt::Debug for EthereumAdapter { + fn fmt(&self, f: &mut Formatter) -> std::fmt::Result { + write!(f, "EthereumAdapter") + } +} + impl CheapClone for EthereumAdapter { fn cheap_clone(&self) -> Self { Self { logger: self.logger.clone(), provider: self.provider.clone(), web3: self.web3.cheap_clone(), + alloy: self.alloy.clone(), metrics: self.metrics.cheap_clone(), supports_eip_1898: self.supports_eip_1898, call_only: self.call_only, @@ -111,7 +125,18 @@ impl EthereumAdapter { supports_eip_1898: bool, call_only: bool, ) -> Self { + let rpc_url = match &transport { + Transport::RPC { + client: _, + metrics: _, + provider: _, + rpc_url, + } => rpc_url.clone(), + Transport::IPC(_ipc) => todo!(), + Transport::WS(_web_socket) => todo!(), + }; let web3 = Arc::new(Web3::new(transport)); + let alloy = Arc::new(ProviderBuilder::new().connect(&rpc_url).await.unwrap()); // Use the client version to check if it is ganache. For compatibility with unit tests, be // are lenient with errors, defaulting to false. @@ -126,6 +151,7 @@ impl EthereumAdapter { logger, provider, web3, + alloy, metrics: provider_metrics, supports_eip_1898: supports_eip_1898 && !is_ganache, call_only, @@ -141,6 +167,7 @@ impl EthereumAdapter { to: BlockNumber, addresses: Vec, ) -> Result, Error> { + info!(logger, "!!!! traces"); assert!(!self.call_only); let eth = self.clone(); @@ -231,6 +258,7 @@ impl EthereumAdapter { // cached. The result is not used for anything critical, so it is fine to be lazy. async fn check_block_receipt_support_and_update_cache( &self, + alloy: Arc, web3: Arc>, block_hash: H256, supports_eip_1898: bool, @@ -249,7 +277,7 @@ impl EthereumAdapter { info!(logger, "Checking eth_getBlockReceipts support"); let result = timeout( ENV_VARS.block_receipts_check_timeout, - check_block_receipt_support(web3, block_hash, supports_eip_1898, call_only), + check_block_receipt_support(alloy, web3, block_hash, supports_eip_1898, call_only), ) .await; @@ -314,6 +342,27 @@ impl EthereumAdapter { async move { let start = Instant::now(); + let block_option = FilterBlockOption::default() + .with_from_block((from as u64).into()) + .with_to_block((to as u64).into()); + let address: alloy_rpc_types::FilterSet = filter + .contracts + .iter() + .map(|c| h160_to_address(c)) + .collect(); + let topic0 = convert_topic(&Some(filter.event_signatures.clone())); + let topic1 = convert_topic(&filter.topic1); + let topic2 = convert_topic(&filter.topic2); + let topic3 = convert_topic(&filter.topic3); + let topics = [topic0, topic1, topic2, topic3]; + let filter2 = alloy_rpc_types::Filter { + block_option, + address, + topics, + }; + let result1 = eth_adapter.alloy.get_logs(&filter2).await.unwrap(); + let result2 = convert_log(&result1); + // Create a log filter let log_filter: Filter = FilterBuilder::default() .from_block(from.into()) @@ -328,15 +377,20 @@ impl EthereumAdapter { .build(); // Request logs from client - let result = eth_adapter.web3.eth().logs(log_filter).boxed().await; + let result3 = eth_adapter.web3.eth().logs(log_filter).boxed().await; + match &result3 { + Ok(res) => assert_eq!(&result2, res), + Err(_) => {} + } + // assert_eq!(Ok(result2), result3); let elapsed = start.elapsed().as_secs_f64(); provider_metrics.observe_request(elapsed, "eth_getLogs", &provider); subgraph_metrics.observe_request(elapsed, "eth_getLogs", &provider); - if result.is_err() { + if result3.is_err() { provider_metrics.add_error("eth_getLogs", &provider); subgraph_metrics.add_error("eth_getLogs", &provider); } - result + Ok(result2) } }) .await @@ -500,6 +554,17 @@ impl EthereumAdapter { } } + // Method to determine block_id based on support for EIP-1898 + fn block_ptr_to_id2(&self, block_ptr: &BlockPtr) -> alloy_rpc_types::BlockId { + // Ganache does not support calls by block hash. + // See https://github.com/trufflesuite/ganache-cli/issues/973 + if !self.supports_eip_1898 { + alloy_rpc_types::BlockId::number(block_ptr.number as u64) + } else { + alloy_rpc_types::BlockId::hash(h256_to_b256(&block_ptr.hash_as_h256())) + } + } + async fn code( &self, logger: &Logger, @@ -507,9 +572,12 @@ impl EthereumAdapter { block_ptr: BlockPtr, ) -> Result { let web3 = self.web3.clone(); + let alloy = self.alloy.clone(); let logger = Logger::new(&logger, o!("provider" => self.provider.clone())); let block_id = self.block_ptr_to_id(&block_ptr); + let block_id2 = self.block_ptr_to_id2(&block_ptr); + let address2 = h160_to_address(&address); let retry_log_message = format!("eth_getCode RPC call for block {}", block_ptr); retry(retry_log_message, &logger) @@ -522,11 +590,20 @@ impl EthereumAdapter { .timeout_secs(ENV_VARS.json_rpc_timeout.as_secs()) .run(move || { let web3 = web3.cheap_clone(); + let alloy = alloy.clone(); async move { let result: Result = web3.eth().code(address, Some(block_id)).boxed().await; + let result2 = alloy + .get_code_at(address2) + .block_id(block_id2) + .await + .map(bytes_to_bytes); match result { - Ok(code) => Ok(code), + Ok(code) => { + assert_eq!(result2.unwrap(), code); + Ok(code) + } Err(err) => Err(EthereumRpcError::Web3Error(err)), } } @@ -542,9 +619,12 @@ impl EthereumAdapter { block_ptr: BlockPtr, ) -> Result { let web3 = self.web3.clone(); + let alloy = self.alloy.clone(); let logger = Logger::new(&logger, o!("provider" => self.provider.clone())); let block_id = self.block_ptr_to_id(&block_ptr); + let block_id2 = self.block_ptr_to_id2(&block_ptr); + let address2 = h160_to_address(&address); let retry_log_message = format!("eth_getBalance RPC call for block {}", block_ptr); retry(retry_log_message, &logger) @@ -557,11 +637,20 @@ impl EthereumAdapter { .timeout_secs(ENV_VARS.json_rpc_timeout.as_secs()) .run(move || { let web3 = web3.cheap_clone(); + let alloy = alloy.clone(); async move { let result: Result = web3.eth().balance(address, Some(block_id)).boxed().await; + let result2 = alloy + .get_balance(address2) + .block_id(block_id2) + .await + .map(u256_to_u256); match result { - Ok(balance) => Ok(balance), + Ok(balance) => { + assert_eq!(result2.unwrap(), balance); + Ok(balance) + } Err(err) => Err(EthereumRpcError::Web3Error(err)), } } @@ -583,9 +672,11 @@ impl EthereumAdapter { } let web3 = self.web3.clone(); + let alloy = self.alloy.clone(); let logger = Logger::new(&logger, o!("provider" => self.provider.clone())); let block_id = self.block_ptr_to_id(&block_ptr); + let block_id2 = self.block_ptr_to_id2(&block_ptr); let retry_log_message = format!("eth_call RPC call for block {}", block_ptr); retry(retry_log_message, &logger) .redact_log_urls(true) @@ -594,6 +685,7 @@ impl EthereumAdapter { .run(move || { let call_data = call_data.clone(); let web3 = web3.cheap_clone(); + let alloy = alloy.clone(); let logger = logger.cheap_clone(); async move { let req = CallRequest { @@ -609,6 +701,37 @@ impl EthereumAdapter { transaction_type: None, }; let result = web3.eth().call(req, Some(block_id)).boxed().await; + let gas = gas.map(|val| val as u64); + let to = Some(TxKind::from(h160_to_address(&call_data.address))); + let input = TransactionInput { + input: None, + data: Some(alloy::primitives::Bytes::from( + call_data.encoded_call.to_vec(), + )), + }; + let tx_req = TransactionRequest { + from: None, + to, + gas_price: None, + max_fee_per_gas: None, + max_priority_fee_per_gas: None, + max_fee_per_blob_gas: None, + gas, + value: None, + input, + nonce: None, + chain_id: None, + access_list: None, + transaction_type: None, + blob_versioned_hashes: None, + sidecar: None, + authorization_list: None, + }; + let result2 = alloy + .call(tx_req) + .block(block_id2) + .await + .map(bytes_to_bytes); // Try to check if the call was reverted. The JSON-RPC response for reverts is // not standardized, so we have ad-hoc checks for each Ethereum client. @@ -664,15 +787,19 @@ impl EthereumAdapter { match bytes.len() >= 4 && &bytes[..4] == solidity_revert_function_selector { false => None, - true => ethabi::decode(&[ParamType::String], &bytes[4..]) + true => abi::DynSolType::String + .abi_decode(&bytes[4..]) .ok() - .and_then(|tokens| tokens[0].clone().into_string()), + .and_then(|val| val.clone().as_str().map(ToOwned::to_owned)), } }; match result { // A successful response. - Ok(bytes) => Ok(call::Retval::Value(scalar::Bytes::from(bytes))), + Ok(bytes) => { + assert_eq!(result2.unwrap(), bytes); + Ok(call::Retval::Value(scalar::Bytes::from(bytes))) + } // Check for Geth revert. Err(web3::Error::Rpc(rpc_error)) @@ -757,6 +884,67 @@ impl EthereumAdapter { Ok(req.response(result, call::Source::Rpc)) } + + async fn load_latest_block_rpc_alloy( + alloy: Arc, + logger: &Logger, + ) -> Result>>, anyhow::Error> { + let latest_block = alloy.get_block_number().await?; + Self::load_block_rpc_alloy(alloy, latest_block, logger).await + } + + async fn load_block_rpc_alloy( + alloy: Arc, + block_number: u64, + logger: &Logger, + ) -> Result>>, anyhow::Error> { + let number = alloy_rpc_types::BlockId::number(block_number); + let block = alloy + .get_block(number) + .await? + .map(|block| convert_block_hash_alloy2web3(&logger, block)); + Ok(block) + } + + async fn load_full_block_rpc_alloy( + alloy: Arc, + logger: Logger, + id: H256, + ) -> Result, anyhow::Error> { + let hash: alloy_rpc_types::BlockId = + alloy_rpc_types::BlockId::hash(B256::new(*id.as_fixed_bytes())); + let block = alloy.get_block(hash).full().await.unwrap(); + if let Some(block) = block { + Ok(convert_block_alloy2web3(&logger, block)) + } else { + Err(anyhow!("Ethereum node did not find block {:?}", hash)) + } + } + + fn load_blocks_rpc_alloy( + &self, + logger: Logger, + ids: Vec, + ) -> impl Stream, Error = Error> + Send { + let alloy = self.alloy.clone(); + let logger = logger.clone(); + + stream::iter_ok::<_, Error>(ids.into_iter().map(move |hash| { + let alloy = alloy.clone(); + let logger = logger.clone(); + + retry(format!("load block {}", hash), &logger) + .redact_log_urls(true) + .limit(ENV_VARS.request_retries) + .timeout_secs(ENV_VARS.json_rpc_timeout.as_secs()) + .run(move || Self::load_full_block_rpc_alloy(alloy.clone(), logger.clone(), hash)) + .boxed() + .compat() + .from_err() + })) + .buffered(ENV_VARS.block_batch_size) + } + /// Request blocks by hash through JSON-RPC. fn load_blocks_rpc( &self, @@ -796,9 +984,11 @@ impl EthereumAdapter { numbers: Vec, ) -> impl futures03::Stream, Error>> + Send { let web3 = self.web3.clone(); + let alloy = self.alloy.clone(); futures03::stream::iter(numbers.into_iter().map(move |number| { let web3 = web3.clone(); + let alloy = alloy.clone(); let logger = logger.clone(); async move { @@ -808,15 +998,24 @@ impl EthereumAdapter { .timeout_secs(ENV_VARS.json_rpc_timeout.as_secs()) .run(move || { let web3 = web3.clone(); + let alloy = alloy.clone(); + let logger = logger.clone(); async move { let block_result = web3 .eth() .block(BlockId::Number(Web3BlockNumber::Number(number.into()))) .await; - - match block_result { + let block_number = + alloy_rpc_types::BlockNumberOrTag::from(number as u64); + let block_result2 = + alloy.get_block_by_number(block_number).await.map(|block| { + block.map(|bl| convert_block_hash_alloy2web3(&logger, bl)) + }); + + let ret = match block_result { Ok(Some(block)) => { + assert_eq!(*block_result2.unwrap().unwrap(), block); let ptr = ExtendedBlockPtr::try_from(( block.hash, block.number, @@ -833,7 +1032,8 @@ impl EthereumAdapter { number )), Err(e) => Err(anyhow::anyhow!("Failed to fetch block: {}", e)), - } + }; + ret } }) .await @@ -848,6 +1048,56 @@ impl EthereumAdapter { .buffered(ENV_VARS.block_ptr_batch_size) } + /// Request blocks ptrs for numbers through JSON-RPC. + /// + /// Reorg safety: If ids are numbers, they must be a final blocks. + fn load_block_ptrs_rpc_alloy( + &self, + logger: Logger, + block_nums: Vec, + ) -> impl Stream + Send { + let alloy = self.alloy.clone(); + let logger = logger.clone(); + + stream::iter_ok::<_, Error>(block_nums.into_iter().map(move |block_num| { + let alloy = alloy.clone(); + retry(format!("load block ptr {}", block_num), &logger) + .redact_log_urls(true) + .when(|res| !res.is_ok() && !detect_null_block(res)) + .no_limit() + .timeout_secs(ENV_VARS.json_rpc_timeout.as_secs()) + .run({ + let logger = logger.clone(); + let ret = move || { + let alloy = alloy.clone(); + let logger = logger.clone(); + async move { + let block = + Self::load_block_rpc_alloy(alloy, block_num as u64, &logger).await; + block.transpose().unwrap().map(|b| (*b).clone()) + } + }; + ret + }) + .boxed() + .compat() + .from_err() + .then(|res| { + if detect_null_block(&res) { + Ok(None) + } else { + Some(res).transpose() + } + }) + })) + .buffered(ENV_VARS.block_batch_size) + .filter_map(|b| b) + .map(|b| { + let ret = b.into(); + ret + }) + } + /// Request blocks ptrs for numbers through JSON-RPC. /// /// Reorg safety: If ids are numbers, they must be a final blocks. @@ -857,6 +1107,7 @@ impl EthereumAdapter { block_nums: Vec, ) -> impl Stream + Send { let web3 = self.web3.clone(); + let logger = logger.clone(); stream::iter_ok::<_, Error>(block_nums.into_iter().map(move |block_num| { let web3 = web3.clone(); @@ -865,19 +1116,22 @@ impl EthereumAdapter { .when(|res| !res.is_ok() && !detect_null_block(res)) .no_limit() .timeout_secs(ENV_VARS.json_rpc_timeout.as_secs()) - .run(move || { - let web3 = web3.clone(); - async move { - let block = web3 - .eth() - .block(BlockId::Number(Web3BlockNumber::Number(block_num.into()))) - .boxed() - .await?; + .run({ + let ret = move || { + let web3 = web3.clone(); - block.ok_or_else(|| { - anyhow!("Ethereum node did not find block {:?}", block_num) - }) - } + async move { + let block = web3 + .eth() + .block(BlockId::Number(Web3BlockNumber::Number(block_num.into()))) + .boxed() + .await?; + block.ok_or_else(|| { + anyhow!("Ethereum node did not find block {:?}", block_num) + }) + } + }; + ret }) .boxed() .compat() @@ -952,6 +1206,7 @@ impl EthereumAdapter { to: BlockNumber, call_filter: &'a EthereumCallFilter, ) -> Box + Send + 'a> { + info!(logger, "!!!! calls_in_block_range"); let eth = self.clone(); let EthereumCallFilter { @@ -1129,6 +1384,20 @@ impl EthereumAdapter { .collect(), ) } + pub(crate) fn block_range_to_ptrs_alloy( + &self, + logger: Logger, + from: BlockNumber, + to: BlockNumber, + ) -> Box, Error = Error> + Send> { + // Currently we can't go to the DB for this because there might be duplicate entries for + // the same block number. + debug!(&logger, "Requesting hashes for blocks [{}, {}]", from, to); + Box::new( + self.load_block_ptrs_rpc_alloy(logger, (from..=to).collect()) + .collect(), + ) + } pub(crate) fn load_ptrs_for_blocks( &self, @@ -1144,6 +1413,7 @@ impl EthereumAdapter { pub async fn chain_id(&self) -> Result { let logger = self.logger.clone(); let web3 = self.web3.clone(); + let alloy = self.alloy.clone(); u64::try_from( retry("chain_id RPC call", &logger) .redact_log_urls(true) @@ -1151,7 +1421,16 @@ impl EthereumAdapter { .timeout_secs(ENV_VARS.json_rpc_timeout.as_secs()) .run(move || { let web3 = web3.cheap_clone(); - async move { web3.eth().chain_id().await } + let alloy = alloy.clone(); + async move { + let ch = web3.eth().chain_id().await; + let ch2 = alloy.get_chain_id().await.map(u64_to_u256); + match (&ch, &ch2) { + (Ok(c1), Ok(c2)) => assert_eq!(c1, c2), + (_, _) => panic!("chain_id"), + }; + ch + } }) .await?, ) @@ -1169,6 +1448,135 @@ fn detect_null_block(res: &Result) -> bool { } } +impl EthereumAdapter { + async fn latest_block_header_alloy( + &self, + logger: &Logger, + ) -> Result>, IngestorError> { + let alloy = self.alloy.clone(); + let logger2 = logger.clone(); + retry("eth_getBlockByNumber(latest) no txs RPC call", &logger2) + .redact_log_urls(true) + .no_limit() + .timeout_secs(ENV_VARS.json_rpc_timeout.as_secs()) + .run(move || { + let alloy = alloy.clone(); + let logger = logger2.clone(); + async move { + let block_opt = Self::load_latest_block_rpc_alloy(alloy, &logger) + .await + .map_err(|e| anyhow!("could not get latest block from Ethereum: {}", e))?; + + block_opt + .ok_or_else(|| anyhow!("no latest block returned from Ethereum").into()) + } + }) + .map_err(move |e| { + e.into_inner().unwrap_or_else(move || { + anyhow!("Ethereum node took too long to return latest block").into() + }) + }) + .await + } + + async fn latest_block_header_web3( + &self, + logger: &Logger, + ) -> Result, IngestorError> { + let web3 = self.web3.clone(); + retry("eth_getBlockByNumber(latest) no txs RPC call", logger) + .redact_log_urls(true) + .no_limit() + .timeout_secs(ENV_VARS.json_rpc_timeout.as_secs()) + .run(move || { + let web3 = web3.cheap_clone(); + async move { + let block_opt = web3 + .eth() + .block(Web3BlockNumber::Latest.into()) + .await + .map_err(|e| anyhow!("could not get latest block from Ethereum: {}", e))?; + + block_opt + .ok_or_else(|| anyhow!("no latest block returned from Ethereum").into()) + } + }) + .map_err(move |e| { + e.into_inner().unwrap_or_else(move || { + anyhow!("Ethereum node took too long to return latest block").into() + }) + }) + .await + } + + async fn block_by_hash_alloy( + &self, + logger: &Logger, + block_hash: H256, + ) -> Result, Error> { + let alloy = self.alloy.clone(); + let logger = logger.clone(); + let retry_log_message = format!( + "eth_getBlockByHash RPC call for block hash {:?}", + block_hash + ); + + retry(retry_log_message, &logger) + .redact_log_urls(true) + .limit(ENV_VARS.request_retries) + .timeout_secs(ENV_VARS.json_rpc_timeout.as_secs()) + .run(move || { + let alloy = alloy.clone(); + let logger = logger.clone(); + async move { + Self::load_full_block_rpc_alloy(alloy.clone(), logger.clone(), block_hash) + .await + .map_err(Error::from) + } + }) + .map_err(move |e| { + e.into_inner().unwrap_or_else(move || { + anyhow!("Ethereum node took too long to return block {}", block_hash) + }) + }) + .await + .map(|block| Some((*block).clone())) + } + + async fn block_by_hash_web3( + &self, + logger: &Logger, + block_hash: H256, + ) -> Result, Error> { + let web3 = self.web3.clone(); + let logger = logger.clone(); + let retry_log_message = format!( + "eth_getBlockByHash RPC call for block hash {:?}", + block_hash + ); + + retry(retry_log_message, &logger) + .redact_log_urls(true) + .limit(ENV_VARS.request_retries) + .timeout_secs(ENV_VARS.json_rpc_timeout.as_secs()) + .run(move || { + let web3 = web3.cheap_clone(); + async move { + web3.eth() + .block_with_txs(BlockId::Hash(block_hash)) + .await + .map_err(Error::from) + } + }) + .map_err(move |e| { + e.into_inner().unwrap_or_else(move || { + anyhow!("Ethereum node took too long to return block {}", block_hash) + }) + }) + .await + } +} + #[async_trait] impl EthereumAdapterTrait for EthereumAdapter { fn provider(&self) -> &str { @@ -1198,31 +1606,92 @@ impl EthereumAdapterTrait for EthereumAdapter { }) .map_err(|e| { self.metrics - .set_status(ProviderStatus::VersionTimeout, self.provider()); + .set_status(ProviderStatus::VersionTimeout, self.provider()); + e + }) + .boxed(); + let alloy = self.alloy.clone(); + let metrics = self.metrics.clone(); + let provider = self.provider().to_string(); + let net_version_future2 = retry("net_version RPC call", &logger) + .redact_log_urls(true) + .no_limit() + .timeout_secs(20) + .run(move || { + let alloy = alloy.cheap_clone(); + let metrics = metrics.cheap_clone(); + let provider = provider.clone(); + async move { + alloy + .get_net_version() + .await + .map(|version| format!("{}", version)) + .map_err(|e| { + metrics.set_status(ProviderStatus::VersionFail, &provider); + e.into() + }) + } + }) + .map_err(|e| { + self.metrics + .set_status(ProviderStatus::VersionTimeout, self.provider()); + e + }) + .boxed(); + + let web3 = self.web3.clone(); + let metrics = self.metrics.clone(); + let provider = self.provider().to_string(); + let retry_log_message = format!( + "eth_getBlockByNumber({}, false) RPC call", + ENV_VARS.genesis_block_number + ); + let gen_block_hash_future = retry(retry_log_message, &logger) + .redact_log_urls(true) + .no_limit() + .timeout_secs(30) + .run(move || { + let web3 = web3.cheap_clone(); + let metrics = metrics.cheap_clone(); + let provider = provider.clone(); + async move { + web3.eth() + .block(BlockId::Number(Web3BlockNumber::Number( + ENV_VARS.genesis_block_number.into(), + ))) + .await + .map_err(|e| { + metrics.set_status(ProviderStatus::GenesisFail, &provider); + e + })? + .and_then(|gen_block| gen_block.hash.map(BlockHash::from)) + .ok_or_else(|| anyhow!("Ethereum node could not find genesis block")) + } + }) + .map_err(|e| { + self.metrics + .set_status(ProviderStatus::GenesisTimeout, self.provider()); e - }) - .boxed(); - - let web3 = self.web3.clone(); + }); + let alloy = self.alloy.clone(); + let logger2 = logger.clone(); let metrics = self.metrics.clone(); let provider = self.provider().to_string(); let retry_log_message = format!( "eth_getBlockByNumber({}, false) RPC call", ENV_VARS.genesis_block_number ); - let gen_block_hash_future = retry(retry_log_message, &logger) + let gen_block_hash_future2 = retry(retry_log_message, &logger) .redact_log_urls(true) .no_limit() .timeout_secs(30) .run(move || { - let web3 = web3.cheap_clone(); + let alloy = alloy.cheap_clone(); + let logger = logger2.clone(); let metrics = metrics.cheap_clone(); let provider = provider.clone(); async move { - web3.eth() - .block(BlockId::Number(Web3BlockNumber::Number( - ENV_VARS.genesis_block_number.into(), - ))) + Self::load_block_rpc_alloy(alloy, ENV_VARS.genesis_block_number, &logger) .await .map_err(|e| { metrics.set_status(ProviderStatus::GenesisFail, &provider); @@ -1238,18 +1707,28 @@ impl EthereumAdapterTrait for EthereumAdapter { e }); - let (net_version, genesis_block_hash) = - try_join!(net_version_future, gen_block_hash_future).map_err(|e| { - anyhow!( - "Ethereum node took too long to read network identifiers: {}", - e - ) - })?; + let (net_version, net_version2, genesis_block_hash, genesis_block_hash2) = try_join!( + net_version_future, + net_version_future2, + gen_block_hash_future, + gen_block_hash_future2 + ) + .map_err(|e| { + anyhow!( + "Ethereum node took too long to read network identifiers: {}", + e + ) + })?; let ident = ChainIdentifier { net_version, genesis_block_hash, }; + let ident2 = ChainIdentifier { + net_version: net_version2, + genesis_block_hash: genesis_block_hash2, + }; + assert_eq!(ident, ident2); self.metrics .set_status(ProviderStatus::Working, self.provider()); @@ -1260,33 +1739,25 @@ impl EthereumAdapterTrait for EthereumAdapter { &self, logger: &Logger, ) -> Result, IngestorError> { - let web3 = self.web3.clone(); - retry("eth_getBlockByNumber(latest) no txs RPC call", logger) - .redact_log_urls(true) - .no_limit() - .timeout_secs(ENV_VARS.json_rpc_timeout.as_secs()) - .run(move || { - let web3 = web3.cheap_clone(); - async move { - let block_opt = web3 - .eth() - .block(Web3BlockNumber::Latest.into()) - .await - .map_err(|e| anyhow!("could not get latest block from Ethereum: {}", e))?; - - block_opt - .ok_or_else(|| anyhow!("no latest block returned from Ethereum").into()) + let ret = self.latest_block_header_web3(logger).await; + let ret2 = self.latest_block_header_alloy(logger).await; + match (&ret, &ret2) { + (Ok(bl1), Ok(bl2)) => { + if bl1.number == bl2.number { + assert_eq!(Arc::new(bl1.clone()), *bl2) + } else { + let diff = + bl1.number.unwrap().as_u32() as i64 - bl2.number.unwrap().as_u32() as i64; + assert!(diff > -30 && diff < 30) } - }) - .map_err(move |e| { - e.into_inner().unwrap_or_else(move || { - anyhow!("Ethereum node took too long to return latest block").into() - }) - }) - .await + } + (a, b) => panic!("Not same types: {:?} and {:?}", a, b), + }; + ret } async fn latest_block(&self, logger: &Logger) -> Result { + info!(logger, "!!!! latest_block"); let web3 = self.web3.clone(); retry("eth_getBlockByNumber(latest) with txs RPC call", logger) .redact_log_urls(true) @@ -1332,32 +1803,42 @@ impl EthereumAdapterTrait for EthereumAdapter { logger: &Logger, block_hash: H256, ) -> Result, Error> { - let web3 = self.web3.clone(); - let logger = logger.clone(); - let retry_log_message = format!( - "eth_getBlockByHash RPC call for block hash {:?}", - block_hash - ); + let ret = self + .block_by_hash_web3(logger, block_hash) + .await? + .ok_or_else(move || { + anyhow!( + "Ethereum node could not find block with hash {}", + block_hash + ) + }); + let ret2 = self + .block_by_hash_alloy(logger, block_hash) + .await? + .ok_or_else(move || { + anyhow!( + "Ethereum node could not find block with hash {}", + block_hash + ) + }); - retry(retry_log_message, &logger) - .redact_log_urls(true) - .limit(ENV_VARS.request_retries) - .timeout_secs(ENV_VARS.json_rpc_timeout.as_secs()) - .run(move || { - let web3 = web3.cheap_clone(); - async move { - web3.eth() - .block_with_txs(BlockId::Hash(block_hash)) - .await - .map_err(Error::from) + match (&ret, &ret2) { + (Ok(r1), Ok(r2)) => { + // assert_eq!(r1, r2); + if !semi_equal(logger, r1, r2) { + // info!(logger, "RET1: {:?}", r1); + // info!(logger, "RET2: {:?}", r2); + panic!("Error - not equal!"); } - }) - .map_err(move |e| { - e.into_inner().unwrap_or_else(move || { - anyhow!("Ethereum node took too long to return block {}", block_hash) - }) - }) - .await + } + (r1, r2) => { + info!(logger, "RET1: {:?}", r1.is_ok()); + info!(logger, "RET2: {:?}", r2.is_ok()); + info!(logger, "Error - not same!"); + } + } + + ret.map(Some) } async fn block_by_number( @@ -1365,6 +1846,7 @@ impl EthereumAdapterTrait for EthereumAdapter { logger: &Logger, block_number: BlockNumber, ) -> Result, Error> { + info!(logger, "!!!! block_by_number"); let web3 = self.web3.clone(); let logger = logger.clone(); let retry_log_message = format!( @@ -1401,6 +1883,7 @@ impl EthereumAdapterTrait for EthereumAdapter { block: LightEthereumBlock, ) -> Result { let web3 = Arc::clone(&self.web3); + let alloy: Arc = self.alloy.clone(); let logger = logger.clone(); let block_hash = block.hash.expect("block is missing block hash"); @@ -1417,6 +1900,7 @@ impl EthereumAdapterTrait for EthereumAdapter { let supports_block_receipts = self .check_block_receipt_support_and_update_cache( + alloy.clone(), web3.clone(), block_hash, self.supports_eip_1898, @@ -1425,12 +1909,22 @@ impl EthereumAdapterTrait for EthereumAdapter { ) .await; - fetch_receipts_with_retry(web3, hashes, block_hash, logger, supports_block_receipts) - .await - .map(|transaction_receipts| EthereumBlock { - block: Arc::new(block), - transaction_receipts, - }) + // let log = logger.clone(); + let ret = fetch_receipts_with_retry( + alloy, + web3, + hashes, + block_hash, + logger, + supports_block_receipts, + ) + .await + .map(|transaction_receipts| EthereumBlock { + block: Arc::new(block), + transaction_receipts, + }); + // info!(log, "load_full_block is OK: {}", ret.is_ok()); + ret } async fn block_hash_by_block_number( @@ -1438,6 +1932,7 @@ impl EthereumAdapterTrait for EthereumAdapter { logger: &Logger, block_number: BlockNumber, ) -> Result, Error> { + info!(logger, "!!!! block_hash_by_block_number"); let web3 = self.web3.clone(); let retry_log_message = format!( "eth_getBlockByNumber RPC call for block number {}", @@ -1508,6 +2003,7 @@ impl EthereumAdapterTrait for EthereumAdapter { next_number ); let web3 = self.web3.clone(); + let alloy = self.alloy.clone(); let logger = logger.clone(); let res = retry(retry_log_message, &logger) .redact_log_urls(true) @@ -1516,12 +2012,25 @@ impl EthereumAdapterTrait for EthereumAdapter { .timeout_secs(ENV_VARS.json_rpc_timeout.as_secs()) .run(move || { let web3 = web3.cheap_clone(); + let alloy = alloy.clone(); + let logger = logger.clone(); async move { - web3.eth() + let block1 = web3 + .eth() .block(BlockId::Number(next_number.into())) .await .map(|block_opt| block_opt.and_then(|block| block.hash)) - .map_err(Error::from) + .map_err(Error::from); + let block2 = Self::load_block_rpc_alloy(alloy, next_number as u64, &logger) + .await + .map(|block_opt| block_opt.and_then(|block| block.hash)) + .map_err(Error::from); + match (&block1, &block2) { + (Ok(bl1), Ok(bl2)) => assert_eq!(bl1, bl2), + (_, _) => panic!("next_existing_ptr_to_number"), + }; + + block1 } }) .await @@ -1550,7 +2059,7 @@ impl EthereumAdapterTrait for EthereumAdapter { logger: &Logger, inp_call: &ContractCall, cache: Arc, - ) -> Result<(Option>, call::Source), ContractCallError> { + ) -> Result<(Option>, call::Source), ContractCallError> { let mut result = self.contract_calls(logger, &[inp_call], cache).await?; // unwrap: self.contract_calls returns as many results as there were calls Ok(result.pop().unwrap()) @@ -1561,20 +2070,26 @@ impl EthereumAdapterTrait for EthereumAdapter { logger: &Logger, calls: &[&ContractCall], cache: Arc, - ) -> Result>, call::Source)>, ContractCallError> { + ) -> Result>, call::Source)>, ContractCallError> { fn as_req( logger: &Logger, call: &ContractCall, index: u32, ) -> Result { // Emit custom error for type mismatches. - for (token, kind) in call + for (val, kind) in call .args .iter() - .zip(call.function.inputs.iter().map(|p| &p.kind)) + .zip(call.function.inputs.iter().map(|p| p.selector_type())) { - if !token.type_check(kind) { - return Err(ContractCallError::TypeError(token.clone(), kind.clone())); + let kind: abi::DynSolType = kind.parse().map_err(|err| { + ContractCallError::ABIError(anyhow!( + "failed to parse function input type '{kind}': {err}" + )) + })?; + + if !val.type_check(&kind) { + return Err(ContractCallError::TypeError(val.clone(), kind.clone())); } } @@ -1582,8 +2097,8 @@ impl EthereumAdapterTrait for EthereumAdapter { let req = { let encoded_call = call .function - .encode_input(&call.args) - .map_err(ContractCallError::EncodingError)?; + .abi_encode_input(&call.args) + .map_err(|err| ContractCallError::EncodingError(err.into()))?; call::Request::new(call.address, encoded_call, index) }; @@ -1601,7 +2116,7 @@ impl EthereumAdapterTrait for EthereumAdapter { logger: &Logger, resp: call::Response, call: &ContractCall, - ) -> (Option>, call::Source) { + ) -> (Option>, call::Source) { let call::Response { retval, source, @@ -1609,7 +2124,7 @@ impl EthereumAdapterTrait for EthereumAdapter { } = resp; use call::Retval::*; match retval { - Value(output) => match call.function.decode_output(&output) { + Value(output) => match call.function.abi_decode_output(&output) { Ok(tokens) => (Some(tokens), source), Err(e) => { // Decode failures are reverts. The reasoning is that if Solidity fails to @@ -1724,12 +2239,27 @@ impl EthereumAdapterTrait for EthereumAdapter { ); // Return a stream that lazily loads batches of blocks. - debug!(logger, "Requesting {} block(s)", missing_blocks.len()); + info!(logger, "Requesting {} block(s)", missing_blocks.len()); let new_blocks = self - .load_blocks_rpc(logger.clone(), missing_blocks) + .load_blocks_rpc(logger.clone(), missing_blocks.clone()) + .collect() + .compat() + .await?; + let new_blocks2 = self + .load_blocks_rpc_alloy(logger.clone(), missing_blocks.clone()) .collect() .compat() .await?; + assert_eq!(new_blocks.len(), new_blocks2.len()); + for i in 0..new_blocks.len() { + let mut bl1: web3::types::Block = (*new_blocks[i]).clone(); + fix_v_values(&mut bl1); + let mut bl2: web3::types::Block = (*new_blocks[i]).clone(); + fix_v_values(&mut bl2); + let str = format!("{:?}", bl1); + let str2 = format!("{:?}", bl2); + assert_eq!(str, str2); + } let upsert_blocks: Vec<_> = new_blocks .iter() .map(|block| BlockFinality::Final(block.clone())) @@ -1747,6 +2277,17 @@ impl EthereumAdapterTrait for EthereumAdapter { } } +fn fix_v_values(bl1: &mut web3::types::Block) { + for i in 0..bl1.transactions.len() { + let v_new = if let Some(v) = bl1.transactions[i].v { + Some(v % 62709) + } else { + None + }; + bl1.transactions[i].v = v_new; + } +} + /// Returns blocks with triggers, corresponding to the specified range and filters; and the resolved /// `to` block, which is the nearest non-null block greater than or equal to the passed `to` block. /// If a block contains no triggers, there may be no corresponding item in the stream. @@ -1805,7 +2346,64 @@ pub(crate) async fn blocks_with_triggers( }) .compat() .boxed(); - trigger_futs.push(block_future) + trigger_futs.push(block_future); + + ////////////////////////////////////////////////////////////////////////////////// + // Do comparison from here: + ////////////////////////////////////////////////////////////////////////////////// + let trigger_futs1: FuturesUnordered< + BoxFuture, anyhow::Error>>, + > = FuturesUnordered::new(); + let block_future1 = eth + .block_range_to_ptrs(logger.clone(), from, to) + .map(move |ptrs| { + ptrs.into_iter() + .flat_map(|ptr| { + vec![ + EthereumTrigger::Block(ptr.clone(), EthereumBlockTriggerType::Start), + EthereumTrigger::Block(ptr, EthereumBlockTriggerType::End), + ] + }) + .collect() + }) + .compat() + .boxed(); + trigger_futs1.push(block_future1); + let trigger_futs2: FuturesUnordered< + BoxFuture, anyhow::Error>>, + > = FuturesUnordered::new(); + let block_future2 = eth + .block_range_to_ptrs_alloy(logger.clone(), from, to) + .map(move |ptrs| { + ptrs.into_iter() + .flat_map(|ptr| { + vec![ + EthereumTrigger::Block(ptr.clone(), EthereumBlockTriggerType::Start), + EthereumTrigger::Block(ptr, EthereumBlockTriggerType::End), + ] + }) + .collect() + }) + .compat() + .boxed(); + trigger_futs2.push(block_future2); + // request them + let triggers1 = trigger_futs1 + .try_concat() + .await + .with_context(|| format!("Failed to obtain triggers for block {}", to))?; + let block_hashes1: HashSet = + triggers1.iter().map(EthereumTrigger::block_hash).collect(); + let triggers2 = trigger_futs2 + .try_concat() + .await + .with_context(|| format!("Failed to obtain triggers for block {}", to))?; + let block_hashes2: HashSet = + triggers2.iter().map(EthereumTrigger::block_hash).collect(); + assert_eq!(block_hashes1, block_hashes2) + ////////////////////////////////////////////////////////////////////////////////// + // to here + ////////////////////////////////////////////////////////////////////////////////// } else if !filter.block.polling_intervals.is_empty() { let block_futures_matching_once_filter = eth.blocks_matching_polling_intervals(logger.clone(), from, to, &filter.block); @@ -1862,6 +2460,9 @@ pub(crate) async fn blocks_with_triggers( .await .with_context(|| format!("Failed to obtain triggers for block {}", to))?; + // info!(logger, "TRIGGERS:"); + // triggers.iter().for_each(|t| info!(logger, "TR: {:?}", t)); + let mut block_hashes: HashSet = triggers.iter().map(EthereumTrigger::block_hash).collect(); let mut triggers_by_block: HashMap> = @@ -2102,6 +2703,7 @@ async fn fetch_receipt_from_ethereum_client( eth: &EthereumAdapter, transaction_hash: &H256, ) -> anyhow::Result { + println!("!!!! fetch_receipt_from_ethereum_client"); match eth.web3.eth().transaction_receipt(*transaction_hash).await { Ok(Some(receipt)) => Ok(receipt), Ok(None) => bail!("Could not find transaction receipt"), @@ -2257,6 +2859,10 @@ async fn fetch_transaction_receipts_in_batch_with_retry( block_hash: H256, logger: Logger, ) -> Result>, IngestorError> { + info!( + logger, + "!!!! fetch_transaction_receipts_in_batch_with_retry" + ); let retry_log_message = format!( "batch eth_getTransactionReceipt RPC call for block {:?}", block_hash @@ -2283,6 +2889,7 @@ async fn fetch_transaction_receipts_in_batch( block_hash: H256, logger: Logger, ) -> Result>, IngestorError> { + info!(logger, "!!!! fetch_transaction_receipts_in_batch"); let batching_web3 = Web3::new(Batch::new(web3.transport().clone())); let eth = batching_web3.eth(); let receipt_futures = hashes @@ -2307,6 +2914,7 @@ async fn fetch_transaction_receipts_in_batch( } pub(crate) async fn check_block_receipt_support( + alloy: Arc, web3: Arc>, block_hash: H256, supports_eip_1898: bool, @@ -2322,19 +2930,30 @@ pub(crate) async fn check_block_receipt_support( // Fetch block receipts from the provider for the latest block. let block_receipts_result = web3.eth().block_receipts(BlockId::Hash(block_hash)).await; + let hash: alloy_rpc_types::BlockId = + alloy_rpc_types::BlockId::hash(B256::new(*block_hash.as_fixed_bytes())); + let block_receipts_result2 = alloy.get_block_receipts(hash).await; // Determine if the provider supports block receipts based on the fetched result. - match block_receipts_result { + let ret = match block_receipts_result { Ok(Some(receipts)) if !receipts.is_empty() => Ok(()), Ok(_) => Err(anyhow!("Block receipts are empty")), Err(err) => Err(anyhow!("Error fetching block receipts: {}", err)), - } + }; + let ret2 = match block_receipts_result2 { + Ok(Some(receipts)) if !receipts.is_empty() => Ok(()), + Ok(_) => Err(anyhow!("Block receipts are empty")), + Err(err) => Err(anyhow!("Error fetching block receipts: {}", err)), + }; + assert_eq!(ret.is_ok(), ret2.is_ok()); + ret } // Fetches transaction receipts with retries. This function acts as a dispatcher // based on whether block receipts are supported or individual transaction receipts // need to be fetched. async fn fetch_receipts_with_retry( + alloy: Arc, web3: Arc>, hashes: Vec, block_hash: H256, @@ -2342,13 +2961,14 @@ async fn fetch_receipts_with_retry( supports_block_receipts: bool, ) -> Result>, IngestorError> { if supports_block_receipts { - return fetch_block_receipts_with_retry(web3, hashes, block_hash, logger).await; + return fetch_block_receipts_with_retry(alloy, web3, hashes, block_hash, logger).await; } - fetch_individual_receipts_with_retry(web3, hashes, block_hash, logger).await + fetch_individual_receipts_with_retry(alloy, web3, hashes, block_hash, logger).await } // Fetches receipts for each transaction in the block individually. async fn fetch_individual_receipts_with_retry( + alloy: Arc, web3: Arc>, hashes: Vec, block_hash: H256, @@ -2364,6 +2984,7 @@ async fn fetch_individual_receipts_with_retry( let receipt_stream = hash_stream .map(move |tx_hash| { fetch_transaction_receipt_with_retry( + alloy.clone(), web3.cheap_clone(), tx_hash, block_hash, @@ -2380,6 +3001,7 @@ async fn fetch_individual_receipts_with_retry( /// Fetches transaction receipts of all transactions in a block with `eth_getBlockReceipts` call. async fn fetch_block_receipts_with_retry( + alloy: Arc, web3: Arc>, hashes: Vec, block_hash: H256, @@ -2389,13 +3011,46 @@ async fn fetch_block_receipts_with_retry( let retry_log_message = format!("eth_getBlockReceipts RPC call for block {:?}", block_hash); // Perform the retry operation - let receipts_option = retry(retry_log_message, &logger) + let receipts_option = retry(retry_log_message.clone(), &logger) + .redact_log_urls(true) + .limit(ENV_VARS.request_retries) + .timeout_secs(ENV_VARS.json_rpc_timeout.as_secs()) + .run({ + let block_hash = block_hash.clone(); + move || web3.eth().block_receipts(BlockId::Hash(block_hash)).boxed() + }) + .await + .map_err(|_timeout| -> IngestorError { anyhow!(block_hash).into() })?; + // Perform the retry operation + let receipts_option2 = retry(retry_log_message, &logger) .redact_log_urls(true) .limit(ENV_VARS.request_retries) .timeout_secs(ENV_VARS.json_rpc_timeout.as_secs()) - .run(move || web3.eth().block_receipts(BlockId::Hash(block_hash)).boxed()) + .run(move || { + let hash: alloy_rpc_types::BlockId = + alloy_rpc_types::BlockId::hash(B256::new(*block_hash.as_fixed_bytes())); + alloy.get_block_receipts(hash) + }) .await .map_err(|_timeout| -> IngestorError { anyhow!(block_hash).into() })?; + let receipts_option3: Option> = convert_receipts(receipts_option2); + match (&receipts_option, &receipts_option3) { + (Some(r1), Some(r2)) => { + assert_eq!(r1.len(), r2.len()); + for i in 0..r1.len() { + let mut rec1 = r1[i].clone(); + rec1.cumulative_gas_used = u64_to_u256(0); + rec1.transaction_type = None; + rec1.root = None; + let mut rec2 = r2[i].clone(); + rec2.cumulative_gas_used = u64_to_u256(0); + rec2.transaction_type = None; + rec2.root = None; + assert_eq!(rec1, rec2) + } + } + (_, _) => info!(logger, "One side of receipes are missing"), + }; // Check if receipts are available, and transform them if they are match receipts_option { @@ -2424,6 +3079,7 @@ async fn fetch_block_receipts_with_retry( /// Retries fetching a single transaction receipt. async fn fetch_transaction_receipt_with_retry( + alloy: Arc, web3: Arc>, transaction_hash: H256, block_hash: H256, @@ -2434,7 +3090,9 @@ async fn fetch_transaction_receipt_with_retry( "eth_getTransactionReceipt RPC call for transaction {:?}", transaction_hash ); - retry(retry_log_message, &logger) + let logger2 = logger.cheap_clone(); + let retry_log_message2 = retry_log_message.clone(); + let rcp1 = retry(retry_log_message, &logger) .redact_log_urls(true) .limit(ENV_VARS.request_retries) .timeout_secs(ENV_VARS.json_rpc_timeout.as_secs()) @@ -2444,7 +3102,40 @@ async fn fetch_transaction_receipt_with_retry( .and_then(move |some_receipt| { resolve_transaction_receipt(some_receipt, transaction_hash, block_hash, logger) }) - .map(Arc::new) + .map(Arc::new); + + let mut rcp2: Result, IngestorError> = + retry(retry_log_message2, &logger2) + .redact_log_urls(true) + .limit(ENV_VARS.request_retries) + .timeout_secs(ENV_VARS.json_rpc_timeout.as_secs()) + .run(move || { + alloy + .get_transaction_receipt(h256_to_b256(&transaction_hash)) + .boxed() + }) + .await + .map_err(|_timeout| anyhow!(block_hash).into()) + .and_then(move |some_receipt| { + let rcp = some_receipt.map(convert_receipt); + resolve_transaction_receipt(rcp, transaction_hash, block_hash, logger2) + }) + .map(Arc::new); + match (&rcp1, &mut rcp2) { + (Ok(r1), Ok(r2)) => { + let r2 = std::sync::Arc::::get_mut(r2) + .unwrap(); + r2.cumulative_gas_used = r1.cumulative_gas_used; + r2.root = r1.root; + r2.transaction_type = r1.transaction_type; + let r2 = r2.clone(); + let r2 = Arc::new(r2); + assert_eq!(r1, &r2); + } + (_, _) => todo!(), + }; + + rcp1 } fn resolve_transaction_receipt( @@ -2589,7 +3280,6 @@ async fn get_transaction_receipts_for_transaction_hashes( if transaction_hashes_by_block.is_empty() { return Ok(receipts_by_hash); } - // Keep a record of all unique transaction hashes for which we'll request receipts. We will // later use this to check if we have collected the receipts from all required transactions. let mut unique_transaction_hashes: HashSet<&H256> = HashSet::new(); @@ -2598,10 +3288,12 @@ async fn get_transaction_receipts_for_transaction_hashes( let receipt_futures = FuturesUnordered::new(); let web3 = Arc::clone(&adapter.web3); + let alloy = adapter.alloy.clone(); for (block_hash, transaction_hashes) in transaction_hashes_by_block { for transaction_hash in transaction_hashes { unique_transaction_hashes.insert(transaction_hash); let receipt_future = fetch_transaction_receipt_with_retry( + alloy.clone(), web3.cheap_clone(), *transaction_hash, *block_hash, @@ -2654,6 +3346,645 @@ async fn get_transaction_receipts_for_transaction_hashes( Ok(receipts_by_hash) } +fn b256_to_h256(in_data: B256) -> H256 { + H256(in_data.as_slice()[0..32].try_into().unwrap()) +} +fn b64_to_h64(in_data: B64) -> H64 { + H64(in_data.as_slice()[0..8].try_into().unwrap()) +} +fn u256_to_u256(in_data: alloy::primitives::U256) -> web3::types::U256 { + let u1 = u64::from_le_bytes(in_data.as_le_slice()[0..8].try_into().unwrap_or_default()); + let u2 = u64::from_le_bytes(in_data.as_le_slice()[8..16].try_into().unwrap_or_default()); + let u3 = u64::from_le_bytes(in_data.as_le_slice()[16..24].try_into().unwrap_or_default()); + let u4 = u64::from_le_bytes(in_data.as_le_slice()[24..32].try_into().unwrap_or_default()); + U256([u1, u2, u3, u4]) +} +fn u128_to_u256(in_data: u128) -> web3::types::U256 { + let u1 = (in_data & 0xffffffffffffffff) as u64; + let u2 = (in_data >> 64) as u64; + U256([u1, u2, 0, 0]) +} +fn u64_to_u256(in_data: u64) -> web3::types::U256 { + web3::types::U256([in_data, 0, 0, 0]) +} +fn u64_to_u64(in_data: u64) -> web3::types::U64 { + web3::types::U64([in_data]) +} +fn bool_to_u64(in_data: bool) -> web3::types::U64 { + web3::types::U64([if in_data { 1 } else { 0 }]) +} +fn u128_to_u64(in_data: u128) -> web3::types::U64 { + web3::types::U64([(in_data & 0xffffffffffffffff) as u64]) +} +fn address_to_h160(fixed_bytes: alloy::primitives::Address) -> H160 { + let address = H160(fixed_bytes.as_slice().try_into().unwrap()); + address +} +fn h160_to_address(fixed_bytes: &H160) -> alloy::primitives::Address { + let address = + alloy::primitives::Address::new(fixed_bytes.as_bytes()[0..20].try_into().unwrap()); + address +} +fn h256_to_b256(fixed_bytes: &H256) -> B256 { + let bytes = fixed_bytes.as_bytes()[0..32].try_into().unwrap(); + bytes +} +fn convert_bloom(logs_bloom: &alloy::primitives::Bloom) -> H2048 { + let bytes: [u8; 256] = logs_bloom.as_slice()[0..256].try_into().unwrap(); + H2048::from(bytes) +} +fn bytes_to_bytes(in_data: alloy::primitives::Bytes) -> Bytes { + let slice = in_data.iter().as_slice(); + Bytes::from(slice) +} + +fn convert_topic( + h256s: &Option>, +) -> alloy_rpc_types::FilterSet> { + if let Some(topic1) = h256s { + topic1.into_iter().map(|b| h256_to_b256(&b)).collect() + } else { + alloy_rpc_types::Topic::default() + } +} + +fn convert_log(alloy_logs: &[alloy_rpc_types::Log]) -> Vec { + alloy_logs + .iter() + .map(|log| { + let address = address_to_h160(log.inner.address); + let topics = log.topics().iter().map(|t| b256_to_h256(*t)).collect(); + let data = log.inner.data.data.clone().into(); + let block_hash = log.block_hash.map(b256_to_h256); + let block_number = log.block_number.map(u64_to_u64); + let transaction_hash = log.transaction_hash.map(b256_to_h256); + let transaction_index = log.transaction_index.map(u64_to_u64); + let log_index = log.log_index.map(u64_to_u256); + let transaction_log_index = None; // TODO: fix it + let log_type = None; // TODO: fix it + let removed = Some(log.removed); + Log { + address, + topics, + data, + block_hash, + block_number, + transaction_hash, + transaction_index, + log_index, + transaction_log_index, + log_type, + removed, + } + }) + .collect() +} + +fn convert_receipts( + receipts_option: Option>, +) -> Option> { + receipts_option.map(|receipts| receipts.into_iter().map(convert_receipt).collect()) +} + +fn convert_receipt(receipt: alloy_rpc_types::TransactionReceipt) -> TransactionReceipt { + let transaction_hash = b256_to_h256(receipt.transaction_hash); + let transaction_index = u64_to_u64(receipt.transaction_index.unwrap()); + let block_hash = receipt.block_hash.map(b256_to_h256); + let block_number = receipt.block_number.map(u64_to_u64); + let from = address_to_h160(receipt.from); + let to = receipt.to.map(address_to_h160); + let cumulative_gas_used = u64_to_u256(receipt.blob_gas_used.unwrap_or_default()); // TODO: fix + let gas_used = Some(u64_to_u256(receipt.gas_used)); + let contract_address = receipt.contract_address.map(address_to_h160); + let logs = convert_log(receipt.logs()); + let status = Some(bool_to_u64(receipt.status())); + let root = None; // TODO: fix it + let logs_bloom = convert_bloom(receipt.inner.logs_bloom()); + let transaction_type = Some(u64_to_u64(0)); // TODO fix it + let effective_gas_price = Some(u128_to_u256(receipt.effective_gas_price)); + + TransactionReceipt { + transaction_hash, + transaction_index, + block_hash, + block_number, + from, + to, + cumulative_gas_used, + gas_used, + contract_address, + logs, + status, + root, + logs_bloom, + transaction_type, + effective_gas_price, + } +} + +fn tx_to_tx( + logger: &Logger, + in_data: BlockTransactions, +) -> Vec { + let _ = logger; + match in_data { + BlockTransactions::Full(items) => { + // if items.len() > 0 { + // info!(logger, "ITEMS: {}", items.len()); + // } + let ret = items + .iter() + .map(|tx| -> Transaction { + // info!(logger, "TX: {:?}", tx); + let inner = tx.inner.inner(); + let hash = b256_to_h256(inner.hash().clone()); + let block_hash = tx.block_hash.map(b256_to_h256); + let block_number = tx.block_number.map(u64_to_u64); + let transaction_index = tx.transaction_index.map(u64_to_u64); + let from = Some(address_to_h160(tx.inner.signer())); + + let gas_price = tx.effective_gas_price.map(u128_to_u256); + let raw = None; // TODO: fix it + match inner { + alloy::consensus::EthereumTxEnvelope::Legacy(signed) => { + // info!(logger, "TX legacy: {:?}", signed.tx()); + // info!(logger, "SIG legacy: {:?}", signed.signature()); + let nonce = u64_to_u256(signed.tx().nonce); + let to = if let alloy::primitives::TxKind::Call(to) = signed.tx().to { + Some(address_to_h160(to)) + } else { + None + }; + let value = u256_to_u256(signed.tx().value); + let gas = u64_to_u256(signed.tx().gas_limit); + let input: web3::types::Bytes = signed.tx().input.clone().into(); + // let v: Option = + // Some(if signed.signature().v() { 1 } else { 0 }.into()); + let r = Some(u256_to_u256(signed.signature().r())); + let s = Some(u256_to_u256(signed.signature().s())); + + let v_val = + u128_to_u64(alloy::consensus::transaction::to_eip155_value( + signed.signature().v(), + signed.tx().chain_id, + )); + // info!( + // logger, + // "V_VAL: {:?} LEGACY #{:?} NOT USED", v_val, block_number + // ); + let v = Some(v_val); + let transaction_type: Option = Some(0.into()); // TODO: fix it + let access_list = None; // TODO: fix it + let max_fee_per_gas = None; // TODO: fix it + let max_priority_fee_per_gas = None; // TODO: fix it + + web3::types::Transaction { + hash, + nonce, + block_hash, + block_number, + transaction_index, + from, + to, + value, + gas_price, + gas, + input, + v, + r, + s, + raw, + transaction_type, + access_list, + max_fee_per_gas, + max_priority_fee_per_gas, + } + } + alloy::consensus::EthereumTxEnvelope::Eip2930(signed) => { + let nonce = u64_to_u256(signed.tx().nonce()); + let to = if let Some(to) = signed.tx().to() { + Some(address_to_h160(to)) + } else { + None + }; + let value = u256_to_u256(signed.tx().value()); + let gas = u64_to_u256(signed.tx().gas_limit()); + let input: web3::types::Bytes = signed.tx().input().clone().into(); + let r = Some(u256_to_u256(signed.signature().r())); + let s = Some(u256_to_u256(signed.signature().s())); + let v_val = + u128_to_u64(alloy::consensus::transaction::to_eip155_value( + signed.signature().v(), + Some(signed.tx().chain_id().unwrap()), + )); + let v = Some(v_val); + let transaction_type: Option = Some(2.into()); // TODO: fix it + let access_list = Some(vec![]); // TODO: fix it + let max_fee_per_gas = Some(u128_to_u256(signed.tx().max_fee_per_gas())); + let max_priority_fee_per_gas = + signed.tx().max_priority_fee_per_gas().map(u128_to_u256); + web3::types::Transaction { + hash, + nonce, + block_hash, + block_number, + transaction_index, + from, + to, + value, + gas_price, + gas, + input, + v, + r, + s, + raw, + transaction_type, + access_list, + max_fee_per_gas, + max_priority_fee_per_gas, + } + } + alloy::consensus::EthereumTxEnvelope::Eip1559(signed) => { + // info!(logger, "TX eip1559: {:?}", signed.tx()); + let nonce = u64_to_u256(signed.tx().nonce); + let to = if let alloy::primitives::TxKind::Call(to) = signed.tx().to { + Some(address_to_h160(to)) + } else { + None + }; + let value = u256_to_u256(signed.tx().value); + let gas = u64_to_u256(signed.tx().gas_limit); + let input: web3::types::Bytes = signed.tx().input.clone().into(); + // let v: Option = + // Some(if signed.signature().v() { 1 } else { 0 }.into()); + let r = Some(u256_to_u256(signed.signature().r())); + let s = Some(u256_to_u256(signed.signature().s())); + let v_val = + u128_to_u64(alloy::consensus::transaction::to_eip155_value( + signed.signature().v(), + Some(signed.tx().chain_id), + )); + // info!(logger, "V_VAL: {:?} EIP #{:?}", v_val, block_number); + let v = Some(v_val); + + let transaction_type: Option = Some(2.into()); // TODO: fix it + let access_list = Some(vec![]); // TODO: fix it + let max_fee_per_gas = Some(u128_to_u256(signed.tx().max_fee_per_gas)); + let max_priority_fee_per_gas = + Some(u128_to_u256(signed.tx().max_priority_fee_per_gas)); + + web3::types::Transaction { + hash, + nonce, + block_hash, + block_number, + transaction_index, + from, + to, + value, + gas_price, + gas, + input, + v, + r, + s, + raw, + transaction_type, + access_list, + max_fee_per_gas, + max_priority_fee_per_gas, + } + } + alloy::consensus::EthereumTxEnvelope::Eip4844(signed) => { + let nonce = u64_to_u256(signed.tx().nonce()); + let to = if let Some(to) = signed.tx().to() { + Some(address_to_h160(to)) + } else { + None + }; + let value = u256_to_u256(signed.tx().value()); + let gas = u64_to_u256(signed.tx().gas_limit()); + let input: web3::types::Bytes = signed.tx().input().clone().into(); + let r = Some(u256_to_u256(signed.signature().r())); + let s = Some(u256_to_u256(signed.signature().s())); + let v_val = + u128_to_u64(alloy::consensus::transaction::to_eip155_value( + signed.signature().v(), + Some(signed.tx().chain_id().unwrap()), + )); + let v = Some(v_val); + let transaction_type: Option = Some(2.into()); // TODO: fix it + let access_list = Some(vec![]); // TODO: fix it + let max_fee_per_gas = Some(u128_to_u256(signed.tx().max_fee_per_gas())); + let max_priority_fee_per_gas = Some(u128_to_u256( + signed.tx().max_priority_fee_per_gas().unwrap(), + )); + web3::types::Transaction { + hash, + nonce, + block_hash, + block_number, + transaction_index, + from, + to, + value, + gas_price, + gas, + input, + v, + r, + s, + raw, + transaction_type, + access_list, + max_fee_per_gas, + max_priority_fee_per_gas, + } + } + alloy::consensus::EthereumTxEnvelope::Eip7702(signed) => { + let nonce = u64_to_u256(signed.tx().nonce()); + let to = if let Some(to) = signed.tx().to() { + Some(address_to_h160(to)) + } else { + None + }; + let value = u256_to_u256(signed.tx().value()); + let gas = u64_to_u256(signed.tx().gas_limit()); + let input: web3::types::Bytes = signed.tx().input().clone().into(); + let r = Some(u256_to_u256(signed.signature().r())); + let s = Some(u256_to_u256(signed.signature().s())); + let v_val = + u128_to_u64(alloy::consensus::transaction::to_eip155_value( + signed.signature().v(), + Some(signed.tx().chain_id().unwrap()), + )); + let v = Some(v_val); + let transaction_type: Option = Some(2.into()); // TODO: fix it + let access_list = Some(vec![]); // TODO: fix it + let max_fee_per_gas = Some(u128_to_u256(signed.tx().max_fee_per_gas())); + let max_priority_fee_per_gas = Some(u128_to_u256( + signed.tx().max_priority_fee_per_gas().unwrap(), + )); + web3::types::Transaction { + hash, + nonce, + block_hash, + block_number, + transaction_index, + from, + to, + value, + gas_price, + gas, + input, + v, + r, + s, + raw, + transaction_type, + access_list, + max_fee_per_gas, + max_priority_fee_per_gas, + } + } + } + }) + .collect::>(); + // info!(logger, "DONE WITH ITEMS"); + ret + } + BlockTransactions::Hashes(_items) => { + // items + // .iter() + // .map(|hash| b256_to_h256(*hash)) + // .collect::>(); + panic!("Not implemented variant: Hashes"); + } + BlockTransactions::Uncle => panic!("Not implemented variant: Uncle"), + } +} + +fn convert_block_alloy2web3( + logger: &Logger, + block: alloy_rpc_types::Block, +) -> Arc { + let hash = Some(b256_to_h256(block.header.hash)); + // info!(logger, "hash: {:?}", hash); + let parent_hash = b256_to_h256(block.header.inner.parent_hash); + // info!(logger, "parent_hash: {:?}", parent_hash); + let uncles_hash = b256_to_h256(block.header.inner.ommers_hash); + // info!(logger, "uncles_hash: {:?}", uncles_hash); + let author = address_to_h160(block.header.inner.beneficiary); + // info!(logger, "author: {:?}", author); + let state_root = b256_to_h256(block.header.state_root); + // info!(logger, "state_root: {:?}", state_root); + let transactions_root = b256_to_h256(block.header.transactions_root); + // info!(logger, "transactions_root: {:?}", transactions_root); + let receipts_root = b256_to_h256(block.header.receipts_root); + // info!(logger, "receipts_root: {:?}", receipts_root); + let number = Some(web3::types::U64([block.header.number; 1])); + // info!(logger, "number: {:?}", number); + let gas_used = u64_to_u256(block.header.gas_used); + // info!(logger, "gas_used: {:?}", gas_used); + let gas_limit = u64_to_u256(block.header.gas_limit); + // info!(logger, "gas_limit: {:?}", gas_limit); + let base_fee_per_gas = block.header.base_fee_per_gas.map(|n| u64_to_u256(n)); + // info!(logger, "base_fee_per_gas: {:?}", base_fee_per_gas); + let extra_data = web3::types::Bytes(block.header.extra_data.to_vec()); + // info!(logger, "extra_data: {:?}", extra_data); + let logs_bloom = Some(H2048( + block.header.inner.logs_bloom.as_slice()[0..256] + .try_into() + .unwrap(), + )); + // info!(logger, "logs_bloom: {:?}", logs_bloom); + let timestamp = u64_to_u256(block.header.inner.timestamp); + // info!(logger, "timestamp: {:?}", timestamp); + let difficulty = u256_to_u256(block.header.inner.difficulty); + // info!(logger, "difficulty: {:?}", difficulty); + let total_difficulty = block.header.total_difficulty.map(|n| u256_to_u256(n)); + // info!(logger, "total_difficulty: {:?}", total_difficulty); + let uncles = block.uncles.into_iter().map(|h| b256_to_h256(h)).collect(); + // info!(logger, "uncles: {:?}", uncles); + let transactions = tx_to_tx(logger, block.transactions); + let size = block.header.size.map(|n| u256_to_u256(n)); + // info!(logger, "size: {:?}", size); + let mix_hash = Some(b256_to_h256(block.header.mix_hash)); + // info!(logger, "mix_hash: {:?}", mix_hash); + let nonce = Some(b64_to_h64(block.header.nonce)); + // info!(logger, "nonce: {:?}", nonce); + let light_block = LightEthereumBlock { + hash, + parent_hash, + uncles_hash, + author, + state_root, + transactions_root, + receipts_root, + number, + gas_used, + gas_limit, + base_fee_per_gas, + extra_data, + logs_bloom, + timestamp, + difficulty, + total_difficulty, + seal_fields: vec![], // TODO: fix this + uncles, + transactions, + size, + mix_hash, + nonce, + }; + // info!(logger, "light_block: {:?}", light_block); + Arc::new(light_block) +} + +fn tx_hash_to_tx( + logger: &Logger, + in_data: BlockTransactions, +) -> Vec { + let _ = logger; + match in_data { + BlockTransactions::Full(_) => panic!("Wrong variant: Full"), + BlockTransactions::Hashes(items) => { + let v = items + .iter() + .map(|hash| { + // info!(logger, "HASH: {:?}", hash); + b256_to_h256(*hash) + }) + .collect::>(); + v + } + BlockTransactions::Uncle => panic!("Not implemented variant: Uncle"), + } +} + +fn convert_block_hash_alloy2web3( + logger: &Logger, + block: alloy_rpc_types::Block, +) -> Arc> { + let hash = Some(b256_to_h256(block.header.hash)); + // info!(logger, "hash: {:?}", hash); + let parent_hash = b256_to_h256(block.header.inner.parent_hash); + // info!(logger, "parent_hash: {:?}", parent_hash); + let uncles_hash = b256_to_h256(block.header.inner.ommers_hash); + // info!(logger, "uncles_hash: {:?}", uncles_hash); + let author = address_to_h160(block.header.inner.beneficiary); + // info!(logger, "author: {:?}", author); + let state_root = b256_to_h256(block.header.state_root); + // info!(logger, "state_root: {:?}", state_root); + let transactions_root = b256_to_h256(block.header.transactions_root); + // info!(logger, "transactions_root: {:?}", transactions_root); + let receipts_root = b256_to_h256(block.header.receipts_root); + // info!(logger, "receipts_root: {:?}", receipts_root); + let number = Some(web3::types::U64([block.header.number; 1])); + // info!(logger, "number: {:?}", number); + let gas_used = u64_to_u256(block.header.gas_used); + // info!(logger, "gas_used: {:?}", gas_used); + let gas_limit = u64_to_u256(block.header.gas_limit); + // info!(logger, "gas_limit: {:?}", gas_limit); + let base_fee_per_gas = block.header.base_fee_per_gas.map(|n| u64_to_u256(n)); + // info!(logger, "base_fee_per_gas: {:?}", base_fee_per_gas); + let extra_data = web3::types::Bytes(block.header.extra_data.to_vec()); + // info!(logger, "extra_data: {:?}", extra_data); + let logs_bloom = Some(H2048( + block.header.inner.logs_bloom.as_slice()[0..256] + .try_into() + .unwrap(), + )); + // info!(logger, "logs_bloom: {:?}", logs_bloom); + let timestamp = u64_to_u256(block.header.inner.timestamp); + // info!(logger, "timestamp: {:?}", timestamp); + let difficulty = u256_to_u256(block.header.inner.difficulty); + // info!(logger, "difficulty: {:?}", difficulty); + let total_difficulty = block.header.total_difficulty.map(|n| u256_to_u256(n)); + // info!(logger, "total_difficulty: {:?}", total_difficulty); + let uncles = block.uncles.into_iter().map(|h| b256_to_h256(h)).collect(); + // info!(logger, "uncles: {:?}", uncles); + let transactions = tx_hash_to_tx(logger, block.transactions); + // let transactions = block.transactions.map(|hash|); + let size = block.header.size.map(|n| u256_to_u256(n)); + // info!(logger, "size: {:?}", size); + let mix_hash = Some(b256_to_h256(block.header.mix_hash)); + // info!(logger, "mix_hash: {:?}", mix_hash); + let nonce = Some(b64_to_h64(block.header.nonce)); + // info!(logger, "nonce: {:?}", nonce); + let block = web3::types::Block:: { + hash, + parent_hash, + uncles_hash, + author, + state_root, + transactions_root, + receipts_root, + number, + gas_used, + gas_limit, + base_fee_per_gas, + extra_data, + logs_bloom, + timestamp, + difficulty, + total_difficulty, + seal_fields: vec![], // TODO: fix this + uncles, + transactions, + size, + mix_hash, + nonce, + }; + Arc::new(block) +} + +fn semi_equal( + logger: &Logger, + block1: &web3::types::Block, + block2: &web3::types::Block, +) -> bool { + if block1.transactions.len() != block2.transactions.len() { + info!( + logger, + "different TX sizes: {} vs {}", + block1.transactions.len(), + block2.transactions.len() + ); + return false; + } + for i in 0..block1.transactions.len() { + let mut tx1 = block1.transactions[i].clone(); + tx1.v = None; + tx1.transaction_type = None; + tx1.access_list = None; + tx1.max_fee_per_gas = None; + let mut tx2 = block2.transactions[i].clone(); + tx2.v = None; + tx2.transaction_type = None; + tx2.access_list = None; + tx2.max_fee_per_gas = None; + if tx1 != tx2 { + info!(logger, "different TX (block #{:?}):", block1.number); + info!(logger, "TX1: {:?}", tx1); + info!(logger, "TX2: {:?}", tx2); + return false; + } + } + let mut bl1 = block1.clone(); + bl1.transactions = vec![]; + let mut bl2 = block2.clone(); + bl2.transactions = vec![]; + if bl1 != bl2 { + info!(logger, "different BL (block #{:?}):", block1.number); + info!(logger, "BL1: {:?}", bl1); + info!(logger, "BL2: {:?}", bl2); + return false; + } + true +} + #[cfg(test)] mod tests { @@ -2664,9 +3995,9 @@ mod tests { EthereumBlockWithCalls, }; use graph::blockchain::BlockPtr; - use graph::prelude::ethabi::ethereum_types::U64; use graph::prelude::tokio::{self}; use graph::prelude::web3::transports::test::TestTransport; + use graph::prelude::web3::types::U64; use graph::prelude::web3::types::{Address, Block, Bytes, H256}; use graph::prelude::web3::Web3; use graph::prelude::EthereumCall; @@ -2751,7 +4082,12 @@ mod tests { // transport.add_response(json_value); let web3 = Arc::new(Web3::new(transport.clone())); + let asserter = alloy::transports::mock::Asserter::new(); + // asserter.push(json_value); + let alloy = + Arc::new(alloy::providers::ProviderBuilder::new().connect_mocked_client(asserter)); let result = check_block_receipt_support( + alloy, web3.clone(), H256::zero(), supports_eip_1898, diff --git a/chain/ethereum/src/ingestor.rs b/chain/ethereum/src/ingestor.rs index 935cb525936..a29aa8d17bd 100644 --- a/chain/ethereum/src/ingestor.rs +++ b/chain/ethereum/src/ingestor.rs @@ -9,8 +9,8 @@ use graph::{ blockchain::{BlockHash, BlockIngestor, BlockPtr, IngestorError}, cheap_clone::CheapClone, prelude::{ - async_trait, error, ethabi::ethereum_types::H256, info, tokio, trace, warn, ChainStore, - Error, EthereumBlockWithCalls, LogCode, Logger, + async_trait, error, info, tokio, trace, warn, web3::types::H256, ChainStore, Error, + EthereumBlockWithCalls, LogCode, Logger, }, }; use std::{sync::Arc, time::Duration}; diff --git a/chain/ethereum/src/runtime/abi.rs b/chain/ethereum/src/runtime/abi.rs index 1a4af0663cb..7af6470bf40 100644 --- a/chain/ethereum/src/runtime/abi.rs +++ b/chain/ethereum/src/runtime/abi.rs @@ -2,9 +2,9 @@ use super::runtime_adapter::UnresolvedContractCall; use crate::trigger::{ EthereumBlockData, EthereumCallData, EthereumEventData, EthereumTransactionData, }; +use graph::abi; use graph::{ prelude::{ - ethabi, web3::types::{Log, TransactionReceipt, H256}, BigInt, }, @@ -37,7 +37,7 @@ impl AscType for AscLogParamArray { } } -impl ToAscObj for &[ethabi::LogParam] { +impl ToAscObj for &[abi::DynSolParam] { fn to_asc_obj( &self, heap: &mut H, @@ -778,7 +778,7 @@ impl<'a> ToAscObj for ethabi::LogParam { +impl ToAscObj for abi::DynSolParam { fn to_asc_obj( &self, heap: &mut H, diff --git a/chain/ethereum/src/runtime/runtime_adapter.rs b/chain/ethereum/src/runtime/runtime_adapter.rs index 951958d786b..91f7e2dd1a4 100644 --- a/chain/ethereum/src/runtime/runtime_adapter.rs +++ b/chain/ethereum/src/runtime/runtime_adapter.rs @@ -7,6 +7,8 @@ use crate::{ }; use anyhow::{anyhow, Context, Error}; use blockchain::HostFn; +use graph::abi; +use graph::abi::DynSolValueExt; use graph::blockchain::ChainIdentifier; use graph::components::subgraph::HostMetrics; use graph::data::store::ethereum::call; @@ -14,6 +16,7 @@ use graph::data::store::scalar::BigInt; use graph::data::subgraph::API_VERSION_0_0_9; use graph::data_source; use graph::data_source::common::{ContractCall, MappingABI}; +use graph::prelude::web3::types::Address; use graph::prelude::web3::types::H160; use graph::runtime::gas::Gas; use graph::runtime::{AscIndexId, IndexForAscTypeId}; @@ -21,10 +24,7 @@ use graph::slog::debug; use graph::{ blockchain::{self, BlockPtr, HostFnCtx}, cheap_clone::CheapClone, - prelude::{ - ethabi::{self, Address, Token}, - EthereumCallCache, - }, + prelude::EthereumCallCache, runtime::{asc_get, asc_new, AscPtr, HostExportError}, semver::Version, slog::Logger, @@ -283,20 +283,7 @@ fn eth_call( abis: &[Arc], eth_call_gas: Option, metrics: Arc, -) -> Result>, HostExportError> { - // Helpers to log the result of the call at the end - fn tokens_as_string(tokens: &[Token]) -> String { - tokens.iter().map(|arg| arg.to_string()).join(", ") - } - - fn result_as_string(result: &Result>, HostExportError>) -> String { - match result { - Ok(Some(tokens)) => format!("({})", tokens_as_string(&tokens)), - Ok(None) => "none".to_string(), - Err(_) => "error".to_string(), - } - } - +) -> Result>, HostExportError> { let start_time = Instant::now(); // Obtain the path to the contract ABI @@ -375,16 +362,26 @@ fn eth_call( ); } - debug!(logger, "Contract call finished"; - "address" => format!("0x{:x}", &unresolved_call.contract_address), - "contract" => &unresolved_call.contract_name, - "signature" => &unresolved_call.function_signature, - "args" => format!("[{}]", tokens_as_string(&unresolved_call.function_args)), - "time_ms" => format!("{}ms", elapsed.as_millis()), - "result" => result_as_string(&result), - "block_hash" => block_ptr.hash_hex(), - "block_number" => block_ptr.block_number(), - "source" => source.to_string()); + let args_as_string = format!("[{}]", values_to_string(&unresolved_call.function_args)); + + let result_as_string = match &result { + Ok(Some(values)) => format!("({})", values_to_string(values)), + Ok(None) => "none".to_owned(), + Err(_err) => "error".to_owned(), + }; + + debug!( + logger, "Contract call finished"; + "address" => format!("0x{:x}", &unresolved_call.contract_address), + "contract" => &unresolved_call.contract_name, + "signature" => &unresolved_call.function_signature, + "args" => args_as_string, + "time_ms" => format!("{}ms", elapsed.as_millis()), + "result" => result_as_string, + "block_hash" => block_ptr.hash_hex(), + "block_number" => block_ptr.block_number(), + "source" => source.to_string(), + ); result } @@ -395,9 +392,18 @@ pub struct UnresolvedContractCall { pub contract_address: Address, pub function_name: String, pub function_signature: Option, - pub function_args: Vec, + pub function_args: Vec, } impl AscIndexId for AscUnresolvedContractCall { const INDEX_ASC_TYPE_ID: IndexForAscTypeId = IndexForAscTypeId::SmartContractCall; } + +#[inline] +fn values_to_string(values: &[abi::DynSolValue]) -> String { + values + .iter() + .map(|x| x.to_string()) + .collect_vec() + .join(", ") +} diff --git a/chain/ethereum/src/transport.rs b/chain/ethereum/src/transport.rs index a90a6b9720b..b19dd362e33 100644 --- a/chain/ethereum/src/transport.rs +++ b/chain/ethereum/src/transport.rs @@ -17,6 +17,7 @@ pub enum Transport { client: http::Http, metrics: Arc, provider: ProviderName, + rpc_url: String, }, IPC(ipc::Ipc), WS(ws::WebSocket), @@ -56,10 +57,13 @@ impl Transport { .build() .unwrap(); + let rpc_url = rpc.to_string(); + Transport::RPC { client: http::Http::with_client(client, rpc), metrics, provider: provider.as_ref().into(), + rpc_url, } } } @@ -73,6 +77,7 @@ impl web3::Transport for Transport { client, metrics: _, provider: _, + rpc_url: _, } => client.prepare(method, params), Transport::IPC(ipc) => ipc.prepare(method, params), Transport::WS(ws) => ws.prepare(method, params), @@ -85,6 +90,7 @@ impl web3::Transport for Transport { client, metrics, provider, + rpc_url: _, } => { let metrics = metrics.cheap_clone(); let client = client.clone(); @@ -132,6 +138,7 @@ impl web3::BatchTransport for Transport { client, metrics: _, provider: _, + rpc_url: _, } => Box::new(client.send_batch(requests)), Transport::IPC(ipc) => Box::new(ipc.send_batch(requests)), Transport::WS(ws) => Box::new(ws.send_batch(requests)), diff --git a/chain/ethereum/src/trigger.rs b/chain/ethereum/src/trigger.rs index f9f4ced2978..6bda943e82f 100644 --- a/chain/ethereum/src/trigger.rs +++ b/chain/ethereum/src/trigger.rs @@ -1,20 +1,20 @@ +use graph::abi; use graph::blockchain::MappingTriggerTrait; use graph::blockchain::TriggerData; use graph::data::subgraph::API_VERSION_0_0_2; use graph::data::subgraph::API_VERSION_0_0_6; use graph::data::subgraph::API_VERSION_0_0_7; use graph::data_source::common::DeclaredCall; -use graph::prelude::ethabi::ethereum_types::H160; -use graph::prelude::ethabi::ethereum_types::H256; -use graph::prelude::ethabi::ethereum_types::U128; -use graph::prelude::ethabi::ethereum_types::U256; -use graph::prelude::ethabi::ethereum_types::U64; -use graph::prelude::ethabi::Address; -use graph::prelude::ethabi::LogParam; +use graph::prelude::web3::types::Address; use graph::prelude::web3::types::Block; use graph::prelude::web3::types::Log; use graph::prelude::web3::types::Transaction; use graph::prelude::web3::types::TransactionReceipt; +use graph::prelude::web3::types::H160; +use graph::prelude::web3::types::H256; +use graph::prelude::web3::types::U128; +use graph::prelude::web3::types::U256; +use graph::prelude::web3::types::U64; use graph::prelude::BlockNumber; use graph::prelude::BlockPtr; use graph::prelude::{CheapClone, EthereumCall}; @@ -47,7 +47,7 @@ pub enum MappingTrigger { block: Arc, transaction: Arc, log: Arc, - params: Vec, + params: Vec, receipt: Option>, calls: Vec, }, @@ -55,8 +55,8 @@ pub enum MappingTrigger { block: Arc, transaction: Arc, call: Arc, - inputs: Vec, - outputs: Vec, + inputs: Vec, + outputs: Vec, }, Block { block: Arc, @@ -64,7 +64,7 @@ pub enum MappingTrigger { } impl MappingTriggerTrait for MappingTrigger { - fn error_context(&self) -> std::string::String { + fn error_context(&self) -> String { let transaction_id = match self { MappingTrigger::Log { log, .. } => log.transaction_hash, MappingTrigger::Call { call, .. } => call.transaction_hash, @@ -86,13 +86,13 @@ impl std::fmt::Debug for MappingTrigger { Log { _transaction: Arc, _log: Arc, - _params: Vec, + _params: Vec, }, Call { _transaction: Arc, _call: Arc, - _inputs: Vec, - _outputs: Vec, + _inputs: Vec, + _outputs: Vec, }, Block, } @@ -544,7 +544,7 @@ impl<'a> EthereumTransactionData<'a> { pub struct EthereumEventData<'a> { pub block: EthereumBlockData<'a>, pub transaction: EthereumTransactionData<'a>, - pub params: &'a [LogParam], + pub params: &'a [abi::DynSolParam], log: &'a Log, } @@ -553,7 +553,7 @@ impl<'a> EthereumEventData<'a> { block: &'a Block, tx: &'a Transaction, log: &'a Log, - params: &'a [LogParam], + params: &'a [abi::DynSolParam], ) -> Self { EthereumEventData { block: EthereumBlockData::from(block), @@ -588,8 +588,8 @@ impl<'a> EthereumEventData<'a> { pub struct EthereumCallData<'a> { pub block: EthereumBlockData<'a>, pub transaction: EthereumTransactionData<'a>, - pub inputs: &'a [LogParam], - pub outputs: &'a [LogParam], + pub inputs: &'a [abi::DynSolParam], + pub outputs: &'a [abi::DynSolParam], call: &'a EthereumCall, } @@ -598,8 +598,8 @@ impl<'a> EthereumCallData<'a> { block: &'a Block, transaction: &'a Transaction, call: &'a EthereumCall, - inputs: &'a [LogParam], - outputs: &'a [LogParam], + inputs: &'a [abi::DynSolParam], + outputs: &'a [abi::DynSolParam], ) -> EthereumCallData<'a> { EthereumCallData { block: EthereumBlockData::from(block), diff --git a/graph/Cargo.toml b/graph/Cargo.toml index 631edb29b71..57de345289c 100644 --- a/graph/Cargo.toml +++ b/graph/Cargo.toml @@ -4,6 +4,7 @@ version.workspace = true edition.workspace = true [dependencies] +alloy = { workspace = true } base64 = "=0.21.7" anyhow = "1.0" async-trait = "0.1.74" diff --git a/graph/src/abi/event_ext.rs b/graph/src/abi/event_ext.rs new file mode 100644 index 00000000000..59ae560a8a2 --- /dev/null +++ b/graph/src/abi/event_ext.rs @@ -0,0 +1,181 @@ +use std::collections::VecDeque; + +use alloy::json_abi::Event; +use alloy::primitives::LogData; +use anyhow::anyhow; +use anyhow::Context; +use anyhow::Result; +use itertools::Itertools; +use web3::types::Log; + +use crate::abi::{DynSolParam, DynSolValue}; + +pub trait EventExt { + fn decode_log(&self, log: &Log) -> Result>; +} + +impl EventExt for Event { + fn decode_log(&self, log: &Log) -> Result> { + let log_data = log_to_log_data(log)?; + let decoded_event = alloy::dyn_abi::EventExt::decode_log(self, &log_data)?; + let mut indexed: VecDeque = decoded_event.indexed.into(); + let mut body: VecDeque = decoded_event.body.into(); + + if self.inputs.len() != indexed.len() + body.len() { + return Err(anyhow!( + "unexpected number of decoded event inputs; expected {}, got {}", + self.inputs.len(), + indexed.len() + body.len(), + )); + } + + let mut decoded_params = Vec::with_capacity(self.inputs.len()); + + for input in &self.inputs { + decoded_params.push(DynSolParam { + name: input.name.clone(), + value: { + if input.indexed { + indexed.pop_front().unwrap() + } else { + body.pop_front().unwrap() + } + }, + }); + } + + Ok(decoded_params) + } +} + +fn log_to_log_data(log: &Log) -> Result { + let topics = log + .topics + .iter() + .map(|x| x.to_fixed_bytes().into()) + .collect_vec(); + + let data = log.data.0.clone().into(); + + LogData::new(topics, data).context("log has an invalid number of topics") +} + +#[cfg(test)] +mod tests { + use alloy::dyn_abi::DynSolValue; + use alloy::primitives::U256; + + use super::*; + + fn make_log(topics: &[[u8; 32]], data: Vec) -> Log { + Log { + address: [1; 20].into(), + topics: topics.iter().map(Into::into).collect(), + data: data.into(), + block_hash: None, + block_number: None, + transaction_hash: None, + transaction_index: None, + log_index: None, + transaction_log_index: None, + log_type: None, + removed: None, + } + } + + #[test] + fn decode_log_no_topic_0() { + let event = Event::parse("event X(uint256 indexed a, bytes32 b)").unwrap(); + let a = U256::from(10).to_be_bytes::<32>(); + let b = DynSolValue::FixedBytes([10; 32].into(), 32).abi_encode(); + + let log = make_log(&[a], b); + let err = event.decode_log(&log).unwrap_err(); + + assert_eq!( + err.to_string(), + "invalid log topic list length: expected 2 topics, got 1", + ); + } + + #[test] + fn decode_log_invalid_topic_0() { + let event = Event::parse("event X(uint256 indexed a, bytes32 b)").unwrap(); + let a = U256::from(10).to_be_bytes::<32>(); + let b = DynSolValue::FixedBytes([10; 32].into(), 32).abi_encode(); + + let log = make_log(&[[0; 32], a], b); + let err = event.decode_log(&log).unwrap_err(); + + assert!(err.to_string().starts_with("invalid event signature:")); + } + + #[test] + fn decode_log_success() { + let event = Event::parse("event X(uint256 indexed a, bytes32 b)").unwrap(); + let topic_0 = event.selector().0; + let a = U256::from(10).to_be_bytes::<32>(); + let b = DynSolValue::FixedBytes([10; 32].into(), 32).abi_encode(); + + let log = make_log(&[topic_0, a], b); + let resp = event.decode_log(&log).unwrap(); + + assert_eq!( + resp, + vec![ + DynSolParam { + name: "a".to_owned(), + value: DynSolValue::Uint(U256::from(10), 256), + }, + DynSolParam { + name: "b".to_owned(), + value: DynSolValue::FixedBytes([10; 32].into(), 32), + } + ], + ); + } + + #[test] + fn decode_log_too_many_topics() { + let event = Event::parse("event X(uint256 indexed a, bytes32 b)").unwrap(); + let topic_0 = event.selector().0; + let a = U256::from(10).to_be_bytes::<32>(); + let b = DynSolValue::FixedBytes([10; 32].into(), 32).abi_encode(); + + let log = make_log(&[topic_0, a, a, a, a], b); + let err = event.decode_log(&log).unwrap_err(); + + assert_eq!(err.to_string(), "log has an invalid number of topics"); + } + + #[test] + fn decode_log_when_indexed_param_is_not_the_first() { + let event = Event::parse("event X(uint256 a, uint256 indexed b, bytes32 c)").unwrap(); + let topic_0 = event.selector().0; + let a = DynSolValue::Uint(U256::from(10), 32); + let b = U256::from(20).to_be_bytes::<32>(); + let c = DynSolValue::FixedBytes([30; 32].into(), 32); + let data = DynSolValue::Tuple(vec![a, c]).abi_encode(); + + let log = make_log(&[topic_0, b], data); + let resp = event.decode_log(&log).unwrap(); + + assert_eq!( + resp, + vec![ + DynSolParam { + name: "a".to_owned(), + value: DynSolValue::Uint(U256::from(10), 256), + }, + DynSolParam { + name: "b".to_owned(), + value: DynSolValue::Uint(U256::from(20), 256), + }, + DynSolParam { + name: "c".to_owned(), + value: DynSolValue::FixedBytes([30; 32].into(), 32), + } + ], + ); + } +} diff --git a/graph/src/abi/function_ext.rs b/graph/src/abi/function_ext.rs new file mode 100644 index 00000000000..3264dd10a35 --- /dev/null +++ b/graph/src/abi/function_ext.rs @@ -0,0 +1,303 @@ +use std::borrow::Cow; + +use alloy::dyn_abi::DynSolType; +use alloy::dyn_abi::DynSolValue; +use alloy::dyn_abi::Specifier; +use alloy::json_abi::Function; +use alloy::json_abi::Param; +use anyhow::anyhow; +use anyhow::Result; +use itertools::Itertools; + +use crate::abi::DynSolValueExt; + +pub trait FunctionExt { + /// Returns the signature of this function in the following formats: + /// - if the function has no outputs: `$name($($inputs),*)` + /// - if the function has outputs: `$name($($inputs),*):($(outputs),*)` + /// + /// Examples: + /// - `functionName()` + /// - `functionName():(uint256)` + /// - `functionName(bool):(uint256,string)` + /// - `functionName(uint256,bytes32):(string,uint256)` + fn signature_compat(&self) -> String; + + /// ABI-decodes the given data according to the function's input types. + fn abi_decode_input(&self, data: &[u8]) -> Result>; + + /// ABI-decodes the given data according to the function's output types. + fn abi_decode_output(&self, data: &[u8]) -> Result>; + + /// ABI-encodes the given values, prefixed by the function's selector, if any. + /// + /// This behaviour is to ensure consistency with `ethabi`. + fn abi_encode_input(&self, values: &[DynSolValue]) -> Result>; +} + +impl FunctionExt for Function { + fn signature_compat(&self) -> String { + let name = &self.name; + let inputs = &self.inputs; + let outputs = &self.outputs; + + // This is what `alloy` uses internally when creating signatures. + const MAX_SOL_TYPE_LEN: usize = 32; + + let mut sig_cap = name.len() + 1 + inputs.len() * MAX_SOL_TYPE_LEN + 1; + + if !outputs.is_empty() { + sig_cap = sig_cap + 2 + outputs.len() * MAX_SOL_TYPE_LEN + 1; + } + + let mut sig = String::with_capacity(sig_cap); + + sig.push_str(&name); + signature_part(&inputs, &mut sig); + + if !outputs.is_empty() { + sig.push(':'); + signature_part(&outputs, &mut sig); + } + + sig + } + + fn abi_decode_input(&self, data: &[u8]) -> Result> { + (self as &dyn alloy::dyn_abi::FunctionExt) + .abi_decode_input(data) + .map_err(Into::into) + } + + fn abi_decode_output(&self, data: &[u8]) -> Result> { + (self as &dyn alloy::dyn_abi::FunctionExt) + .abi_decode_output(data) + .map_err(Into::into) + } + + fn abi_encode_input(&self, values: &[DynSolValue]) -> Result> { + let inputs = &self.inputs; + + if inputs.len() != values.len() { + return Err(anyhow!( + "unexpected number of values; expected {}, got {}", + inputs.len(), + values.len(), + )); + } + + let mut fixed_values = Vec::with_capacity(values.len()); + + for (i, input) in inputs.iter().enumerate() { + let ty = input.resolve()?; + let val = &values[i]; + + fixed_values.push(fix_type_size(&ty, val)?); + } + + if fixed_values.iter().all(|x| matches!(x, Cow::Borrowed(_))) { + return (self as &dyn alloy::dyn_abi::JsonAbiExt) + .abi_encode_input(values) + .map_err(Into::into); + } + + // Required because of `alloy::dyn_abi::JsonAbiExt::abi_encode_input` API; + let owned_fixed_values = fixed_values + .into_iter() + .map(|x| x.into_owned()) + .collect_vec(); + + (self as &dyn alloy::dyn_abi::JsonAbiExt) + .abi_encode_input(&owned_fixed_values) + .map_err(Into::into) + } +} + +// An efficient way to compute a part of the signature without new allocations. +fn signature_part(params: &[Param], out: &mut String) { + out.push('('); + + match params.len() { + 0 => {} + 1 => { + params[0].selector_type_raw(out); + } + n => { + params[0].selector_type_raw(out); + + for i in 1..n { + out.push(','); + params[i].selector_type_raw(out); + } + } + } + + out.push(')'); +} + +// Alloy is stricter in type checking than `ehtabi` and requires that the decoded values have +// exactly the same number of bits / bytes as the type used for checking. +// +// This is a problem because in some ASC conversions we lose the original number of bits / bytes +// if the actual data takes less memory. +// +// This method fixes that in a simple but not very cheap way, by encoding the value and trying +// to decode it again using the given type. The result fixes the number of bits / bytes in the +// decoded values, so we can use `alloy` methods that have strict type checking internally. +fn fix_type_size<'a>(ty: &DynSolType, val: &'a DynSolValue) -> Result> { + if val.matches(ty) { + return Ok(Cow::Borrowed(val)); + } + + if !val.type_check(ty) { + return Err(anyhow!( + "invalid value type; expected '{}', got '{:?}'", + ty.sol_type_name(), + val.sol_type_name(), + )); + } + + let bytes = val.abi_encode(); + let new_val = ty.abi_decode(&bytes)?; + + Ok(Cow::Owned(new_val)) +} + +#[cfg(test)] +mod tests { + use alloy::primitives::I256; + use alloy::primitives::U256; + + use super::*; + + fn s(f: &str) -> String { + Function::parse(f).unwrap().signature_compat() + } + + fn u256(u: u64) -> U256 { + U256::from(u) + } + + fn i256(i: i32) -> I256 { + I256::try_from(i).unwrap() + } + + #[test] + fn signature_compat_no_inputs_no_outputs() { + assert_eq!(s("x()"), "x()"); + } + + #[test] + fn signature_compat_one_input_no_outputs() { + assert_eq!(s("x(uint256 a)"), "x(uint256)"); + } + + #[test] + fn signature_compat_multiple_inputs_no_outputs() { + assert_eq!(s("x(uint256 a, bytes32 b)"), "x(uint256,bytes32)"); + } + + #[test] + fn signature_compat_no_inputs_one_output() { + assert_eq!(s("x() returns (uint256)"), "x():(uint256)"); + } + + #[test] + fn signature_compat_no_inputs_multiple_outputs() { + assert_eq!(s("x() returns (uint256, bytes32)"), "x():(uint256,bytes32)"); + } + + #[test] + fn signature_compat_multiple_inputs_multiple_outputs() { + assert_eq!( + s("x(bytes32 a, uint256 b) returns (uint256, bytes32)"), + "x(bytes32,uint256):(uint256,bytes32)", + ); + } + + #[test] + fn abi_decode_input() { + use DynSolValue::{Int, Tuple, Uint}; + + let f = Function::parse("x(uint256 a, int256 b)").unwrap(); + let data = Tuple(vec![Uint(u256(10), 256), Int(i256(-10), 256)]).abi_encode_params(); + let inputs = f.abi_decode_input(&data).unwrap(); + + assert_eq!(inputs, vec![Uint(u256(10), 256), Int(i256(-10), 256)]); + } + + #[test] + fn abi_decode_output() { + use DynSolValue::{Int, Tuple, Uint}; + + let f = Function::parse("x() returns (uint256 a, int256 b)").unwrap(); + let data = Tuple(vec![Uint(u256(10), 256), Int(i256(-10), 256)]).abi_encode_params(); + let outputs = f.abi_decode_output(&data).unwrap(); + + assert_eq!(outputs, vec![Uint(u256(10), 256), Int(i256(-10), 256)]); + } + + #[test] + fn abi_encode_input_no_values() { + let f = Function::parse("x(uint256 a, int256 b)").unwrap(); + let err = f.abi_encode_input(&[]).unwrap_err(); + + assert_eq!( + err.to_string(), + "unexpected number of values; expected 2, got 0", + ); + } + + #[test] + fn abi_encode_input_too_many_values() { + use DynSolValue::Bool; + + let f = Function::parse("x(uint256 a, int256 b)").unwrap(); + + let err = f + .abi_encode_input(&[Bool(true), Bool(false), Bool(true)]) + .unwrap_err(); + + assert_eq!( + err.to_string(), + "unexpected number of values; expected 2, got 3", + ); + } + + #[test] + fn abi_encode_input_invalid_types() { + use DynSolValue::Bool; + + let f = Function::parse("x(uint256 a, int256 b)").unwrap(); + let err = f.abi_encode_input(&[Bool(true), Bool(false)]).unwrap_err(); + assert!(err.to_string().starts_with("invalid value type;")); + } + + #[test] + fn abi_encode_success() { + use DynSolValue::{Bool, Uint}; + + let f = Function::parse("x(uint256 a, bool b)").unwrap(); + let a = Uint(u256(10), 256); + let b = Bool(true); + + let data = f.abi_encode_input(&[a.clone(), b.clone()]).unwrap(); + let inputs = f.abi_decode_input(&data[4..]).unwrap(); + + assert_eq!(inputs, vec![a, b]); + } + + #[test] + fn abi_encode_success_with_size_fix() { + use DynSolValue::{Int, Uint}; + + let f = Function::parse("x(uint256 a, int256 b)").unwrap(); + let a = Uint(u256(10), 32); + let b = Int(i256(-10), 32); + + let data = f.abi_encode_input(&[a, b]).unwrap(); + let inputs = f.abi_decode_input(&data[4..]).unwrap(); + + assert_eq!(inputs, vec![Uint(u256(10), 256), Int(i256(-10), 256)]); + } +} diff --git a/graph/src/abi/mod.rs b/graph/src/abi/mod.rs new file mode 100644 index 00000000000..88fe14b1806 --- /dev/null +++ b/graph/src/abi/mod.rs @@ -0,0 +1,20 @@ +mod event_ext; +mod function_ext; +mod param; +mod value_ext; + +pub use alloy::dyn_abi::DynSolType; +pub use alloy::dyn_abi::DynSolValue; + +pub use alloy::json_abi::Event; +pub use alloy::json_abi::Function; +pub use alloy::json_abi::JsonAbi; +pub use alloy::json_abi::StateMutability; + +pub use alloy::primitives::I256; +pub use alloy::primitives::U256; + +pub use self::event_ext::EventExt; +pub use self::function_ext::FunctionExt; +pub use self::param::DynSolParam; +pub use self::value_ext::DynSolValueExt; diff --git a/graph/src/abi/param.rs b/graph/src/abi/param.rs new file mode 100644 index 00000000000..49e0f0878ea --- /dev/null +++ b/graph/src/abi/param.rs @@ -0,0 +1,7 @@ +use alloy::dyn_abi::DynSolValue; + +#[derive(Clone, Debug, PartialEq)] +pub struct DynSolParam { + pub name: String, + pub value: DynSolValue, +} diff --git a/graph/src/abi/value_ext.rs b/graph/src/abi/value_ext.rs new file mode 100644 index 00000000000..cb0f220e036 --- /dev/null +++ b/graph/src/abi/value_ext.rs @@ -0,0 +1,277 @@ +use alloy::dyn_abi::DynSolType; +use alloy::dyn_abi::DynSolValue; +use anyhow::anyhow; +use anyhow::Result; +use itertools::Itertools; + +pub trait DynSolValueExt { + /// Creates a fixed-byte decoded value from a slice. + /// + /// Fails if the source slice exceeds 32 bytes. + fn fixed_bytes_from_slice(s: &[u8]) -> Result; + + /// Returns the decoded value as a string. + /// + /// The resulting string contains no type information. + fn to_string(&self) -> String; + + /// Checks whether the value is of the specified type. + /// + /// For types with additional size information, returns true if the size of the value is less + /// than or equal to the size of the specified type. + #[must_use] + fn type_check(&self, ty: &DynSolType) -> bool; +} + +impl DynSolValueExt for DynSolValue { + fn fixed_bytes_from_slice(s: &[u8]) -> Result { + let num_bytes = s.len(); + + if num_bytes > 32 { + return Err(anyhow!( + "input slice must contain a maximum of 32 bytes, got {num_bytes}" + )); + } + + let mut bytes = [0u8; 32]; + + // Access: If `x` is of type `bytesI`, then `x[k]` for `0 <= k < I` returns the `k`th byte. + // Ref: + bytes[..num_bytes].copy_from_slice(s); + + Ok(Self::FixedBytes(bytes.into(), num_bytes)) + } + + fn to_string(&self) -> String { + let s = |v: &[Self]| v.iter().map(|x| x.to_string()).collect_vec().join(","); + + // Output format is taken from `ethabi`; + // See: + match self { + Self::Bool(v) => v.to_string(), + Self::Int(v, _) => format!("{v:x}"), + Self::Uint(v, _) => format!("{v:x}"), + Self::FixedBytes(v, _) => hex::encode(v), + Self::Address(v) => format!("{v:x}"), + Self::Function(v) => format!("{v:x}"), + Self::Bytes(v) => hex::encode(v), + Self::String(v) => v.to_owned(), + Self::Array(v) => format!("[{}]", s(v)), + Self::FixedArray(v) => format!("[{}]", s(v)), + Self::Tuple(v) => format!("({})", s(v)), + } + } + + fn type_check(&self, ty: &DynSolType) -> bool { + match self { + Self::Bool(_) => *ty == DynSolType::Bool, + Self::Int(_, a) => { + if let DynSolType::Int(b) = ty { + b >= a + } else { + false + } + } + Self::Uint(_, a) => { + if let DynSolType::Uint(b) = ty { + b >= a + } else { + false + } + } + Self::FixedBytes(_, a) => { + if let DynSolType::FixedBytes(b) = ty { + b >= a + } else { + false + } + } + Self::Address(_) => *ty == DynSolType::Address, + Self::Function(_) => *ty == DynSolType::Function, + Self::Bytes(_) => *ty == DynSolType::Bytes, + Self::String(_) => *ty == DynSolType::String, + Self::Array(values) => { + if let DynSolType::Array(ty) = ty { + values.iter().all(|x| x.type_check(ty)) + } else { + false + } + } + Self::FixedArray(values) => { + if let DynSolType::FixedArray(ty, size) = ty { + *size == values.len() && values.iter().all(|x| x.type_check(ty)) + } else { + false + } + } + Self::Tuple(values) => { + if let DynSolType::Tuple(types) = ty { + types.len() == values.len() + && values + .iter() + .enumerate() + .all(|(i, x)| x.type_check(&types[i])) + } else { + false + } + } + } + } +} + +#[cfg(test)] +mod tests { + use alloy::primitives::I256; + use alloy::primitives::U256; + + use super::*; + + #[test] + fn fixed_bytes_from_slice_empty_slice() { + let val = DynSolValue::fixed_bytes_from_slice(&[]).unwrap(); + let bytes = [0; 32]; + + assert_eq!(val, DynSolValue::FixedBytes(bytes.into(), 0)); + } + + #[test] + fn fixed_bytes_from_slice_one_byte() { + let val = DynSolValue::fixed_bytes_from_slice(&[10]).unwrap(); + let mut bytes = [0; 32]; + bytes[0] = 10; + + assert_eq!(val, DynSolValue::FixedBytes(bytes.into(), 1)); + } + + #[test] + fn fixed_bytes_from_slice_multiple_bytes() { + let val = DynSolValue::fixed_bytes_from_slice(&[10, 20, 30]).unwrap(); + let mut bytes = [0; 32]; + bytes[0] = 10; + bytes[1] = 20; + bytes[2] = 30; + + assert_eq!(val, DynSolValue::FixedBytes(bytes.into(), 3)); + } + + #[test] + fn fixed_bytes_from_slice_max_bytes() { + let val = DynSolValue::fixed_bytes_from_slice(&[10; 32]).unwrap(); + let bytes = [10; 32]; + + assert_eq!(val, DynSolValue::FixedBytes(bytes.into(), 32)); + } + + #[test] + fn fixed_bytes_from_slice_too_many_bytes() { + DynSolValue::fixed_bytes_from_slice(&[10; 33]).unwrap_err(); + } + + #[test] + fn to_string() { + use DynSolValue::*; + + assert_eq!(Bool(false).to_string(), "false"); + assert_eq!(Bool(true).to_string(), "true"); + + assert_eq!( + Int(I256::try_from(-10).unwrap(), 256).to_string(), + "fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff6", + ); + + assert_eq!(Uint(U256::from(10), 256).to_string(), "a"); + + assert_eq!( + FixedBytes([10; 32].into(), 32).to_string(), + "0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a", + ); + + assert_eq!( + Address([10; 20].into()).to_string(), + "0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a", + ); + + assert_eq!( + Function([10; 24].into()).to_string(), + "0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a", + ); + + assert_eq!(Bytes(vec![10, 20, 30]).to_string(), "0a141e"); + + assert_eq!( + String("one two three".to_owned()).to_string(), + "one two three" + ); + + assert_eq!( + Array(vec![String("one".to_owned()), String("two".to_owned())]).to_string(), + "[one,two]", + ); + + assert_eq!( + FixedArray(vec![String("one".to_owned()), String("two".to_owned())]).to_string(), + "[one,two]" + ); + + assert_eq!( + Tuple(vec![String("one".to_owned()), String("two".to_owned())]).to_string(), + "(one,two)" + ); + } + + #[test] + fn type_check() { + use DynSolType as T; + use DynSolValue::*; + + assert!(Bool(true).type_check(&T::Bool)); + assert!(!Bool(true).type_check(&T::Int(256))); + + assert!(!Int(I256::try_from(-10).unwrap(), 32).type_check(&T::Int(24))); + assert!(Int(I256::try_from(-10).unwrap(), 32).type_check(&T::Int(32))); + assert!(Int(I256::try_from(-10).unwrap(), 32).type_check(&T::Int(256))); + assert!(!Int(I256::try_from(-10).unwrap(), 32).type_check(&T::Uint(256))); + + assert!(!Uint(U256::from(10), 32).type_check(&T::Uint(24))); + assert!(Uint(U256::from(10), 32).type_check(&T::Uint(32))); + assert!(Uint(U256::from(10), 32).type_check(&T::Uint(256))); + assert!(!Uint(U256::from(10), 32).type_check(&T::FixedBytes(32))); + + assert!(!FixedBytes([0; 32].into(), 16).type_check(&T::FixedBytes(8))); + assert!(FixedBytes([0; 32].into(), 16).type_check(&T::FixedBytes(16))); + assert!(FixedBytes([0; 32].into(), 16).type_check(&T::FixedBytes(32))); + assert!(!FixedBytes([0; 32].into(), 32).type_check(&T::Address)); + + assert!(Address([0; 20].into()).type_check(&T::Address)); + assert!(!Address([0; 20].into()).type_check(&T::Function)); + + assert!(Function([0; 24].into()).type_check(&T::Function)); + assert!(!Function([0; 24].into()).type_check(&T::Bytes)); + + assert!(Bytes(vec![0, 0, 0]).type_check(&T::Bytes)); + assert!(!Bytes(vec![0, 0, 0]).type_check(&T::String)); + + assert!(String("".to_owned()).type_check(&T::String)); + assert!(!String("".to_owned()).type_check(&T::Array(Box::new(T::Bool)))); + + assert!(Array(vec![Bool(true)]).type_check(&T::Array(Box::new(T::Bool)))); + assert!(!Array(vec![Bool(true)]).type_check(&T::Array(Box::new(T::String)))); + assert!(!Array(vec![Bool(true)]).type_check(&T::FixedArray(Box::new(T::Bool), 1))); + + assert!(!FixedArray(vec![String("".to_owned())]) + .type_check(&T::FixedArray(Box::new(T::Bool), 1))); + assert!(!FixedArray(vec![Bool(true), Bool(false)]) + .type_check(&T::FixedArray(Box::new(T::Bool), 1))); + assert!(FixedArray(vec![Bool(true), Bool(false)]) + .type_check(&T::FixedArray(Box::new(T::Bool), 2))); + assert!(!FixedArray(vec![Bool(true), Bool(false)]) + .type_check(&T::FixedArray(Box::new(T::Bool), 3))); + assert!(!FixedArray(vec![Bool(true), Bool(false)]) + .type_check(&T::Tuple(vec![T::Bool, T::Bool]))); + + assert!(!Tuple(vec![Bool(true), Bool(false)]).type_check(&T::Tuple(vec![T::Bool]))); + assert!(Tuple(vec![Bool(true), Bool(false)]).type_check(&T::Tuple(vec![T::Bool, T::Bool]))); + assert!(!Tuple(vec![Bool(true)]).type_check(&T::Tuple(vec![T::Bool, T::Bool]))); + assert!(!Tuple(vec![Bool(true)]).type_check(&T::Bool)); + } +} diff --git a/graph/src/cheap_clone.rs b/graph/src/cheap_clone.rs index b8863d3918e..0d894d84434 100644 --- a/graph/src/cheap_clone.rs +++ b/graph/src/cheap_clone.rs @@ -118,4 +118,4 @@ cheap_clone_is_copy!( &'static str, std::time::Duration ); -cheap_clone_is_copy!(ethabi::Address); +cheap_clone_is_copy!(web3::types::Address); diff --git a/graph/src/components/store/mod.rs b/graph/src/components/store/mod.rs index ab30caeda75..abda8a10bd3 100644 --- a/graph/src/components/store/mod.rs +++ b/graph/src/components/store/mod.rs @@ -1133,7 +1133,7 @@ pub struct CachedEthereumCall { pub block_ptr: BlockPtr, /// The address to the called contract. - pub contract_address: ethabi::Address, + pub contract_address: web3::types::Address, /// The encoded return value of this call. pub return_value: Vec, diff --git a/graph/src/data/store/ethereum.rs b/graph/src/data/store/ethereum.rs index 12d48f992df..ae39f1ffcbc 100644 --- a/graph/src/data/store/ethereum.rs +++ b/graph/src/data/store/ethereum.rs @@ -104,7 +104,7 @@ pub mod call { /// on the call's return value #[derive(Debug, Clone, CheapClone)] pub struct Request { - pub address: ethabi::Address, + pub address: web3::types::Address, pub encoded_call: Arc, /// The index is set by the caller and is used to identify the /// request in related data structures that the caller might have @@ -112,7 +112,7 @@ pub mod call { } impl Request { - pub fn new(address: ethabi::Address, encoded_call: Vec, index: u32) -> Self { + pub fn new(address: web3::types::Address, encoded_call: Vec, index: u32) -> Self { Request { address, encoded_call: Arc::new(Bytes::from(encoded_call)), diff --git a/graph/src/data_source/common.rs b/graph/src/data_source/common.rs index 57781815f5f..bd6eecfe05a 100644 --- a/graph/src/data_source/common.rs +++ b/graph/src/data_source/common.rs @@ -1,8 +1,10 @@ +use crate::abi; +use crate::abi::DynSolValueExt; +use crate::abi::FunctionExt; use crate::blockchain::block_stream::EntitySourceOperation; use crate::prelude::{BlockPtr, Value}; use crate::{components::link_resolver::LinkResolver, data::value::Word, prelude::Link}; use anyhow::{anyhow, Context, Error}; -use ethabi::{Address, Contract, Function, LogParam, ParamType, Token}; use graph_derive::CheapClone; use lazy_static::lazy_static; use num_bigint::Sign; @@ -11,12 +13,13 @@ use serde::de; use serde::Deserialize; use slog::Logger; use std::{str::FromStr, sync::Arc}; +use web3::types::Address; use web3::types::{Log, H160}; #[derive(Clone, Debug, PartialEq)] pub struct MappingABI { pub name: String, - pub contract: Contract, + pub contract: abi::JsonAbi, } impl MappingABI { @@ -25,24 +28,27 @@ impl MappingABI { contract_name: &str, name: &str, signature: Option<&str>, - ) -> Result<&Function, Error> { + ) -> Result<&abi::Function, Error> { let contract = &self.contract; let function = match signature { // Behavior for apiVersion < 0.0.4: look up function by name; for overloaded // functions this always picks the same overloaded variant, which is incorrect // and may lead to encoding/decoding errors - None => contract.function(name).with_context(|| { - format!( - "Unknown function \"{}::{}\" called from WASM runtime", - contract_name, name - ) - })?, + None => contract + .function(name) + .and_then(|matches| matches.first()) + .with_context(|| { + format!( + "Unknown function \"{}::{}\" called from WASM runtime", + contract_name, name + ) + })?, // Behavior for apiVersion >= 0.0.04: look up function by signature of // the form `functionName(uint256,string) returns (bytes32,string)`; this // correctly picks the correct variant of an overloaded function Some(ref signature) => contract - .functions_by_name(name) + .function(name) .with_context(|| { format!( "Unknown function \"{}::{}\" called from WASM runtime", @@ -50,7 +56,7 @@ impl MappingABI { ) })? .iter() - .find(|f| signature == &f.signature()) + .find(|f| signature == &f.signature_compat()) .with_context(|| { format!( "Unknown function \"{}::{}\" with signature `{}` \ @@ -81,7 +87,7 @@ impl UnresolvedMappingABI { self.name, self.file.link ) })?; - let contract = Contract::load(&*contract_bytes) + let contract = serde_json::from_slice(&*contract_bytes) .with_context(|| format!("failed to load ABI {}", self.name))?; Ok(MappingABI { name: self.name, @@ -123,21 +129,23 @@ impl CallDecl { self.expr.validate_args() } - pub fn address_for_log(&self, log: &Log, params: &[LogParam]) -> Result { + pub fn address_for_log(&self, log: &Log, params: &[abi::DynSolParam]) -> Result { let address = match &self.expr.address { CallArg::HexAddress(address) => *address, CallArg::Ethereum(arg) => match arg { EthereumArg::Address => log.address, EthereumArg::Param(name) => { - let value = params + let value = ¶ms .iter() .find(|param| ¶m.name == name.as_str()) - .ok_or_else(|| anyhow!("unknown param {name}"))? - .value - .clone(); - value - .into_address() - .ok_or_else(|| anyhow!("param {name} is not an address"))? + .ok_or_else(|| anyhow!("unknown param '{name}'"))? + .value; + + let address = value + .as_address() + .ok_or_else(|| anyhow!("param '{name}' is not an address"))?; + + Address::from(address.into_array()) } }, CallArg::Subgraph(_) => { @@ -149,14 +157,24 @@ impl CallDecl { Ok(address) } - pub fn args_for_log(&self, log: &Log, params: &[LogParam]) -> Result, Error> { + pub fn args_for_log( + &self, + log: &Log, + params: &[abi::DynSolParam], + ) -> Result, Error> { + use abi::DynSolValue; + self.expr .args .iter() .map(|arg| match arg { - CallArg::HexAddress(address) => Ok(Token::Address(*address)), + CallArg::HexAddress(address) => { + Ok(DynSolValue::Address(address.to_fixed_bytes().into())) + } CallArg::Ethereum(arg) => match arg { - EthereumArg::Address => Ok(Token::Address(log.address)), + EthereumArg::Address => { + Ok(DynSolValue::Address(log.address.to_fixed_bytes().into())) + } EthereumArg::Param(name) => { let value = params .iter() @@ -174,7 +192,10 @@ impl CallDecl { .collect() } - pub fn get_function(&self, mapping: &dyn FindMappingABI) -> Result { + pub fn get_function( + &self, + mapping: &dyn FindMappingABI, + ) -> Result { let contract_name = self.expr.abi.to_string(); let function_name = self.expr.func.as_str(); let abi = mapping.find_abi(&contract_name)?; @@ -185,6 +206,7 @@ impl CallDecl { // and may lead to encoding/decoding errors abi.contract .function(function_name) + .and_then(|matches| matches.first()) .cloned() .with_context(|| { format!( @@ -232,8 +254,8 @@ impl CallDecl { pub fn args_for_entity_handler( &self, entity: &EntitySourceOperation, - param_types: Vec, - ) -> Result, Error> { + param_types: Vec, + ) -> Result, Error> { self.validate_entity_handler_args(¶m_types)?; self.expr @@ -247,7 +269,7 @@ impl CallDecl { } /// Validates that the number of provided arguments matches the expected parameter types. - fn validate_entity_handler_args(&self, param_types: &[ParamType]) -> Result<(), Error> { + fn validate_entity_handler_args(&self, param_types: &[abi::DynSolType]) -> Result<(), Error> { if self.expr.args.len() != param_types.len() { return Err(anyhow!( "mismatched number of arguments: expected {}, got {}", @@ -263,9 +285,9 @@ impl CallDecl { fn process_entity_handler_arg( &self, arg: &CallArg, - expected_type: &ParamType, + expected_type: &abi::DynSolType, entity: &EntitySourceOperation, - ) -> Result { + ) -> Result { match arg { CallArg::HexAddress(address) => self.process_hex_address(*address, expected_type), CallArg::Ethereum(_) => Err(anyhow!( @@ -281,10 +303,12 @@ impl CallDecl { fn process_hex_address( &self, address: H160, - expected_type: &ParamType, - ) -> Result { + expected_type: &abi::DynSolType, + ) -> Result { match expected_type { - ParamType::Address => Ok(Token::Address(address)), + abi::DynSolType::Address => { + Ok(abi::DynSolValue::Address(address.to_fixed_bytes().into())) + } _ => Err(anyhow!( "type mismatch: hex address provided for non-address parameter" )), @@ -295,9 +319,9 @@ impl CallDecl { fn process_entity_param( &self, name: &str, - expected_type: &ParamType, + expected_type: &abi::DynSolType, entity: &EntitySourceOperation, - ) -> Result { + ) -> Result { let value = entity .entity .get(name) @@ -311,27 +335,43 @@ impl CallDecl { fn convert_entity_value_to_token( &self, value: &Value, - expected_type: &ParamType, + expected_type: &abi::DynSolType, param_name: &str, - ) -> Result { + ) -> Result { + use abi::DynSolType; + use abi::DynSolValue; + match (expected_type, value) { - (ParamType::Address, Value::Bytes(b)) => { - Ok(Token::Address(H160::from_slice(b.as_slice()))) + (DynSolType::Address, Value::Bytes(b)) => { + Ok(DynSolValue::Address(b.as_slice().try_into()?)) + } + (DynSolType::Bytes, Value::Bytes(b)) => Ok(DynSolValue::Bytes(b.as_ref().to_vec())), + (DynSolType::FixedBytes(size), Value::Bytes(b)) if b.len() == *size => { + DynSolValue::fixed_bytes_from_slice(b.as_ref()) + } + (DynSolType::String, Value::String(s)) => Ok(DynSolValue::String(s.to_string())), + (DynSolType::Bool, Value::Bool(b)) => Ok(DynSolValue::Bool(*b)), + (DynSolType::Int(_), Value::Int(i)) => { + let x = abi::I256::try_from(*i)?; + Ok(DynSolValue::Int(x, x.bits() as usize)) + } + (DynSolType::Int(_), Value::Int8(i)) => { + let x = abi::I256::try_from(*i)?; + Ok(DynSolValue::Int(x, x.bits() as usize)) + } + (DynSolType::Int(_), Value::BigInt(i)) => { + let x = abi::I256::from_limbs(i.to_signed_u256().0); + Ok(DynSolValue::Int(x, x.bits() as usize)) } - (ParamType::Bytes, Value::Bytes(b)) => Ok(Token::Bytes(b.as_ref().to_vec())), - (ParamType::FixedBytes(size), Value::Bytes(b)) if b.len() == *size => { - Ok(Token::FixedBytes(b.as_ref().to_vec())) + (DynSolType::Uint(_), Value::Int(i)) if *i >= 0 => { + let x = abi::U256::try_from(*i)?; + Ok(DynSolValue::Uint(x, x.bit_len())) } - (ParamType::String, Value::String(s)) => Ok(Token::String(s.to_string())), - (ParamType::Bool, Value::Bool(b)) => Ok(Token::Bool(*b)), - (ParamType::Int(_), Value::Int(i)) => Ok(Token::Int((*i).into())), - (ParamType::Int(_), Value::Int8(i)) => Ok(Token::Int((*i).into())), - (ParamType::Int(_), Value::BigInt(i)) => Ok(Token::Int(i.to_signed_u256())), - (ParamType::Uint(_), Value::Int(i)) if *i >= 0 => Ok(Token::Uint((*i).into())), - (ParamType::Uint(_), Value::BigInt(i)) if i.sign() == Sign::Plus => { - Ok(Token::Uint(i.to_unsigned_u256())) + (DynSolType::Uint(_), Value::BigInt(i)) if i.sign() == Sign::Plus => { + let x = abi::U256::from_limbs(i.to_unsigned_u256().0); + Ok(DynSolValue::Uint(x, x.bit_len())) } - (ParamType::Array(inner_type), Value::List(values)) => { + (DynSolType::Array(inner_type), Value::List(values)) => { self.process_entity_array_values(values, inner_type.as_ref(), param_name) } _ => Err(anyhow!( @@ -345,17 +385,17 @@ impl CallDecl { fn process_entity_array_values( &self, values: &[Value], - inner_type: &ParamType, + inner_type: &abi::DynSolType, param_name: &str, - ) -> Result { - let tokens: Result, Error> = values + ) -> Result { + let tokens: Result, Error> = values .iter() .enumerate() .map(|(idx, v)| { self.convert_entity_value_to_token(v, inner_type, &format!("{param_name}[{idx}]")) }) .collect(); - Ok(Token::Array(tokens?)) + Ok(abi::DynSolValue::Array(tokens?)) } } @@ -531,8 +571,8 @@ pub struct DeclaredCall { label: String, contract_name: String, address: Address, - function: Function, - args: Vec, + function: abi::Function, + args: Vec, } impl DeclaredCall { @@ -540,8 +580,8 @@ impl DeclaredCall { mapping: &dyn FindMappingABI, call_decls: &CallDecls, log: &Log, - params: &[LogParam], - ) -> Result, anyhow::Error> { + params: &[abi::DynSolParam], + ) -> Result, Error> { Self::create_calls(mapping, call_decls, |decl, _| { Ok(( decl.address_for_log(log, params)?, @@ -554,13 +594,13 @@ impl DeclaredCall { mapping: &dyn FindMappingABI, call_decls: &CallDecls, entity: &EntitySourceOperation, - ) -> Result, anyhow::Error> { + ) -> Result, Error> { Self::create_calls(mapping, call_decls, |decl, function| { let param_types = function .inputs .iter() - .map(|param| param.kind.clone()) - .collect::>(); + .map(|param| param.selector_type().parse()) + .collect::, _>>()?; Ok(( decl.address_for_entity_handler(entity)?, @@ -580,7 +620,7 @@ impl DeclaredCall { get_address_and_args: F, ) -> Result, anyhow::Error> where - F: Fn(&CallDecl, &Function) -> Result<(Address, Vec), anyhow::Error>, + F: Fn(&CallDecl, &abi::Function) -> Result<(Address, Vec), anyhow::Error>, { let mut calls = Vec::new(); for decl in call_decls.decls.iter() { @@ -618,8 +658,8 @@ pub struct ContractCall { pub contract_name: String, pub address: Address, pub block_ptr: BlockPtr, - pub function: Function, - pub args: Vec, + pub function: abi::Function, + pub args: Vec, pub gas: Option, } diff --git a/graph/src/lib.rs b/graph/src/lib.rs index 7d1536929bd..39bd7f5a88c 100644 --- a/graph/src/lib.rs +++ b/graph/src/lib.rs @@ -37,8 +37,11 @@ pub mod env; pub mod ipfs; +pub mod abi; + /// Wrapper for spawning tasks that abort on panic, which is our default. mod task_spawn; + pub use task_spawn::{ block_on, spawn, spawn_allow_panic, spawn_blocking, spawn_blocking_allow_panic, spawn_thread, }; @@ -81,7 +84,6 @@ pub mod prelude { pub use chrono; pub use diesel; pub use envconfig; - pub use ethabi; pub use hex; pub use isatty; pub use lazy_static::lazy_static; diff --git a/runtime/test/src/common.rs b/runtime/test/src/common.rs index 461d4a08256..c2a7d3a231b 100644 --- a/runtime/test/src/common.rs +++ b/runtime/test/src/common.rs @@ -1,4 +1,3 @@ -use ethabi::Contract; use graph::blockchain::BlockTime; use graph::components::store::DeploymentLocator; use graph::components::subgraph::SharedProofOfIndexing; @@ -82,7 +81,7 @@ fn mock_host_exports( fn mock_abi() -> MappingABI { MappingABI { name: "mock_abi".to_string(), - contract: Contract::load( + contract: serde_json::from_str( r#"[ { "inputs": [ @@ -93,8 +92,7 @@ fn mock_abi() -> MappingABI { ], "type": "constructor" } - ]"# - .as_bytes(), + ]"#, ) .unwrap(), } diff --git a/runtime/test/src/test/abi.rs b/runtime/test/src/test/abi.rs index b681287c50c..ac733bad554 100644 --- a/runtime/test/src/test/abi.rs +++ b/runtime/test/src/test/abi.rs @@ -1,4 +1,5 @@ -use graph::prelude::{ethabi::Token, web3::types::U256}; +use graph::abi; +use graph::prelude::web3::types::U256; use graph_runtime_wasm::asc_abi::class::{ ArrayBuffer, AscAddress, AscEnum, AscEnumArray, EthereumValueKind, StoreValueKind, TypedArray, }; @@ -178,9 +179,9 @@ async fn abi_bytes_and_fixed_bytes_v0_0_5() { test_abi_bytes_and_fixed_bytes(API_VERSION_0_0_5).await; } -async fn test_abi_ethabi_token_identity(api_version: Version) { +async fn test_abi_alloy_token_identity(api_version: Version) { let mut instance = test_module( - "abiEthabiTokenIdentity", + "abiAlloyTokenIdentity", mock_data_source( &wasm_file_path("abi_token.wasm", api_version.clone()), api_version.clone(), @@ -190,8 +191,8 @@ async fn test_abi_ethabi_token_identity(api_version: Version) { .await; // Token::Address - let address = H160([1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1]); - let token_address = Token::Address(address); + let address = [1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1]; + let token_address = abi::DynSolValue::Address(address.into()); let new_address_obj: AscPtr = instance.invoke_export1("token_to_address", &token_address); @@ -202,7 +203,7 @@ async fn test_abi_ethabi_token_identity(api_version: Version) { assert_eq!(token_address, new_token); // Token::Bytes - let token_bytes = Token::Bytes(vec![42, 45, 7, 245, 45]); + let token_bytes = abi::DynSolValue::Bytes(vec![42, 45, 7, 245, 45]); let new_bytes_obj: AscPtr = instance.invoke_export1("token_to_bytes", &token_bytes); let new_token_ptr = instance.takes_ptr_returns_ptr("token_from_bytes", new_bytes_obj); @@ -211,7 +212,8 @@ async fn test_abi_ethabi_token_identity(api_version: Version) { assert_eq!(token_bytes, new_token); // Token::Int - let int_token = Token::Int(U256([256, 453452345, 0, 42])); + let int = abi::I256::from_limbs([256, 453452345, 0, 42]); + let int_token = abi::DynSolValue::Int(int, int.bits() as usize); let new_int_obj: AscPtr = instance.invoke_export1("token_to_int", &int_token); let new_token_ptr = instance.takes_ptr_returns_ptr("token_from_int", new_int_obj); @@ -220,7 +222,8 @@ async fn test_abi_ethabi_token_identity(api_version: Version) { assert_eq!(int_token, new_token); // Token::Uint - let uint_token = Token::Uint(U256([256, 453452345, 0, 42])); + let uint = abi::U256::from_limbs([256, 453452345, 0, 42]); + let uint_token = abi::DynSolValue::Uint(uint, uint.bit_len()); let new_uint_obj: AscPtr = instance.invoke_export1("token_to_uint", &uint_token); let new_token_ptr = instance.takes_ptr_returns_ptr("token_from_uint", new_uint_obj); @@ -230,7 +233,7 @@ async fn test_abi_ethabi_token_identity(api_version: Version) { assert_ne!(uint_token, int_token); // Token::Bool - let token_bool = Token::Bool(true); + let token_bool = abi::DynSolValue::Bool(true); let token_bool_ptr = instance.asc_new(&token_bool).unwrap(); let func = instance @@ -251,7 +254,7 @@ async fn test_abi_ethabi_token_identity(api_version: Version) { assert_eq!(token_bool, new_token); // Token::String - let token_string = Token::String("漢字Go🇧🇷".into()); + let token_string = abi::DynSolValue::String("漢字Go🇧🇷".into()); let new_string_obj: AscPtr = instance.invoke_export1("token_to_string", &token_string); let new_token_ptr = instance.takes_ptr_returns_ptr("token_from_string", new_string_obj); @@ -260,13 +263,13 @@ async fn test_abi_ethabi_token_identity(api_version: Version) { assert_eq!(token_string, new_token); // Token::Array - let token_array = Token::Array(vec![token_address, token_bytes, token_bool]); - let token_array_nested = Token::Array(vec![token_string, token_array]); + let token_array = abi::DynSolValue::Array(vec![token_address, token_bytes, token_bool]); + let token_array_nested = abi::DynSolValue::Array(vec![token_string, token_array]); let new_array_obj: AscEnumArray = instance.invoke_export1("token_to_array", &token_array_nested); let new_token_ptr = instance.takes_ptr_returns_ptr("token_from_array", new_array_obj); - let new_token: Token = instance.asc_get(new_token_ptr).unwrap(); + let new_token: abi::DynSolValue = instance.asc_get(new_token_ptr).unwrap(); assert_eq!(new_token, token_array_nested); } @@ -274,15 +277,15 @@ async fn test_abi_ethabi_token_identity(api_version: Version) { /// Test a roundtrip Token -> Payload -> Token identity conversion through asc, /// and assert the final token is the same as the starting one. #[tokio::test] -async fn abi_ethabi_token_identity_v0_0_4() { - test_abi_ethabi_token_identity(API_VERSION_0_0_4).await; +async fn abi_alloy_token_identity_v0_0_4() { + test_abi_alloy_token_identity(API_VERSION_0_0_4).await; } /// Test a roundtrip Token -> Payload -> Token identity conversion through asc, /// and assert the final token is the same as the starting one. #[tokio::test] -async fn abi_ethabi_token_identity_v0_0_5() { - test_abi_ethabi_token_identity(API_VERSION_0_0_5).await; +async fn abi_alloy_token_identity_v0_0_5() { + test_abi_alloy_token_identity(API_VERSION_0_0_5).await; } async fn test_abi_store_value(api_version: Version) { diff --git a/runtime/wasm/Cargo.toml b/runtime/wasm/Cargo.toml index dfbd7983b1c..2ca24759d0d 100644 --- a/runtime/wasm/Cargo.toml +++ b/runtime/wasm/Cargo.toml @@ -5,7 +5,6 @@ edition.workspace = true [dependencies] async-trait = "0.1.50" -ethabi = "17.2" hex = "0.4.3" graph = { path = "../../graph" } bs58 = "0.4.0" diff --git a/runtime/wasm/src/asc_abi/class.rs b/runtime/wasm/src/asc_abi/class.rs index 1fae1ad9ce0..1e69c9690df 100644 --- a/runtime/wasm/src/asc_abi/class.rs +++ b/runtime/wasm/src/asc_abi/class.rs @@ -1,5 +1,4 @@ -use ethabi; - +use graph::abi; use graph::{ data::store::{self, scalar::Timestamp}, runtime::{ @@ -535,21 +534,25 @@ pub enum EthereumValueKind { FixedArray, Array, Tuple, + Function, } impl EthereumValueKind { - pub(crate) fn get_kind(token: ðabi::Token) -> Self { - match token { - ethabi::Token::Address(_) => EthereumValueKind::Address, - ethabi::Token::FixedBytes(_) => EthereumValueKind::FixedBytes, - ethabi::Token::Bytes(_) => EthereumValueKind::Bytes, - ethabi::Token::Int(_) => EthereumValueKind::Int, - ethabi::Token::Uint(_) => EthereumValueKind::Uint, - ethabi::Token::Bool(_) => EthereumValueKind::Bool, - ethabi::Token::String(_) => EthereumValueKind::String, - ethabi::Token::FixedArray(_) => EthereumValueKind::FixedArray, - ethabi::Token::Array(_) => EthereumValueKind::Array, - ethabi::Token::Tuple(_) => EthereumValueKind::Tuple, + pub(crate) fn get_kind(value: &abi::DynSolValue) -> Self { + use graph::abi::DynSolValue; + + match value { + DynSolValue::Bool(_) => Self::Bool, + DynSolValue::Int(_, _) => Self::Int, + DynSolValue::Uint(_, _) => Self::Uint, + DynSolValue::FixedBytes(_, _) => Self::FixedBytes, + DynSolValue::Address(_) => Self::Address, + DynSolValue::Function(_) => Self::Function, + DynSolValue::Bytes(_) => Self::Bytes, + DynSolValue::String(_) => Self::String, + DynSolValue::Array(_) => Self::Array, + DynSolValue::FixedArray(_) => Self::FixedArray, + DynSolValue::Tuple(_) => Self::Tuple, } } } diff --git a/runtime/wasm/src/host_exports.rs b/runtime/wasm/src/host_exports.rs index 12099c55b7e..732deaa221b 100644 --- a/runtime/wasm/src/host_exports.rs +++ b/runtime/wasm/src/host_exports.rs @@ -11,6 +11,7 @@ use never::Never; use semver::Version; use web3::types::H160; +use graph::abi; use graph::blockchain::BlockTime; use graph::blockchain::Blockchain; use graph::components::store::{EnsLookup, GetScope, LoadRelatedRequest}; @@ -20,8 +21,6 @@ use graph::components::subgraph::{ use graph::data::store::{self}; use graph::data_source::{CausalityRegion, DataSource, EntityTypeAccess}; use graph::ensure; -use graph::prelude::ethabi::param_type::Reader; -use graph::prelude::ethabi::{decode, encode, Token}; use graph::prelude::serde_json; use graph::prelude::{slog::b, slog::record_static, *}; use graph::runtime::gas::{self, complexity, Gas, GasCounter}; @@ -1181,11 +1180,11 @@ impl HostExports { pub(crate) fn ethereum_encode( &self, - token: Token, + value: abi::DynSolValue, gas: &GasCounter, state: &mut BlockState, ) -> Result, DeterministicHostError> { - let encoded = encode(&[token]); + let encoded = value.abi_encode(); Self::track_gas_and_ops( gas, @@ -1203,7 +1202,7 @@ impl HostExports { data: Vec, gas: &GasCounter, state: &mut BlockState, - ) -> Result { + ) -> Result { Self::track_gas_and_ops( gas, state, @@ -1211,15 +1210,9 @@ impl HostExports { "ethereum_decode", )?; - let param_types = - Reader::read(&types).map_err(|e| anyhow::anyhow!("Failed to read types: {}", e))?; + let ty: abi::DynSolType = types.parse().context("Failed to read types")?; - decode(&[param_types], &data) - // The `.pop().unwrap()` here is ok because we're always only passing one - // `param_types` to `decode`, so the returned `Vec` has always size of one. - // We can't do `tokens[0]` because the value can't be moved out of the `Vec`. - .map(|mut tokens| tokens.pop().unwrap()) - .context("Failed to decode") + ty.abi_decode(&data).context("Failed to decode") } pub(crate) fn yaml_from_bytes( diff --git a/runtime/wasm/src/to_from/external.rs b/runtime/wasm/src/to_from/external.rs index 6bb7122613f..85074f492ca 100644 --- a/runtime/wasm/src/to_from/external.rs +++ b/runtime/wasm/src/to_from/external.rs @@ -1,5 +1,5 @@ -use ethabi; - +use graph::abi; +use graph::abi::DynSolValueExt; use graph::data::store::scalar::Timestamp; use graph::data::value::Word; use graph::prelude::{BigDecimal, BigInt}; @@ -163,32 +163,42 @@ impl ToAscObj>> for Vec { } } -impl ToAscObj> for ethabi::Token { +impl ToAscObj> for abi::DynSolValue { fn to_asc_obj( &self, heap: &mut H, gas: &GasCounter, ) -> Result, HostExportError> { - use ethabi::Token::*; - let kind = EthereumValueKind::get_kind(self); + let payload = match self { - Address(address) => asc_new::(heap, address, gas)?.to_payload(), - FixedBytes(bytes) | Bytes(bytes) => { - asc_new::(heap, &**bytes, gas)?.to_payload() - } - Int(uint) => { - let n = BigInt::from_signed_u256(uint); + Self::Bool(val) => *val as u64, + Self::Int(val, _) => { + let bytes = val.to_le_bytes::<32>(); + let n = BigInt::from_signed_bytes_le(&bytes)?; + asc_new(heap, &n, gas)?.to_payload() } - Uint(uint) => { - let n = BigInt::from_unsigned_u256(uint); + Self::Uint(val, _) => { + let bytes = val.to_le_bytes::<32>(); + let n = BigInt::from_unsigned_bytes_le(&bytes)?; + asc_new(heap, &n, gas)?.to_payload() } - Bool(b) => *b as u64, - String(string) => asc_new(heap, &**string, gas)?.to_payload(), - FixedArray(tokens) | Array(tokens) => asc_new(heap, &**tokens, gas)?.to_payload(), - Tuple(tokens) => asc_new(heap, &**tokens, gas)?.to_payload(), + Self::FixedBytes(val, _) => { + asc_new::(heap, val.as_slice(), gas)?.to_payload() + } + Self::Address(val) => { + asc_new::(heap, val.as_slice(), gas)?.to_payload() + } + Self::Function(val) => { + asc_new::(heap, val.as_slice(), gas)?.to_payload() + } + Self::Bytes(val) => asc_new::(heap, &**val, gas)?.to_payload(), + Self::String(val) => asc_new(heap, &**val, gas)?.to_payload(), + Self::Array(values) => asc_new(heap, &**values, gas)?.to_payload(), + Self::FixedArray(values) => asc_new(heap, &**values, gas)?.to_payload(), + Self::Tuple(values) => asc_new(heap, &**values, gas)?.to_payload(), }; Ok(AscEnum { @@ -199,57 +209,78 @@ impl ToAscObj> for ethabi::Token { } } -impl FromAscObj> for ethabi::Token { +impl FromAscObj> for abi::DynSolValue { fn from_asc_obj( asc_enum: AscEnum, heap: &H, gas: &GasCounter, depth: usize, ) -> Result { - use ethabi::Token; - let payload = asc_enum.payload; - Ok(match asc_enum.kind { - EthereumValueKind::Bool => Token::Bool(bool::from(payload)), + + let value = match asc_enum.kind { EthereumValueKind::Address => { let ptr: AscPtr = AscPtr::from(payload); - Token::Address(asc_get(heap, ptr, gas, depth)?) + let bytes: [u8; 20] = asc_get(heap, ptr, gas, depth)?; + + Self::Address(bytes.into()) } EthereumValueKind::FixedBytes => { let ptr: AscPtr = AscPtr::from(payload); - Token::FixedBytes(asc_get(heap, ptr, gas, depth)?) + let bytes: Vec = asc_get(heap, ptr, gas, depth)?; + + Self::fixed_bytes_from_slice(&bytes)? } EthereumValueKind::Bytes => { let ptr: AscPtr = AscPtr::from(payload); - Token::Bytes(asc_get(heap, ptr, gas, depth)?) + let bytes: Vec = asc_get(heap, ptr, gas, depth)?; + + Self::Bytes(bytes) } EthereumValueKind::Int => { let ptr: AscPtr = AscPtr::from(payload); let n: BigInt = asc_get(heap, ptr, gas, depth)?; - Token::Int(n.to_signed_u256()) + let x = abi::I256::from_limbs(n.to_signed_u256().0); + + Self::Int(x, x.bits() as usize) } EthereumValueKind::Uint => { let ptr: AscPtr = AscPtr::from(payload); let n: BigInt = asc_get(heap, ptr, gas, depth)?; - Token::Uint(n.to_unsigned_u256()) + let x = abi::U256::from_limbs(n.to_unsigned_u256().0); + + Self::Uint(x, x.bit_len()) } + EthereumValueKind::Bool => Self::Bool(bool::from(payload)), EthereumValueKind::String => { let ptr: AscPtr = AscPtr::from(payload); - Token::String(asc_get(heap, ptr, gas, depth)?) + + Self::String(asc_get(heap, ptr, gas, depth)?) } EthereumValueKind::FixedArray => { let ptr: AscEnumArray = AscPtr::from(payload); - Token::FixedArray(asc_get(heap, ptr, gas, depth)?) + + Self::FixedArray(asc_get(heap, ptr, gas, depth)?) } EthereumValueKind::Array => { let ptr: AscEnumArray = AscPtr::from(payload); - Token::Array(asc_get(heap, ptr, gas, depth)?) + + Self::Array(asc_get(heap, ptr, gas, depth)?) } EthereumValueKind::Tuple => { let ptr: AscEnumArray = AscPtr::from(payload); - Token::Tuple(asc_get(heap, ptr, gas, depth)?) + + Self::Tuple(asc_get(heap, ptr, gas, depth)?) } - }) + EthereumValueKind::Function => { + let ptr: AscPtr = AscPtr::from(payload); + let bytes: [u8; 24] = asc_get(heap, ptr, gas, depth)?; + + Self::Function(bytes.into()) + } + }; + + Ok(value) } } diff --git a/store/postgres/src/chain_store.rs b/store/postgres/src/chain_store.rs index a94c44a8870..8877e828072 100644 --- a/store/postgres/src/chain_store.rs +++ b/store/postgres/src/chain_store.rs @@ -99,8 +99,8 @@ mod data { use graph::blockchain::{Block, BlockHash}; use graph::data::store::scalar::Bytes; use graph::internal_error; - use graph::prelude::ethabi::ethereum_types::H160; use graph::prelude::transaction_receipt::LightTransactionReceipt; + use graph::prelude::web3::types::H160; use graph::prelude::web3::types::H256; use graph::prelude::{ serde_json as json, BlockNumber, BlockPtr, CachedEthereumCall, Error, StoreError, diff --git a/store/test-store/Cargo.toml b/store/test-store/Cargo.toml index 2435b447570..58071829315 100644 --- a/store/test-store/Cargo.toml +++ b/store/test-store/Cargo.toml @@ -19,3 +19,4 @@ prost-types = { workspace = true } [dev-dependencies] hex = "0.4.3" pretty_assertions = "1.4.1" +serde_json = { workspace = true } diff --git a/store/test-store/tests/postgres/store.rs b/store/test-store/tests/postgres/store.rs index 28fd05da18f..cf9c2bae428 100644 --- a/store/test-store/tests/postgres/store.rs +++ b/store/test-store/tests/postgres/store.rs @@ -15,7 +15,6 @@ use graph::data::subgraph::*; use graph::{ blockchain::DataSource, components::store::{BlockStore as _, EntityFilter, EntityOrder, EntityQuery, StatusStore}, - prelude::ethabi::Contract, }; use graph::{data::store::scalar, semver::Version}; use graph::{entity, prelude::*}; @@ -1059,19 +1058,18 @@ fn mock_data_source() -> graph_chain_ethereum::DataSource { fn mock_abi() -> MappingABI { MappingABI { name: "mock_abi".to_string(), - contract: Contract::load( + contract: serde_json::from_str( r#"[ - { - "inputs": [ - { - "name": "a", - "type": "address" - } - ], - "type": "constructor" - } - ]"# - .as_bytes(), + { + "inputs": [ + { + "name": "a", + "type": "address" + } + ], + "type": "constructor" + } + ]"#, ) .unwrap(), } diff --git a/tests/src/fixture/ethereum.rs b/tests/src/fixture/ethereum.rs index d93ac25c235..12d9f3325e7 100644 --- a/tests/src/fixture/ethereum.rs +++ b/tests/src/fixture/ethereum.rs @@ -6,16 +6,18 @@ use super::{ test_ptr, CommonChainConfig, MutexBlockStreamBuilder, NoopAdapterSelector, NoopRuntimeAdapterBuilder, StaticBlockRefetcher, StaticStreamBuilder, Stores, TestChain, }; +use graph::abi; +use graph::blockchain::block_stream::BlockWithTriggers; use graph::blockchain::block_stream::{EntityOperationKind, EntitySourceOperation}; use graph::blockchain::client::ChainClient; use graph::blockchain::{BlockPtr, Trigger, TriggersAdapterSelector}; use graph::cheap_clone::CheapClone; use graph::data_source::subgraph; -use graph::prelude::ethabi::ethereum_types::H256; +use graph::prelude::web3::types::H256; +use graph::prelude::web3::types::U64; use graph::prelude::web3::types::{Address, Log, Transaction, H160}; -use graph::prelude::{ethabi, tiny_keccak, DeploymentHash, Entity, LightEthereumBlock, ENV_VARS}; +use graph::prelude::{tiny_keccak, DeploymentHash, Entity, LightEthereumBlock, ENV_VARS}; use graph::schema::EntityType; -use graph::{blockchain::block_stream::BlockWithTriggers, prelude::ethabi::ethereum_types::U64}; use graph_chain_ethereum::network::EthereumNetworkAdapters; use graph_chain_ethereum::trigger::LogRef; use graph_chain_ethereum::Chain; @@ -145,7 +147,7 @@ pub fn push_test_log(block: &mut BlockWithTriggers, payload: impl Into