1#[allow(
287 non_camel_case_types,
288 non_snake_case,
289 clippy::pub_underscore_fields,
290 clippy::style,
291 clippy::empty_structs_with_brackets
292)]
293pub mod HoprNodeSafeRegistry {
294 use super::*;
295 use alloy::sol_types as alloy_sol_types;
296 #[rustfmt::skip]
302 #[allow(clippy::all)]
303 pub static BYTECODE: alloy_sol_types::private::Bytes = alloy_sol_types::private::Bytes::from_static(
304 b"`\x80`@R4\x80\x15a\0\x10W`\0\x80\xFD[Pa\0\x19a\0\x1EV[a\x010V[`@\x80Q\x80\x82\x01\x82R`\x10\x81RoNodeSafeRegistry`\x80\x1B` \x91\x82\x01R\x81Q\x80\x83\x01\x83R`\x05\x81Rd\x03\x12\xE3\x02\xE3`\xDC\x1B\x90\x82\x01R\x81Q\x7F\x8Bs\xC3\xC6\x9B\xB8\xFE=Q.\xCCL\xF7Y\xCCy#\x9F{\x17\x9B\x0F\xFA\xCA\xA9\xA7]R+9@\x0F\x81\x83\x01R\x7FD\x7F\xBA\xD4\xD4k\xBC\x04Y\x0C\xBAl,\x05\x8Er\x91\x0E\xA4\x03\x98\xCD4\x08Ss\xB9\x8E\xA4\xDA\xA0\xE8\x81\x84\x01R\x7F\x06\xC0\x15\xBD\"\xB4\xC6\x96\x90\x93<\x10X\x87\x8E\xBD\xFE\xF3\x1F\x9A\xAA\xE4\x0B\xBE\x86\xD8\xA0\x9F\xE1\xB2\x97,``\x82\x01RF`\x80\x82\x01R0`\xA0\x80\x83\x01\x91\x90\x91R\x83Q\x80\x83\x03\x90\x91\x01\x81R`\xC0\x90\x91\x01\x90\x92R\x81Q\x91\x01 `\0T\x81\x14a\x01-W`\0\x81\x81U`@Q\x82\x91\x7Fw\x1FR@\xAE_\xD8\xA7d\r?\xB8/\xA7\n\xAB/\xB1\xDB\xF3_.\xF4d\xF8P\x99Fqvd\xC5\x91\xA2[PV[a\x0C\xDD\x80a\x01?`\09`\0\xF3\xFE`\x80`@R4\x80\x15a\0\x10W`\0\x80\xFD[P`\x046\x10a\0\x9EW`\x005`\xE0\x1C\x80c\x89\xCC\xFE\x89\x11a\0fW\x80c\x89\xCC\xFE\x89\x14a\x01lW\x80c\x91`|L\x14a\x01tW\x80c\xAA\x90\xF2\xA5\x14a\x01\x87W\x80c\xF6\x98\xDA%\x14a\x01\xC0W\x80c\xFF\xA1\xADt\x14a\x01\xC9W`\0\x80\xFD[\x80c7H\n\xBD\x14a\0\xA3W\x80cI\xD2\x15\xE1\x14a\0\xCBW\x80c\x7F\x93Y1\x14a\0\xE0W\x80c\x84\xB0\xDE\xC2\x14a\0\xF3W\x80c\x89\x97\x8C@\x14a\x01(W[`\0\x80\xFD[a\0\xB6a\0\xB16`\x04a\t\xC9V[a\x01\xFAV[`@Q\x90\x15\x15\x81R` \x01[`@Q\x80\x91\x03\x90\xF3[a\0\xDEa\0\xD96`\x04a\n\x02V[a\x02KV[\0[a\0\xDEa\0\xEE6`\x04a\n\x94V[a\x03\xBBV[a\x01\x1A\x7F\xA8\xACz\xED\x12\x8D\x1A-\xA0w?\xEC\xC8\x0Bbe\xD1_~b\xBFD\x01\xEB#\xBDF\xC3\xFC\xF5\xD2\xF8\x81V[`@Q\x90\x81R` \x01a\0\xC2V[a\x01Ta\x0166`\x04a\n\x94V[`\x01`\x01`\xA0\x1B\x03\x90\x81\x16`\0\x90\x81R`\x01` R`@\x90 T\x16\x90V[`@Q`\x01`\x01`\xA0\x1B\x03\x90\x91\x16\x81R` \x01a\0\xC2V[a\0\xDEa\x03\xC8V[a\0\xDEa\x01\x826`\x04a\n\x94V[a\x04\xD9V[a\x01\x1Aa\x01\x956`\x04a\n\x94V[`\x01`\x01`\xA0\x1B\x03\x16`\0\x90\x81R`\x01` R`@\x90 T`\x01`\xA0\x1B\x90\x04`\x01`\x01``\x1B\x03\x16\x90V[a\x01\x1A`\0T\x81V[a\x01\xED`@Q\x80`@\x01`@R\x80`\x05\x81R` \x01d\x03\x12\xE3\x02\xE3`\xDC\x1B\x81RP\x81V[`@Qa\0\xC2\x91\x90a\n\xB8V[`\x01`\x01`\xA0\x1B\x03\x81\x81\x16`\0\x90\x81R`\x01` R`@\x81 T\x90\x91\x16a\x02#WP`\0a\x02EV[P`\x01`\x01`\xA0\x1B\x03\x81\x81\x16`\0\x90\x81R`\x01` R`@\x90 T\x81\x16\x90\x83\x16\x14[\x92\x91PPV[`\x01`\x01`\xA0\x1B\x03\x83\x81\x16`\0\x81\x81R`\x01` \x90\x81R`@\x80\x83 T\x81Q\x7F\xA8\xACz\xED\x12\x8D\x1A-\xA0w?\xEC\xC8\x0Bbe\xD1_~b\xBFD\x01\xEB#\xBDF\xC3\xFC\xF5\xD2\xF8\x81\x85\x01R\x95\x8A\x16\x86\x83\x01R``\x86\x01\x94\x90\x94R`\x01`\x01``\x1B\x03`\x01`\xA0\x1B\x90\x94\x04\x93\x90\x93\x16`\x80\x80\x86\x01\x91\x90\x91R\x83Q\x80\x86\x03\x90\x91\x01\x81R`\xA0\x85\x01\x84R\x80Q\x90\x82\x01 \x82T`\x19`\xF8\x1B`\xC0\x87\x01R`\x01`\xF8\x1B`\xC1\x87\x01R`\xC2\x86\x01R`\xE2\x80\x86\x01\x82\x90R\x84Q\x80\x87\x03\x90\x91\x01\x81Ra\x01\x02\x86\x01\x80\x86R\x81Q\x91\x84\x01\x91\x90\x91 a\x01\"`\x1F\x89\x01\x85\x90\x04\x90\x94\x02\x87\x01\x84\x01\x90\x95R\x86\x81R\x90\x94\x83\x92a\x03Q\x92\x86\x92\x90\x91\x8A\x91\x8A\x91\x82\x91\x01\x83\x82\x80\x82\x847`\0\x92\x01\x91\x90\x91RPa\x05m\x92PPPV[\x90\x92P\x90P`\0\x81`\x04\x81\x11\x15a\x03jWa\x03ja\x0B\x06V[\x14\x15\x80a\x03\x89WP\x86`\x01`\x01`\xA0\x1B\x03\x16\x82`\x01`\x01`\xA0\x1B\x03\x16\x14\x15[\x15a\x03\xA7W`@Qc\xB4\xC9\x1F\xFB`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a\x03\xB1\x88\x88a\x05\xB2V[PPPPPPPPV[a\x03\xC5\x813a\x05\xB2V[PV[`@\x80Q\x80\x82\x01\x82R`\x10\x81RoNodeSafeRegistry`\x80\x1B` \x91\x82\x01R\x81Q\x80\x83\x01\x83R`\x05\x81Rd\x03\x12\xE3\x02\xE3`\xDC\x1B\x90\x82\x01R\x81Q\x7F\x8Bs\xC3\xC6\x9B\xB8\xFE=Q.\xCCL\xF7Y\xCCy#\x9F{\x17\x9B\x0F\xFA\xCA\xA9\xA7]R+9@\x0F\x81\x83\x01R\x7FD\x7F\xBA\xD4\xD4k\xBC\x04Y\x0C\xBAl,\x05\x8Er\x91\x0E\xA4\x03\x98\xCD4\x08Ss\xB9\x8E\xA4\xDA\xA0\xE8\x81\x84\x01R\x7F\x06\xC0\x15\xBD\"\xB4\xC6\x96\x90\x93<\x10X\x87\x8E\xBD\xFE\xF3\x1F\x9A\xAA\xE4\x0B\xBE\x86\xD8\xA0\x9F\xE1\xB2\x97,``\x82\x01RF`\x80\x82\x01R0`\xA0\x80\x83\x01\x91\x90\x91R\x83Q\x80\x83\x03\x90\x91\x01\x81R`\xC0\x90\x91\x01\x90\x92R\x81Q\x91\x01 `\0T\x81\x14a\x03\xC5W`\0\x81\x81U`@Q\x82\x91\x7Fw\x1FR@\xAE_\xD8\xA7d\r?\xB8/\xA7\n\xAB/\xB1\xDB\xF3_.\xF4d\xF8P\x99Fqvd\xC5\x91\xA2PV[`\x01`\x01`\xA0\x1B\x03\x81\x81\x16`\0\x90\x81R`\x01` R`@\x90 T\x163\x14a\x05\x13W`@Qc\x15\xBF\xA1U`\xE2\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a\x05\x1D3\x82a\x07\x10V[`\x01`\x01`\xA0\x1B\x03\x81\x16`\0\x81\x81R`\x01` R`@\x80\x82 \x80T`\x01`\x01`\xA0\x1B\x03\x19\x16\x90UQ3\x91\x7F\xE87\xF39c\x92\x96\xBE\xC9\xF4\xBC\x98aT\xF5\xFFv\xBB\xBE\xFC1I\xA5\x12\x92\x0E\x13\x11AN=\xA1\x91\xA3PV[`\0\x80\x82Q`A\x03a\x05\xA3W` \x83\x01Q`@\x84\x01Q``\x85\x01Q`\0\x1Aa\x05\x97\x87\x82\x85\x85a\x08\xF0V[\x94P\x94PPPPa\x05\xABV[P`\0\x90P`\x02[\x92P\x92\x90PV[`\x01`\x01`\xA0\x1B\x03\x82\x16a\x05\xD9W`@Qc\x14\xE7\x92!`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`\x01`\x01`\xA0\x1B\x03\x81\x16a\x06\0W`@Qc>\x87j\x93`\xE1\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`\x01`\x01`\xA0\x1B\x03\x81\x16;\x15a\x06)W`@Qc\x1F\x82\x9F\x03`\xE2\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`\x01`\x01`\xA0\x1B\x03\x81\x81\x16`\0\x90\x81R`\x01` R`@\x90 T\x16\x15a\x06bW`@Qcg\xDC0\x01`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a\x06l\x82\x82a\x07\x10V[`\x01`\x01`\xA0\x1B\x03\x81\x81\x16`\0\x90\x81R`\x01` \x81\x90R`@\x90\x91 \x80T`\x01`\x01`\xA0\x1B\x03\x19\x16\x92\x85\x16\x92\x90\x92\x17\x80\x83Ua\x06\xB9\x91`\x01`\xA0\x1B\x90\x91\x04`\x01`\x01``\x1B\x03\x16\x90a\x0B2V[\x81T`\x01`\x01``\x1B\x03\x91\x90\x91\x16`\x01`\xA0\x1B\x02`\x01`\x01`\xA0\x1B\x03\x91\x82\x16\x17\x82U`@Q\x83\x82\x16\x91\x85\x16\x90\x7Fwm\xA4\x0C\xBF,\"5Rf\x1B\xD4\x85\x02\xCE\xB7$\t\xB36+\xB0\xC6m\x89\x89\xBD~ \xE4I}\x90`\0\x90\xA3PPPV[`\0``[`\x01`\x01`\xA0\x1B\x03\x82\x16`\x01\x14a\x08\xD7W`@Qcf\x17\xC2)`\xE1\x1B\x81R`\x01`\x04\x82\x01R`d`$\x82\x01R`\x01`\x01`\xA0\x1B\x03\x85\x16\x90c\xCC/\x84R\x90`D\x01`\0`@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x07rW=`\0\x80>=`\0\xFD[PPPP`@Q=`\0\x82>`\x1F=\x90\x81\x01`\x1F\x19\x16\x82\x01`@Ra\x07\x9A\x91\x90\x81\x01\x90a\x0B\x7FV[\x92P\x90P`\0[\x81Q\x81\x10\x15a\x08\xD1W\x81\x81\x81Q\x81\x10a\x07\xBCWa\x07\xBCa\x0CVV[` \x02` \x01\x01Q`\x01`\x01`\xA0\x1B\x03\x16cJ\x1B\xA4\x08`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x08\x01W=`\0\x80>=`\0\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x08%\x91\x90a\x0ClV[\x80\x15a\x08\xB3WP\x81\x81\x81Q\x81\x10a\x08>Wa\x08>a\x0CVV[` \x90\x81\x02\x91\x90\x91\x01\x01Q`@Qb\xBA\x80\xA9`\xE1\x1B\x81R`\x01`\x01`\xA0\x1B\x03\x86\x81\x16`\x04\x83\x01R\x90\x91\x16\x90c\x01u\x01R\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x08\x8FW=`\0\x80>=`\0\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x08\xB3\x91\x90a\x0ClV[\x15a\x08\xBFWPPPPPV[\x80a\x08\xC9\x81a\x0C\x8EV[\x91PPa\x07\xA1V[Pa\x07\x15V[`@Qc\x0B\xA5\xD7\xEB`\xE4\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`\0\x80\x7F\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF]WnsW\xA4P\x1D\xDF\xE9/Fh\x1B \xA0\x83\x11\x15a\t'WP`\0\x90P`\x03a\t\xABV[`@\x80Q`\0\x80\x82R` \x82\x01\x80\x84R\x89\x90R`\xFF\x88\x16\x92\x82\x01\x92\x90\x92R``\x81\x01\x86\x90R`\x80\x81\x01\x85\x90R`\x01\x90`\xA0\x01` `@Q` \x81\x03\x90\x80\x84\x03\x90\x85Z\xFA\x15\x80\x15a\t{W=`\0\x80>=`\0\xFD[PP`@Q`\x1F\x19\x01Q\x91PP`\x01`\x01`\xA0\x1B\x03\x81\x16a\t\xA4W`\0`\x01\x92P\x92PPa\t\xABV[\x91P`\0\x90P[\x94P\x94\x92PPPV[`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14a\x03\xC5W`\0\x80\xFD[`\0\x80`@\x83\x85\x03\x12\x15a\t\xDCW`\0\x80\xFD[\x825a\t\xE7\x81a\t\xB4V[\x91P` \x83\x015a\t\xF7\x81a\t\xB4V[\x80\x91PP\x92P\x92\x90PV[`\0\x80`\0\x80``\x85\x87\x03\x12\x15a\n\x18W`\0\x80\xFD[\x845a\n#\x81a\t\xB4V[\x93P` \x85\x015a\n3\x81a\t\xB4V[\x92P`@\x85\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x82\x11\x15a\nPW`\0\x80\xFD[\x81\x87\x01\x91P\x87`\x1F\x83\x01\x12a\ndW`\0\x80\xFD[\x815\x81\x81\x11\x15a\nsW`\0\x80\xFD[\x88` \x82\x85\x01\x01\x11\x15a\n\x85W`\0\x80\xFD[\x95\x98\x94\x97PP` \x01\x94PPPV[`\0` \x82\x84\x03\x12\x15a\n\xA6W`\0\x80\xFD[\x815a\n\xB1\x81a\t\xB4V[\x93\x92PPPV[`\0` \x80\x83R\x83Q\x80\x82\x85\x01R`\0[\x81\x81\x10\x15a\n\xE5W\x85\x81\x01\x83\x01Q\x85\x82\x01`@\x01R\x82\x01a\n\xC9V[P`\0`@\x82\x86\x01\x01R`@`\x1F\x19`\x1F\x83\x01\x16\x85\x01\x01\x92PPP\x92\x91PPV[cNH{q`\xE0\x1B`\0R`!`\x04R`$`\0\xFD[cNH{q`\xE0\x1B`\0R`\x11`\x04R`$`\0\xFD[`\x01`\x01``\x1B\x03\x81\x81\x16\x83\x82\x16\x01\x90\x80\x82\x11\x15a\x0BRWa\x0BRa\x0B\x1CV[P\x92\x91PPV[cNH{q`\xE0\x1B`\0R`A`\x04R`$`\0\xFD[\x80Qa\x0Bz\x81a\t\xB4V[\x91\x90PV[`\0\x80`@\x83\x85\x03\x12\x15a\x0B\x92W`\0\x80\xFD[\x82Qg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x82\x11\x15a\x0B\xAAW`\0\x80\xFD[\x81\x85\x01\x91P\x85`\x1F\x83\x01\x12a\x0B\xBEW`\0\x80\xFD[\x81Q` \x82\x82\x11\x15a\x0B\xD2Wa\x0B\xD2a\x0BYV[\x81`\x05\x1B`@Q`\x1F\x19`?\x83\x01\x16\x81\x01\x81\x81\x10\x86\x82\x11\x17\x15a\x0B\xF7Wa\x0B\xF7a\x0BYV[`@R\x92\x83R\x81\x83\x01\x93P\x84\x81\x01\x82\x01\x92\x89\x84\x11\x15a\x0C\x15W`\0\x80\xFD[\x94\x82\x01\x94[\x83\x86\x10\x15a\x0C:Wa\x0C+\x86a\x0BoV[\x85R\x94\x82\x01\x94\x93\x82\x01\x93a\x0C\x1AV[\x96Pa\x0CI\x90P\x87\x82\x01a\x0BoV[\x94PPPPP\x92P\x92\x90PV[cNH{q`\xE0\x1B`\0R`2`\x04R`$`\0\xFD[`\0` \x82\x84\x03\x12\x15a\x0C~W`\0\x80\xFD[\x81Q\x80\x15\x15\x81\x14a\n\xB1W`\0\x80\xFD[`\0`\x01\x82\x01a\x0C\xA0Wa\x0C\xA0a\x0B\x1CV[P`\x01\x01\x90V\xFE\xA2dipfsX\"\x12 -g\xFA\x1A\xF1\xDD\xAE\x10r\0R\xD5\x7F\x9A]\0\xDFV\xF8?\x13U\xF6![\xCB\n\x83\x87@q\xE2dsolcC\0\x08\x13\x003",
305 );
306 #[rustfmt::skip]
312 #[allow(clippy::all)]
313 pub static DEPLOYED_BYTECODE: alloy_sol_types::private::Bytes = alloy_sol_types::private::Bytes::from_static(
314 b"`\x80`@R4\x80\x15a\0\x10W`\0\x80\xFD[P`\x046\x10a\0\x9EW`\x005`\xE0\x1C\x80c\x89\xCC\xFE\x89\x11a\0fW\x80c\x89\xCC\xFE\x89\x14a\x01lW\x80c\x91`|L\x14a\x01tW\x80c\xAA\x90\xF2\xA5\x14a\x01\x87W\x80c\xF6\x98\xDA%\x14a\x01\xC0W\x80c\xFF\xA1\xADt\x14a\x01\xC9W`\0\x80\xFD[\x80c7H\n\xBD\x14a\0\xA3W\x80cI\xD2\x15\xE1\x14a\0\xCBW\x80c\x7F\x93Y1\x14a\0\xE0W\x80c\x84\xB0\xDE\xC2\x14a\0\xF3W\x80c\x89\x97\x8C@\x14a\x01(W[`\0\x80\xFD[a\0\xB6a\0\xB16`\x04a\t\xC9V[a\x01\xFAV[`@Q\x90\x15\x15\x81R` \x01[`@Q\x80\x91\x03\x90\xF3[a\0\xDEa\0\xD96`\x04a\n\x02V[a\x02KV[\0[a\0\xDEa\0\xEE6`\x04a\n\x94V[a\x03\xBBV[a\x01\x1A\x7F\xA8\xACz\xED\x12\x8D\x1A-\xA0w?\xEC\xC8\x0Bbe\xD1_~b\xBFD\x01\xEB#\xBDF\xC3\xFC\xF5\xD2\xF8\x81V[`@Q\x90\x81R` \x01a\0\xC2V[a\x01Ta\x0166`\x04a\n\x94V[`\x01`\x01`\xA0\x1B\x03\x90\x81\x16`\0\x90\x81R`\x01` R`@\x90 T\x16\x90V[`@Q`\x01`\x01`\xA0\x1B\x03\x90\x91\x16\x81R` \x01a\0\xC2V[a\0\xDEa\x03\xC8V[a\0\xDEa\x01\x826`\x04a\n\x94V[a\x04\xD9V[a\x01\x1Aa\x01\x956`\x04a\n\x94V[`\x01`\x01`\xA0\x1B\x03\x16`\0\x90\x81R`\x01` R`@\x90 T`\x01`\xA0\x1B\x90\x04`\x01`\x01``\x1B\x03\x16\x90V[a\x01\x1A`\0T\x81V[a\x01\xED`@Q\x80`@\x01`@R\x80`\x05\x81R` \x01d\x03\x12\xE3\x02\xE3`\xDC\x1B\x81RP\x81V[`@Qa\0\xC2\x91\x90a\n\xB8V[`\x01`\x01`\xA0\x1B\x03\x81\x81\x16`\0\x90\x81R`\x01` R`@\x81 T\x90\x91\x16a\x02#WP`\0a\x02EV[P`\x01`\x01`\xA0\x1B\x03\x81\x81\x16`\0\x90\x81R`\x01` R`@\x90 T\x81\x16\x90\x83\x16\x14[\x92\x91PPV[`\x01`\x01`\xA0\x1B\x03\x83\x81\x16`\0\x81\x81R`\x01` \x90\x81R`@\x80\x83 T\x81Q\x7F\xA8\xACz\xED\x12\x8D\x1A-\xA0w?\xEC\xC8\x0Bbe\xD1_~b\xBFD\x01\xEB#\xBDF\xC3\xFC\xF5\xD2\xF8\x81\x85\x01R\x95\x8A\x16\x86\x83\x01R``\x86\x01\x94\x90\x94R`\x01`\x01``\x1B\x03`\x01`\xA0\x1B\x90\x94\x04\x93\x90\x93\x16`\x80\x80\x86\x01\x91\x90\x91R\x83Q\x80\x86\x03\x90\x91\x01\x81R`\xA0\x85\x01\x84R\x80Q\x90\x82\x01 \x82T`\x19`\xF8\x1B`\xC0\x87\x01R`\x01`\xF8\x1B`\xC1\x87\x01R`\xC2\x86\x01R`\xE2\x80\x86\x01\x82\x90R\x84Q\x80\x87\x03\x90\x91\x01\x81Ra\x01\x02\x86\x01\x80\x86R\x81Q\x91\x84\x01\x91\x90\x91 a\x01\"`\x1F\x89\x01\x85\x90\x04\x90\x94\x02\x87\x01\x84\x01\x90\x95R\x86\x81R\x90\x94\x83\x92a\x03Q\x92\x86\x92\x90\x91\x8A\x91\x8A\x91\x82\x91\x01\x83\x82\x80\x82\x847`\0\x92\x01\x91\x90\x91RPa\x05m\x92PPPV[\x90\x92P\x90P`\0\x81`\x04\x81\x11\x15a\x03jWa\x03ja\x0B\x06V[\x14\x15\x80a\x03\x89WP\x86`\x01`\x01`\xA0\x1B\x03\x16\x82`\x01`\x01`\xA0\x1B\x03\x16\x14\x15[\x15a\x03\xA7W`@Qc\xB4\xC9\x1F\xFB`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a\x03\xB1\x88\x88a\x05\xB2V[PPPPPPPPV[a\x03\xC5\x813a\x05\xB2V[PV[`@\x80Q\x80\x82\x01\x82R`\x10\x81RoNodeSafeRegistry`\x80\x1B` \x91\x82\x01R\x81Q\x80\x83\x01\x83R`\x05\x81Rd\x03\x12\xE3\x02\xE3`\xDC\x1B\x90\x82\x01R\x81Q\x7F\x8Bs\xC3\xC6\x9B\xB8\xFE=Q.\xCCL\xF7Y\xCCy#\x9F{\x17\x9B\x0F\xFA\xCA\xA9\xA7]R+9@\x0F\x81\x83\x01R\x7FD\x7F\xBA\xD4\xD4k\xBC\x04Y\x0C\xBAl,\x05\x8Er\x91\x0E\xA4\x03\x98\xCD4\x08Ss\xB9\x8E\xA4\xDA\xA0\xE8\x81\x84\x01R\x7F\x06\xC0\x15\xBD\"\xB4\xC6\x96\x90\x93<\x10X\x87\x8E\xBD\xFE\xF3\x1F\x9A\xAA\xE4\x0B\xBE\x86\xD8\xA0\x9F\xE1\xB2\x97,``\x82\x01RF`\x80\x82\x01R0`\xA0\x80\x83\x01\x91\x90\x91R\x83Q\x80\x83\x03\x90\x91\x01\x81R`\xC0\x90\x91\x01\x90\x92R\x81Q\x91\x01 `\0T\x81\x14a\x03\xC5W`\0\x81\x81U`@Q\x82\x91\x7Fw\x1FR@\xAE_\xD8\xA7d\r?\xB8/\xA7\n\xAB/\xB1\xDB\xF3_.\xF4d\xF8P\x99Fqvd\xC5\x91\xA2PV[`\x01`\x01`\xA0\x1B\x03\x81\x81\x16`\0\x90\x81R`\x01` R`@\x90 T\x163\x14a\x05\x13W`@Qc\x15\xBF\xA1U`\xE2\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a\x05\x1D3\x82a\x07\x10V[`\x01`\x01`\xA0\x1B\x03\x81\x16`\0\x81\x81R`\x01` R`@\x80\x82 \x80T`\x01`\x01`\xA0\x1B\x03\x19\x16\x90UQ3\x91\x7F\xE87\xF39c\x92\x96\xBE\xC9\xF4\xBC\x98aT\xF5\xFFv\xBB\xBE\xFC1I\xA5\x12\x92\x0E\x13\x11AN=\xA1\x91\xA3PV[`\0\x80\x82Q`A\x03a\x05\xA3W` \x83\x01Q`@\x84\x01Q``\x85\x01Q`\0\x1Aa\x05\x97\x87\x82\x85\x85a\x08\xF0V[\x94P\x94PPPPa\x05\xABV[P`\0\x90P`\x02[\x92P\x92\x90PV[`\x01`\x01`\xA0\x1B\x03\x82\x16a\x05\xD9W`@Qc\x14\xE7\x92!`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`\x01`\x01`\xA0\x1B\x03\x81\x16a\x06\0W`@Qc>\x87j\x93`\xE1\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`\x01`\x01`\xA0\x1B\x03\x81\x16;\x15a\x06)W`@Qc\x1F\x82\x9F\x03`\xE2\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`\x01`\x01`\xA0\x1B\x03\x81\x81\x16`\0\x90\x81R`\x01` R`@\x90 T\x16\x15a\x06bW`@Qcg\xDC0\x01`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a\x06l\x82\x82a\x07\x10V[`\x01`\x01`\xA0\x1B\x03\x81\x81\x16`\0\x90\x81R`\x01` \x81\x90R`@\x90\x91 \x80T`\x01`\x01`\xA0\x1B\x03\x19\x16\x92\x85\x16\x92\x90\x92\x17\x80\x83Ua\x06\xB9\x91`\x01`\xA0\x1B\x90\x91\x04`\x01`\x01``\x1B\x03\x16\x90a\x0B2V[\x81T`\x01`\x01``\x1B\x03\x91\x90\x91\x16`\x01`\xA0\x1B\x02`\x01`\x01`\xA0\x1B\x03\x91\x82\x16\x17\x82U`@Q\x83\x82\x16\x91\x85\x16\x90\x7Fwm\xA4\x0C\xBF,\"5Rf\x1B\xD4\x85\x02\xCE\xB7$\t\xB36+\xB0\xC6m\x89\x89\xBD~ \xE4I}\x90`\0\x90\xA3PPPV[`\0``[`\x01`\x01`\xA0\x1B\x03\x82\x16`\x01\x14a\x08\xD7W`@Qcf\x17\xC2)`\xE1\x1B\x81R`\x01`\x04\x82\x01R`d`$\x82\x01R`\x01`\x01`\xA0\x1B\x03\x85\x16\x90c\xCC/\x84R\x90`D\x01`\0`@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x07rW=`\0\x80>=`\0\xFD[PPPP`@Q=`\0\x82>`\x1F=\x90\x81\x01`\x1F\x19\x16\x82\x01`@Ra\x07\x9A\x91\x90\x81\x01\x90a\x0B\x7FV[\x92P\x90P`\0[\x81Q\x81\x10\x15a\x08\xD1W\x81\x81\x81Q\x81\x10a\x07\xBCWa\x07\xBCa\x0CVV[` \x02` \x01\x01Q`\x01`\x01`\xA0\x1B\x03\x16cJ\x1B\xA4\x08`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x08\x01W=`\0\x80>=`\0\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x08%\x91\x90a\x0ClV[\x80\x15a\x08\xB3WP\x81\x81\x81Q\x81\x10a\x08>Wa\x08>a\x0CVV[` \x90\x81\x02\x91\x90\x91\x01\x01Q`@Qb\xBA\x80\xA9`\xE1\x1B\x81R`\x01`\x01`\xA0\x1B\x03\x86\x81\x16`\x04\x83\x01R\x90\x91\x16\x90c\x01u\x01R\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x08\x8FW=`\0\x80>=`\0\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x08\xB3\x91\x90a\x0ClV[\x15a\x08\xBFWPPPPPV[\x80a\x08\xC9\x81a\x0C\x8EV[\x91PPa\x07\xA1V[Pa\x07\x15V[`@Qc\x0B\xA5\xD7\xEB`\xE4\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`\0\x80\x7F\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF]WnsW\xA4P\x1D\xDF\xE9/Fh\x1B \xA0\x83\x11\x15a\t'WP`\0\x90P`\x03a\t\xABV[`@\x80Q`\0\x80\x82R` \x82\x01\x80\x84R\x89\x90R`\xFF\x88\x16\x92\x82\x01\x92\x90\x92R``\x81\x01\x86\x90R`\x80\x81\x01\x85\x90R`\x01\x90`\xA0\x01` `@Q` \x81\x03\x90\x80\x84\x03\x90\x85Z\xFA\x15\x80\x15a\t{W=`\0\x80>=`\0\xFD[PP`@Q`\x1F\x19\x01Q\x91PP`\x01`\x01`\xA0\x1B\x03\x81\x16a\t\xA4W`\0`\x01\x92P\x92PPa\t\xABV[\x91P`\0\x90P[\x94P\x94\x92PPPV[`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14a\x03\xC5W`\0\x80\xFD[`\0\x80`@\x83\x85\x03\x12\x15a\t\xDCW`\0\x80\xFD[\x825a\t\xE7\x81a\t\xB4V[\x91P` \x83\x015a\t\xF7\x81a\t\xB4V[\x80\x91PP\x92P\x92\x90PV[`\0\x80`\0\x80``\x85\x87\x03\x12\x15a\n\x18W`\0\x80\xFD[\x845a\n#\x81a\t\xB4V[\x93P` \x85\x015a\n3\x81a\t\xB4V[\x92P`@\x85\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x82\x11\x15a\nPW`\0\x80\xFD[\x81\x87\x01\x91P\x87`\x1F\x83\x01\x12a\ndW`\0\x80\xFD[\x815\x81\x81\x11\x15a\nsW`\0\x80\xFD[\x88` \x82\x85\x01\x01\x11\x15a\n\x85W`\0\x80\xFD[\x95\x98\x94\x97PP` \x01\x94PPPV[`\0` \x82\x84\x03\x12\x15a\n\xA6W`\0\x80\xFD[\x815a\n\xB1\x81a\t\xB4V[\x93\x92PPPV[`\0` \x80\x83R\x83Q\x80\x82\x85\x01R`\0[\x81\x81\x10\x15a\n\xE5W\x85\x81\x01\x83\x01Q\x85\x82\x01`@\x01R\x82\x01a\n\xC9V[P`\0`@\x82\x86\x01\x01R`@`\x1F\x19`\x1F\x83\x01\x16\x85\x01\x01\x92PPP\x92\x91PPV[cNH{q`\xE0\x1B`\0R`!`\x04R`$`\0\xFD[cNH{q`\xE0\x1B`\0R`\x11`\x04R`$`\0\xFD[`\x01`\x01``\x1B\x03\x81\x81\x16\x83\x82\x16\x01\x90\x80\x82\x11\x15a\x0BRWa\x0BRa\x0B\x1CV[P\x92\x91PPV[cNH{q`\xE0\x1B`\0R`A`\x04R`$`\0\xFD[\x80Qa\x0Bz\x81a\t\xB4V[\x91\x90PV[`\0\x80`@\x83\x85\x03\x12\x15a\x0B\x92W`\0\x80\xFD[\x82Qg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x82\x11\x15a\x0B\xAAW`\0\x80\xFD[\x81\x85\x01\x91P\x85`\x1F\x83\x01\x12a\x0B\xBEW`\0\x80\xFD[\x81Q` \x82\x82\x11\x15a\x0B\xD2Wa\x0B\xD2a\x0BYV[\x81`\x05\x1B`@Q`\x1F\x19`?\x83\x01\x16\x81\x01\x81\x81\x10\x86\x82\x11\x17\x15a\x0B\xF7Wa\x0B\xF7a\x0BYV[`@R\x92\x83R\x81\x83\x01\x93P\x84\x81\x01\x82\x01\x92\x89\x84\x11\x15a\x0C\x15W`\0\x80\xFD[\x94\x82\x01\x94[\x83\x86\x10\x15a\x0C:Wa\x0C+\x86a\x0BoV[\x85R\x94\x82\x01\x94\x93\x82\x01\x93a\x0C\x1AV[\x96Pa\x0CI\x90P\x87\x82\x01a\x0BoV[\x94PPPPP\x92P\x92\x90PV[cNH{q`\xE0\x1B`\0R`2`\x04R`$`\0\xFD[`\0` \x82\x84\x03\x12\x15a\x0C~W`\0\x80\xFD[\x81Q\x80\x15\x15\x81\x14a\n\xB1W`\0\x80\xFD[`\0`\x01\x82\x01a\x0C\xA0Wa\x0C\xA0a\x0B\x1CV[P`\x01\x01\x90V\xFE\xA2dipfsX\"\x12 -g\xFA\x1A\xF1\xDD\xAE\x10r\0R\xD5\x7F\x9A]\0\xDFV\xF8?\x13U\xF6![\xCB\n\x83\x87@q\xE2dsolcC\0\x08\x13\x003",
315 );
316 #[derive(serde::Serialize, serde::Deserialize)]
317 #[derive(Default, Debug, PartialEq, Eq, Hash)]
318 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
323 #[derive(Clone)]
324 pub struct NodeAddressZero;
325 #[allow(
326 non_camel_case_types,
327 non_snake_case,
328 clippy::pub_underscore_fields,
329 clippy::style
330 )]
331 const _: () = {
332 use alloy::sol_types as alloy_sol_types;
333 #[doc(hidden)]
334 type UnderlyingSolTuple<'a> = ();
335 #[doc(hidden)]
336 type UnderlyingRustTuple<'a> = ();
337 #[cfg(test)]
338 #[allow(dead_code, unreachable_patterns)]
339 fn _type_assertion(
340 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
341 ) {
342 match _t {
343 alloy_sol_types::private::AssertTypeEq::<
344 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
345 >(_) => {}
346 }
347 }
348 #[automatically_derived]
349 #[doc(hidden)]
350 impl ::core::convert::From<NodeAddressZero> for UnderlyingRustTuple<'_> {
351 fn from(value: NodeAddressZero) -> Self {
352 ()
353 }
354 }
355 #[automatically_derived]
356 #[doc(hidden)]
357 impl ::core::convert::From<UnderlyingRustTuple<'_>> for NodeAddressZero {
358 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
359 Self
360 }
361 }
362 #[automatically_derived]
363 impl alloy_sol_types::SolError for NodeAddressZero {
364 type Parameters<'a> = UnderlyingSolTuple<'a>;
365 type Token<'a> = <Self::Parameters<
366 'a,
367 > as alloy_sol_types::SolType>::Token<'a>;
368 const SIGNATURE: &'static str = "NodeAddressZero()";
369 const SELECTOR: [u8; 4] = [125u8, 14u8, 213u8, 38u8];
370 #[inline]
371 fn new<'a>(
372 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
373 ) -> Self {
374 tuple.into()
375 }
376 #[inline]
377 fn tokenize(&self) -> Self::Token<'_> {
378 ()
379 }
380 #[inline]
381 fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
382 <Self::Parameters<
383 '_,
384 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
385 .map(Self::new)
386 }
387 }
388 };
389 #[derive(serde::Serialize, serde::Deserialize)]
390 #[derive(Default, Debug, PartialEq, Eq, Hash)]
391 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
396 #[derive(Clone)]
397 pub struct NodeHasSafe;
398 #[allow(
399 non_camel_case_types,
400 non_snake_case,
401 clippy::pub_underscore_fields,
402 clippy::style
403 )]
404 const _: () = {
405 use alloy::sol_types as alloy_sol_types;
406 #[doc(hidden)]
407 type UnderlyingSolTuple<'a> = ();
408 #[doc(hidden)]
409 type UnderlyingRustTuple<'a> = ();
410 #[cfg(test)]
411 #[allow(dead_code, unreachable_patterns)]
412 fn _type_assertion(
413 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
414 ) {
415 match _t {
416 alloy_sol_types::private::AssertTypeEq::<
417 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
418 >(_) => {}
419 }
420 }
421 #[automatically_derived]
422 #[doc(hidden)]
423 impl ::core::convert::From<NodeHasSafe> for UnderlyingRustTuple<'_> {
424 fn from(value: NodeHasSafe) -> Self {
425 ()
426 }
427 }
428 #[automatically_derived]
429 #[doc(hidden)]
430 impl ::core::convert::From<UnderlyingRustTuple<'_>> for NodeHasSafe {
431 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
432 Self
433 }
434 }
435 #[automatically_derived]
436 impl alloy_sol_types::SolError for NodeHasSafe {
437 type Parameters<'a> = UnderlyingSolTuple<'a>;
438 type Token<'a> = <Self::Parameters<
439 'a,
440 > as alloy_sol_types::SolType>::Token<'a>;
441 const SIGNATURE: &'static str = "NodeHasSafe()";
442 const SELECTOR: [u8; 4] = [103u8, 220u8, 48u8, 1u8];
443 #[inline]
444 fn new<'a>(
445 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
446 ) -> Self {
447 tuple.into()
448 }
449 #[inline]
450 fn tokenize(&self) -> Self::Token<'_> {
451 ()
452 }
453 #[inline]
454 fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
455 <Self::Parameters<
456 '_,
457 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
458 .map(Self::new)
459 }
460 }
461 };
462 #[derive(serde::Serialize, serde::Deserialize)]
463 #[derive(Default, Debug, PartialEq, Eq, Hash)]
464 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
469 #[derive(Clone)]
470 pub struct NodeIsContract;
471 #[allow(
472 non_camel_case_types,
473 non_snake_case,
474 clippy::pub_underscore_fields,
475 clippy::style
476 )]
477 const _: () = {
478 use alloy::sol_types as alloy_sol_types;
479 #[doc(hidden)]
480 type UnderlyingSolTuple<'a> = ();
481 #[doc(hidden)]
482 type UnderlyingRustTuple<'a> = ();
483 #[cfg(test)]
484 #[allow(dead_code, unreachable_patterns)]
485 fn _type_assertion(
486 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
487 ) {
488 match _t {
489 alloy_sol_types::private::AssertTypeEq::<
490 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
491 >(_) => {}
492 }
493 }
494 #[automatically_derived]
495 #[doc(hidden)]
496 impl ::core::convert::From<NodeIsContract> for UnderlyingRustTuple<'_> {
497 fn from(value: NodeIsContract) -> Self {
498 ()
499 }
500 }
501 #[automatically_derived]
502 #[doc(hidden)]
503 impl ::core::convert::From<UnderlyingRustTuple<'_>> for NodeIsContract {
504 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
505 Self
506 }
507 }
508 #[automatically_derived]
509 impl alloy_sol_types::SolError for NodeIsContract {
510 type Parameters<'a> = UnderlyingSolTuple<'a>;
511 type Token<'a> = <Self::Parameters<
512 'a,
513 > as alloy_sol_types::SolType>::Token<'a>;
514 const SIGNATURE: &'static str = "NodeIsContract()";
515 const SELECTOR: [u8; 4] = [126u8, 10u8, 124u8, 12u8];
516 #[inline]
517 fn new<'a>(
518 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
519 ) -> Self {
520 tuple.into()
521 }
522 #[inline]
523 fn tokenize(&self) -> Self::Token<'_> {
524 ()
525 }
526 #[inline]
527 fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
528 <Self::Parameters<
529 '_,
530 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
531 .map(Self::new)
532 }
533 }
534 };
535 #[derive(serde::Serialize, serde::Deserialize)]
536 #[derive(Default, Debug, PartialEq, Eq, Hash)]
537 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
542 #[derive(Clone)]
543 pub struct NodeNotModuleMember;
544 #[allow(
545 non_camel_case_types,
546 non_snake_case,
547 clippy::pub_underscore_fields,
548 clippy::style
549 )]
550 const _: () = {
551 use alloy::sol_types as alloy_sol_types;
552 #[doc(hidden)]
553 type UnderlyingSolTuple<'a> = ();
554 #[doc(hidden)]
555 type UnderlyingRustTuple<'a> = ();
556 #[cfg(test)]
557 #[allow(dead_code, unreachable_patterns)]
558 fn _type_assertion(
559 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
560 ) {
561 match _t {
562 alloy_sol_types::private::AssertTypeEq::<
563 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
564 >(_) => {}
565 }
566 }
567 #[automatically_derived]
568 #[doc(hidden)]
569 impl ::core::convert::From<NodeNotModuleMember> for UnderlyingRustTuple<'_> {
570 fn from(value: NodeNotModuleMember) -> Self {
571 ()
572 }
573 }
574 #[automatically_derived]
575 #[doc(hidden)]
576 impl ::core::convert::From<UnderlyingRustTuple<'_>> for NodeNotModuleMember {
577 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
578 Self
579 }
580 }
581 #[automatically_derived]
582 impl alloy_sol_types::SolError for NodeNotModuleMember {
583 type Parameters<'a> = UnderlyingSolTuple<'a>;
584 type Token<'a> = <Self::Parameters<
585 'a,
586 > as alloy_sol_types::SolType>::Token<'a>;
587 const SIGNATURE: &'static str = "NodeNotModuleMember()";
588 const SELECTOR: [u8; 4] = [186u8, 93u8, 126u8, 176u8];
589 #[inline]
590 fn new<'a>(
591 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
592 ) -> Self {
593 tuple.into()
594 }
595 #[inline]
596 fn tokenize(&self) -> Self::Token<'_> {
597 ()
598 }
599 #[inline]
600 fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
601 <Self::Parameters<
602 '_,
603 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
604 .map(Self::new)
605 }
606 }
607 };
608 #[derive(serde::Serialize, serde::Deserialize)]
609 #[derive(Default, Debug, PartialEq, Eq, Hash)]
610 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
615 #[derive(Clone)]
616 pub struct NotValidSafe;
617 #[allow(
618 non_camel_case_types,
619 non_snake_case,
620 clippy::pub_underscore_fields,
621 clippy::style
622 )]
623 const _: () = {
624 use alloy::sol_types as alloy_sol_types;
625 #[doc(hidden)]
626 type UnderlyingSolTuple<'a> = ();
627 #[doc(hidden)]
628 type UnderlyingRustTuple<'a> = ();
629 #[cfg(test)]
630 #[allow(dead_code, unreachable_patterns)]
631 fn _type_assertion(
632 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
633 ) {
634 match _t {
635 alloy_sol_types::private::AssertTypeEq::<
636 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
637 >(_) => {}
638 }
639 }
640 #[automatically_derived]
641 #[doc(hidden)]
642 impl ::core::convert::From<NotValidSafe> for UnderlyingRustTuple<'_> {
643 fn from(value: NotValidSafe) -> Self {
644 ()
645 }
646 }
647 #[automatically_derived]
648 #[doc(hidden)]
649 impl ::core::convert::From<UnderlyingRustTuple<'_>> for NotValidSafe {
650 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
651 Self
652 }
653 }
654 #[automatically_derived]
655 impl alloy_sol_types::SolError for NotValidSafe {
656 type Parameters<'a> = UnderlyingSolTuple<'a>;
657 type Token<'a> = <Self::Parameters<
658 'a,
659 > as alloy_sol_types::SolType>::Token<'a>;
660 const SIGNATURE: &'static str = "NotValidSafe()";
661 const SELECTOR: [u8; 4] = [86u8, 254u8, 133u8, 84u8];
662 #[inline]
663 fn new<'a>(
664 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
665 ) -> Self {
666 tuple.into()
667 }
668 #[inline]
669 fn tokenize(&self) -> Self::Token<'_> {
670 ()
671 }
672 #[inline]
673 fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
674 <Self::Parameters<
675 '_,
676 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
677 .map(Self::new)
678 }
679 }
680 };
681 #[derive(serde::Serialize, serde::Deserialize)]
682 #[derive(Default, Debug, PartialEq, Eq, Hash)]
683 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
688 #[derive(Clone)]
689 pub struct NotValidSignatureFromNode;
690 #[allow(
691 non_camel_case_types,
692 non_snake_case,
693 clippy::pub_underscore_fields,
694 clippy::style
695 )]
696 const _: () = {
697 use alloy::sol_types as alloy_sol_types;
698 #[doc(hidden)]
699 type UnderlyingSolTuple<'a> = ();
700 #[doc(hidden)]
701 type UnderlyingRustTuple<'a> = ();
702 #[cfg(test)]
703 #[allow(dead_code, unreachable_patterns)]
704 fn _type_assertion(
705 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
706 ) {
707 match _t {
708 alloy_sol_types::private::AssertTypeEq::<
709 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
710 >(_) => {}
711 }
712 }
713 #[automatically_derived]
714 #[doc(hidden)]
715 impl ::core::convert::From<NotValidSignatureFromNode>
716 for UnderlyingRustTuple<'_> {
717 fn from(value: NotValidSignatureFromNode) -> Self {
718 ()
719 }
720 }
721 #[automatically_derived]
722 #[doc(hidden)]
723 impl ::core::convert::From<UnderlyingRustTuple<'_>>
724 for NotValidSignatureFromNode {
725 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
726 Self
727 }
728 }
729 #[automatically_derived]
730 impl alloy_sol_types::SolError for NotValidSignatureFromNode {
731 type Parameters<'a> = UnderlyingSolTuple<'a>;
732 type Token<'a> = <Self::Parameters<
733 'a,
734 > as alloy_sol_types::SolType>::Token<'a>;
735 const SIGNATURE: &'static str = "NotValidSignatureFromNode()";
736 const SELECTOR: [u8; 4] = [180u8, 201u8, 31u8, 251u8];
737 #[inline]
738 fn new<'a>(
739 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
740 ) -> Self {
741 tuple.into()
742 }
743 #[inline]
744 fn tokenize(&self) -> Self::Token<'_> {
745 ()
746 }
747 #[inline]
748 fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
749 <Self::Parameters<
750 '_,
751 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
752 .map(Self::new)
753 }
754 }
755 };
756 #[derive(serde::Serialize, serde::Deserialize)]
757 #[derive(Default, Debug, PartialEq, Eq, Hash)]
758 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
763 #[derive(Clone)]
764 pub struct SafeAddressZero;
765 #[allow(
766 non_camel_case_types,
767 non_snake_case,
768 clippy::pub_underscore_fields,
769 clippy::style
770 )]
771 const _: () = {
772 use alloy::sol_types as alloy_sol_types;
773 #[doc(hidden)]
774 type UnderlyingSolTuple<'a> = ();
775 #[doc(hidden)]
776 type UnderlyingRustTuple<'a> = ();
777 #[cfg(test)]
778 #[allow(dead_code, unreachable_patterns)]
779 fn _type_assertion(
780 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
781 ) {
782 match _t {
783 alloy_sol_types::private::AssertTypeEq::<
784 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
785 >(_) => {}
786 }
787 }
788 #[automatically_derived]
789 #[doc(hidden)]
790 impl ::core::convert::From<SafeAddressZero> for UnderlyingRustTuple<'_> {
791 fn from(value: SafeAddressZero) -> Self {
792 ()
793 }
794 }
795 #[automatically_derived]
796 #[doc(hidden)]
797 impl ::core::convert::From<UnderlyingRustTuple<'_>> for SafeAddressZero {
798 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
799 Self
800 }
801 }
802 #[automatically_derived]
803 impl alloy_sol_types::SolError for SafeAddressZero {
804 type Parameters<'a> = UnderlyingSolTuple<'a>;
805 type Token<'a> = <Self::Parameters<
806 'a,
807 > as alloy_sol_types::SolType>::Token<'a>;
808 const SIGNATURE: &'static str = "SafeAddressZero()";
809 const SELECTOR: [u8; 4] = [20u8, 231u8, 146u8, 33u8];
810 #[inline]
811 fn new<'a>(
812 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
813 ) -> Self {
814 tuple.into()
815 }
816 #[inline]
817 fn tokenize(&self) -> Self::Token<'_> {
818 ()
819 }
820 #[inline]
821 fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
822 <Self::Parameters<
823 '_,
824 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
825 .map(Self::new)
826 }
827 }
828 };
829 #[derive(serde::Serialize, serde::Deserialize)]
830 #[derive(Default, Debug, PartialEq, Eq, Hash)]
831 #[allow(
836 non_camel_case_types,
837 non_snake_case,
838 clippy::pub_underscore_fields,
839 clippy::style
840 )]
841 #[derive(Clone)]
842 pub struct DergisteredNodeSafe {
843 #[allow(missing_docs)]
844 pub safeAddress: alloy::sol_types::private::Address,
845 #[allow(missing_docs)]
846 pub nodeAddress: alloy::sol_types::private::Address,
847 }
848 #[allow(
849 non_camel_case_types,
850 non_snake_case,
851 clippy::pub_underscore_fields,
852 clippy::style
853 )]
854 const _: () = {
855 use alloy::sol_types as alloy_sol_types;
856 #[automatically_derived]
857 impl alloy_sol_types::SolEvent for DergisteredNodeSafe {
858 type DataTuple<'a> = ();
859 type DataToken<'a> = <Self::DataTuple<
860 'a,
861 > as alloy_sol_types::SolType>::Token<'a>;
862 type TopicList = (
863 alloy_sol_types::sol_data::FixedBytes<32>,
864 alloy::sol_types::sol_data::Address,
865 alloy::sol_types::sol_data::Address,
866 );
867 const SIGNATURE: &'static str = "DergisteredNodeSafe(address,address)";
868 const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([
869 232u8, 55u8, 243u8, 57u8, 99u8, 146u8, 150u8, 190u8, 201u8, 244u8, 188u8,
870 152u8, 97u8, 84u8, 245u8, 255u8, 118u8, 187u8, 190u8, 252u8, 49u8, 73u8,
871 165u8, 18u8, 146u8, 14u8, 19u8, 17u8, 65u8, 78u8, 61u8, 161u8,
872 ]);
873 const ANONYMOUS: bool = false;
874 #[allow(unused_variables)]
875 #[inline]
876 fn new(
877 topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
878 data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
879 ) -> Self {
880 Self {
881 safeAddress: topics.1,
882 nodeAddress: topics.2,
883 }
884 }
885 #[inline]
886 fn check_signature(
887 topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
888 ) -> alloy_sol_types::Result<()> {
889 if topics.0 != Self::SIGNATURE_HASH {
890 return Err(
891 alloy_sol_types::Error::invalid_event_signature_hash(
892 Self::SIGNATURE,
893 topics.0,
894 Self::SIGNATURE_HASH,
895 ),
896 );
897 }
898 Ok(())
899 }
900 #[inline]
901 fn tokenize_body(&self) -> Self::DataToken<'_> {
902 ()
903 }
904 #[inline]
905 fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
906 (
907 Self::SIGNATURE_HASH.into(),
908 self.safeAddress.clone(),
909 self.nodeAddress.clone(),
910 )
911 }
912 #[inline]
913 fn encode_topics_raw(
914 &self,
915 out: &mut [alloy_sol_types::abi::token::WordToken],
916 ) -> alloy_sol_types::Result<()> {
917 if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
918 return Err(alloy_sol_types::Error::Overrun);
919 }
920 out[0usize] = alloy_sol_types::abi::token::WordToken(
921 Self::SIGNATURE_HASH,
922 );
923 out[1usize] = <alloy::sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
924 &self.safeAddress,
925 );
926 out[2usize] = <alloy::sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
927 &self.nodeAddress,
928 );
929 Ok(())
930 }
931 }
932 #[automatically_derived]
933 impl alloy_sol_types::private::IntoLogData for DergisteredNodeSafe {
934 fn to_log_data(&self) -> alloy_sol_types::private::LogData {
935 From::from(self)
936 }
937 fn into_log_data(self) -> alloy_sol_types::private::LogData {
938 From::from(&self)
939 }
940 }
941 #[automatically_derived]
942 impl From<&DergisteredNodeSafe> for alloy_sol_types::private::LogData {
943 #[inline]
944 fn from(this: &DergisteredNodeSafe) -> alloy_sol_types::private::LogData {
945 alloy_sol_types::SolEvent::encode_log_data(this)
946 }
947 }
948 };
949 #[derive(serde::Serialize, serde::Deserialize)]
950 #[derive(Default, Debug, PartialEq, Eq, Hash)]
951 #[allow(
956 non_camel_case_types,
957 non_snake_case,
958 clippy::pub_underscore_fields,
959 clippy::style
960 )]
961 #[derive(Clone)]
962 pub struct DomainSeparatorUpdated {
963 #[allow(missing_docs)]
964 pub domainSeparator: alloy::sol_types::private::FixedBytes<32>,
965 }
966 #[allow(
967 non_camel_case_types,
968 non_snake_case,
969 clippy::pub_underscore_fields,
970 clippy::style
971 )]
972 const _: () = {
973 use alloy::sol_types as alloy_sol_types;
974 #[automatically_derived]
975 impl alloy_sol_types::SolEvent for DomainSeparatorUpdated {
976 type DataTuple<'a> = ();
977 type DataToken<'a> = <Self::DataTuple<
978 'a,
979 > as alloy_sol_types::SolType>::Token<'a>;
980 type TopicList = (
981 alloy_sol_types::sol_data::FixedBytes<32>,
982 alloy::sol_types::sol_data::FixedBytes<32>,
983 );
984 const SIGNATURE: &'static str = "DomainSeparatorUpdated(bytes32)";
985 const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([
986 119u8, 31u8, 82u8, 64u8, 174u8, 95u8, 216u8, 167u8, 100u8, 13u8, 63u8,
987 184u8, 47u8, 167u8, 10u8, 171u8, 47u8, 177u8, 219u8, 243u8, 95u8, 46u8,
988 244u8, 100u8, 248u8, 80u8, 153u8, 70u8, 113u8, 118u8, 100u8, 197u8,
989 ]);
990 const ANONYMOUS: bool = false;
991 #[allow(unused_variables)]
992 #[inline]
993 fn new(
994 topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
995 data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
996 ) -> Self {
997 Self { domainSeparator: topics.1 }
998 }
999 #[inline]
1000 fn check_signature(
1001 topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
1002 ) -> alloy_sol_types::Result<()> {
1003 if topics.0 != Self::SIGNATURE_HASH {
1004 return Err(
1005 alloy_sol_types::Error::invalid_event_signature_hash(
1006 Self::SIGNATURE,
1007 topics.0,
1008 Self::SIGNATURE_HASH,
1009 ),
1010 );
1011 }
1012 Ok(())
1013 }
1014 #[inline]
1015 fn tokenize_body(&self) -> Self::DataToken<'_> {
1016 ()
1017 }
1018 #[inline]
1019 fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
1020 (Self::SIGNATURE_HASH.into(), self.domainSeparator.clone())
1021 }
1022 #[inline]
1023 fn encode_topics_raw(
1024 &self,
1025 out: &mut [alloy_sol_types::abi::token::WordToken],
1026 ) -> alloy_sol_types::Result<()> {
1027 if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
1028 return Err(alloy_sol_types::Error::Overrun);
1029 }
1030 out[0usize] = alloy_sol_types::abi::token::WordToken(
1031 Self::SIGNATURE_HASH,
1032 );
1033 out[1usize] = <alloy::sol_types::sol_data::FixedBytes<
1034 32,
1035 > as alloy_sol_types::EventTopic>::encode_topic(&self.domainSeparator);
1036 Ok(())
1037 }
1038 }
1039 #[automatically_derived]
1040 impl alloy_sol_types::private::IntoLogData for DomainSeparatorUpdated {
1041 fn to_log_data(&self) -> alloy_sol_types::private::LogData {
1042 From::from(self)
1043 }
1044 fn into_log_data(self) -> alloy_sol_types::private::LogData {
1045 From::from(&self)
1046 }
1047 }
1048 #[automatically_derived]
1049 impl From<&DomainSeparatorUpdated> for alloy_sol_types::private::LogData {
1050 #[inline]
1051 fn from(this: &DomainSeparatorUpdated) -> alloy_sol_types::private::LogData {
1052 alloy_sol_types::SolEvent::encode_log_data(this)
1053 }
1054 }
1055 };
1056 #[derive(serde::Serialize, serde::Deserialize)]
1057 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1058 #[allow(
1063 non_camel_case_types,
1064 non_snake_case,
1065 clippy::pub_underscore_fields,
1066 clippy::style
1067 )]
1068 #[derive(Clone)]
1069 pub struct RegisteredNodeSafe {
1070 #[allow(missing_docs)]
1071 pub safeAddress: alloy::sol_types::private::Address,
1072 #[allow(missing_docs)]
1073 pub nodeAddress: alloy::sol_types::private::Address,
1074 }
1075 #[allow(
1076 non_camel_case_types,
1077 non_snake_case,
1078 clippy::pub_underscore_fields,
1079 clippy::style
1080 )]
1081 const _: () = {
1082 use alloy::sol_types as alloy_sol_types;
1083 #[automatically_derived]
1084 impl alloy_sol_types::SolEvent for RegisteredNodeSafe {
1085 type DataTuple<'a> = ();
1086 type DataToken<'a> = <Self::DataTuple<
1087 'a,
1088 > as alloy_sol_types::SolType>::Token<'a>;
1089 type TopicList = (
1090 alloy_sol_types::sol_data::FixedBytes<32>,
1091 alloy::sol_types::sol_data::Address,
1092 alloy::sol_types::sol_data::Address,
1093 );
1094 const SIGNATURE: &'static str = "RegisteredNodeSafe(address,address)";
1095 const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([
1096 119u8, 109u8, 164u8, 12u8, 191u8, 44u8, 34u8, 53u8, 82u8, 102u8, 27u8,
1097 212u8, 133u8, 2u8, 206u8, 183u8, 36u8, 9u8, 179u8, 54u8, 43u8, 176u8,
1098 198u8, 109u8, 137u8, 137u8, 189u8, 126u8, 32u8, 228u8, 73u8, 125u8,
1099 ]);
1100 const ANONYMOUS: bool = false;
1101 #[allow(unused_variables)]
1102 #[inline]
1103 fn new(
1104 topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
1105 data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
1106 ) -> Self {
1107 Self {
1108 safeAddress: topics.1,
1109 nodeAddress: topics.2,
1110 }
1111 }
1112 #[inline]
1113 fn check_signature(
1114 topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
1115 ) -> alloy_sol_types::Result<()> {
1116 if topics.0 != Self::SIGNATURE_HASH {
1117 return Err(
1118 alloy_sol_types::Error::invalid_event_signature_hash(
1119 Self::SIGNATURE,
1120 topics.0,
1121 Self::SIGNATURE_HASH,
1122 ),
1123 );
1124 }
1125 Ok(())
1126 }
1127 #[inline]
1128 fn tokenize_body(&self) -> Self::DataToken<'_> {
1129 ()
1130 }
1131 #[inline]
1132 fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
1133 (
1134 Self::SIGNATURE_HASH.into(),
1135 self.safeAddress.clone(),
1136 self.nodeAddress.clone(),
1137 )
1138 }
1139 #[inline]
1140 fn encode_topics_raw(
1141 &self,
1142 out: &mut [alloy_sol_types::abi::token::WordToken],
1143 ) -> alloy_sol_types::Result<()> {
1144 if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
1145 return Err(alloy_sol_types::Error::Overrun);
1146 }
1147 out[0usize] = alloy_sol_types::abi::token::WordToken(
1148 Self::SIGNATURE_HASH,
1149 );
1150 out[1usize] = <alloy::sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
1151 &self.safeAddress,
1152 );
1153 out[2usize] = <alloy::sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
1154 &self.nodeAddress,
1155 );
1156 Ok(())
1157 }
1158 }
1159 #[automatically_derived]
1160 impl alloy_sol_types::private::IntoLogData for RegisteredNodeSafe {
1161 fn to_log_data(&self) -> alloy_sol_types::private::LogData {
1162 From::from(self)
1163 }
1164 fn into_log_data(self) -> alloy_sol_types::private::LogData {
1165 From::from(&self)
1166 }
1167 }
1168 #[automatically_derived]
1169 impl From<&RegisteredNodeSafe> for alloy_sol_types::private::LogData {
1170 #[inline]
1171 fn from(this: &RegisteredNodeSafe) -> alloy_sol_types::private::LogData {
1172 alloy_sol_types::SolEvent::encode_log_data(this)
1173 }
1174 }
1175 };
1176 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1181 #[derive(Clone)]
1182 pub struct constructorCall {}
1183 const _: () = {
1184 use alloy::sol_types as alloy_sol_types;
1185 {
1186 #[doc(hidden)]
1187 type UnderlyingSolTuple<'a> = ();
1188 #[doc(hidden)]
1189 type UnderlyingRustTuple<'a> = ();
1190 #[cfg(test)]
1191 #[allow(dead_code, unreachable_patterns)]
1192 fn _type_assertion(
1193 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1194 ) {
1195 match _t {
1196 alloy_sol_types::private::AssertTypeEq::<
1197 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1198 >(_) => {}
1199 }
1200 }
1201 #[automatically_derived]
1202 #[doc(hidden)]
1203 impl ::core::convert::From<constructorCall> for UnderlyingRustTuple<'_> {
1204 fn from(value: constructorCall) -> Self {
1205 ()
1206 }
1207 }
1208 #[automatically_derived]
1209 #[doc(hidden)]
1210 impl ::core::convert::From<UnderlyingRustTuple<'_>> for constructorCall {
1211 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1212 Self {}
1213 }
1214 }
1215 }
1216 #[automatically_derived]
1217 impl alloy_sol_types::SolConstructor for constructorCall {
1218 type Parameters<'a> = ();
1219 type Token<'a> = <Self::Parameters<
1220 'a,
1221 > as alloy_sol_types::SolType>::Token<'a>;
1222 #[inline]
1223 fn new<'a>(
1224 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
1225 ) -> Self {
1226 tuple.into()
1227 }
1228 #[inline]
1229 fn tokenize(&self) -> Self::Token<'_> {
1230 ()
1231 }
1232 }
1233 };
1234 #[derive(serde::Serialize, serde::Deserialize)]
1235 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1236 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1241 #[derive(Clone)]
1242 pub struct NODE_SAFE_TYPEHASHCall;
1243 #[derive(serde::Serialize, serde::Deserialize)]
1244 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1245 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1247 #[derive(Clone)]
1248 pub struct NODE_SAFE_TYPEHASHReturn {
1249 #[allow(missing_docs)]
1250 pub _0: alloy::sol_types::private::FixedBytes<32>,
1251 }
1252 #[allow(
1253 non_camel_case_types,
1254 non_snake_case,
1255 clippy::pub_underscore_fields,
1256 clippy::style
1257 )]
1258 const _: () = {
1259 use alloy::sol_types as alloy_sol_types;
1260 {
1261 #[doc(hidden)]
1262 type UnderlyingSolTuple<'a> = ();
1263 #[doc(hidden)]
1264 type UnderlyingRustTuple<'a> = ();
1265 #[cfg(test)]
1266 #[allow(dead_code, unreachable_patterns)]
1267 fn _type_assertion(
1268 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1269 ) {
1270 match _t {
1271 alloy_sol_types::private::AssertTypeEq::<
1272 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1273 >(_) => {}
1274 }
1275 }
1276 #[automatically_derived]
1277 #[doc(hidden)]
1278 impl ::core::convert::From<NODE_SAFE_TYPEHASHCall>
1279 for UnderlyingRustTuple<'_> {
1280 fn from(value: NODE_SAFE_TYPEHASHCall) -> Self {
1281 ()
1282 }
1283 }
1284 #[automatically_derived]
1285 #[doc(hidden)]
1286 impl ::core::convert::From<UnderlyingRustTuple<'_>>
1287 for NODE_SAFE_TYPEHASHCall {
1288 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1289 Self
1290 }
1291 }
1292 }
1293 {
1294 #[doc(hidden)]
1295 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,);
1296 #[doc(hidden)]
1297 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::FixedBytes<32>,);
1298 #[cfg(test)]
1299 #[allow(dead_code, unreachable_patterns)]
1300 fn _type_assertion(
1301 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1302 ) {
1303 match _t {
1304 alloy_sol_types::private::AssertTypeEq::<
1305 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1306 >(_) => {}
1307 }
1308 }
1309 #[automatically_derived]
1310 #[doc(hidden)]
1311 impl ::core::convert::From<NODE_SAFE_TYPEHASHReturn>
1312 for UnderlyingRustTuple<'_> {
1313 fn from(value: NODE_SAFE_TYPEHASHReturn) -> Self {
1314 (value._0,)
1315 }
1316 }
1317 #[automatically_derived]
1318 #[doc(hidden)]
1319 impl ::core::convert::From<UnderlyingRustTuple<'_>>
1320 for NODE_SAFE_TYPEHASHReturn {
1321 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1322 Self { _0: tuple.0 }
1323 }
1324 }
1325 }
1326 #[automatically_derived]
1327 impl alloy_sol_types::SolCall for NODE_SAFE_TYPEHASHCall {
1328 type Parameters<'a> = ();
1329 type Token<'a> = <Self::Parameters<
1330 'a,
1331 > as alloy_sol_types::SolType>::Token<'a>;
1332 type Return = alloy::sol_types::private::FixedBytes<32>;
1333 type ReturnTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,);
1334 type ReturnToken<'a> = <Self::ReturnTuple<
1335 'a,
1336 > as alloy_sol_types::SolType>::Token<'a>;
1337 const SIGNATURE: &'static str = "NODE_SAFE_TYPEHASH()";
1338 const SELECTOR: [u8; 4] = [132u8, 176u8, 222u8, 194u8];
1339 #[inline]
1340 fn new<'a>(
1341 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
1342 ) -> Self {
1343 tuple.into()
1344 }
1345 #[inline]
1346 fn tokenize(&self) -> Self::Token<'_> {
1347 ()
1348 }
1349 #[inline]
1350 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
1351 (
1352 <alloy::sol_types::sol_data::FixedBytes<
1353 32,
1354 > as alloy_sol_types::SolType>::tokenize(ret),
1355 )
1356 }
1357 #[inline]
1358 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
1359 <Self::ReturnTuple<
1360 '_,
1361 > as alloy_sol_types::SolType>::abi_decode_sequence(data)
1362 .map(|r| {
1363 let r: NODE_SAFE_TYPEHASHReturn = r.into();
1364 r._0
1365 })
1366 }
1367 #[inline]
1368 fn abi_decode_returns_validate(
1369 data: &[u8],
1370 ) -> alloy_sol_types::Result<Self::Return> {
1371 <Self::ReturnTuple<
1372 '_,
1373 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
1374 .map(|r| {
1375 let r: NODE_SAFE_TYPEHASHReturn = r.into();
1376 r._0
1377 })
1378 }
1379 }
1380 };
1381 #[derive(serde::Serialize, serde::Deserialize)]
1382 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1383 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1388 #[derive(Clone)]
1389 pub struct VERSIONCall;
1390 #[derive(serde::Serialize, serde::Deserialize)]
1391 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1392 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1394 #[derive(Clone)]
1395 pub struct VERSIONReturn {
1396 #[allow(missing_docs)]
1397 pub _0: alloy::sol_types::private::String,
1398 }
1399 #[allow(
1400 non_camel_case_types,
1401 non_snake_case,
1402 clippy::pub_underscore_fields,
1403 clippy::style
1404 )]
1405 const _: () = {
1406 use alloy::sol_types as alloy_sol_types;
1407 {
1408 #[doc(hidden)]
1409 type UnderlyingSolTuple<'a> = ();
1410 #[doc(hidden)]
1411 type UnderlyingRustTuple<'a> = ();
1412 #[cfg(test)]
1413 #[allow(dead_code, unreachable_patterns)]
1414 fn _type_assertion(
1415 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1416 ) {
1417 match _t {
1418 alloy_sol_types::private::AssertTypeEq::<
1419 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1420 >(_) => {}
1421 }
1422 }
1423 #[automatically_derived]
1424 #[doc(hidden)]
1425 impl ::core::convert::From<VERSIONCall> for UnderlyingRustTuple<'_> {
1426 fn from(value: VERSIONCall) -> Self {
1427 ()
1428 }
1429 }
1430 #[automatically_derived]
1431 #[doc(hidden)]
1432 impl ::core::convert::From<UnderlyingRustTuple<'_>> for VERSIONCall {
1433 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1434 Self
1435 }
1436 }
1437 }
1438 {
1439 #[doc(hidden)]
1440 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::String,);
1441 #[doc(hidden)]
1442 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::String,);
1443 #[cfg(test)]
1444 #[allow(dead_code, unreachable_patterns)]
1445 fn _type_assertion(
1446 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1447 ) {
1448 match _t {
1449 alloy_sol_types::private::AssertTypeEq::<
1450 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1451 >(_) => {}
1452 }
1453 }
1454 #[automatically_derived]
1455 #[doc(hidden)]
1456 impl ::core::convert::From<VERSIONReturn> for UnderlyingRustTuple<'_> {
1457 fn from(value: VERSIONReturn) -> Self {
1458 (value._0,)
1459 }
1460 }
1461 #[automatically_derived]
1462 #[doc(hidden)]
1463 impl ::core::convert::From<UnderlyingRustTuple<'_>> for VERSIONReturn {
1464 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1465 Self { _0: tuple.0 }
1466 }
1467 }
1468 }
1469 #[automatically_derived]
1470 impl alloy_sol_types::SolCall for VERSIONCall {
1471 type Parameters<'a> = ();
1472 type Token<'a> = <Self::Parameters<
1473 'a,
1474 > as alloy_sol_types::SolType>::Token<'a>;
1475 type Return = alloy::sol_types::private::String;
1476 type ReturnTuple<'a> = (alloy::sol_types::sol_data::String,);
1477 type ReturnToken<'a> = <Self::ReturnTuple<
1478 'a,
1479 > as alloy_sol_types::SolType>::Token<'a>;
1480 const SIGNATURE: &'static str = "VERSION()";
1481 const SELECTOR: [u8; 4] = [255u8, 161u8, 173u8, 116u8];
1482 #[inline]
1483 fn new<'a>(
1484 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
1485 ) -> Self {
1486 tuple.into()
1487 }
1488 #[inline]
1489 fn tokenize(&self) -> Self::Token<'_> {
1490 ()
1491 }
1492 #[inline]
1493 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
1494 (
1495 <alloy::sol_types::sol_data::String as alloy_sol_types::SolType>::tokenize(
1496 ret,
1497 ),
1498 )
1499 }
1500 #[inline]
1501 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
1502 <Self::ReturnTuple<
1503 '_,
1504 > as alloy_sol_types::SolType>::abi_decode_sequence(data)
1505 .map(|r| {
1506 let r: VERSIONReturn = r.into();
1507 r._0
1508 })
1509 }
1510 #[inline]
1511 fn abi_decode_returns_validate(
1512 data: &[u8],
1513 ) -> alloy_sol_types::Result<Self::Return> {
1514 <Self::ReturnTuple<
1515 '_,
1516 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
1517 .map(|r| {
1518 let r: VERSIONReturn = r.into();
1519 r._0
1520 })
1521 }
1522 }
1523 };
1524 #[derive(serde::Serialize, serde::Deserialize)]
1525 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1526 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1531 #[derive(Clone)]
1532 pub struct deregisterNodeBySafeCall {
1533 #[allow(missing_docs)]
1534 pub nodeAddr: alloy::sol_types::private::Address,
1535 }
1536 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1538 #[derive(Clone)]
1539 pub struct deregisterNodeBySafeReturn {}
1540 #[allow(
1541 non_camel_case_types,
1542 non_snake_case,
1543 clippy::pub_underscore_fields,
1544 clippy::style
1545 )]
1546 const _: () = {
1547 use alloy::sol_types as alloy_sol_types;
1548 {
1549 #[doc(hidden)]
1550 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
1551 #[doc(hidden)]
1552 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
1553 #[cfg(test)]
1554 #[allow(dead_code, unreachable_patterns)]
1555 fn _type_assertion(
1556 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1557 ) {
1558 match _t {
1559 alloy_sol_types::private::AssertTypeEq::<
1560 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1561 >(_) => {}
1562 }
1563 }
1564 #[automatically_derived]
1565 #[doc(hidden)]
1566 impl ::core::convert::From<deregisterNodeBySafeCall>
1567 for UnderlyingRustTuple<'_> {
1568 fn from(value: deregisterNodeBySafeCall) -> Self {
1569 (value.nodeAddr,)
1570 }
1571 }
1572 #[automatically_derived]
1573 #[doc(hidden)]
1574 impl ::core::convert::From<UnderlyingRustTuple<'_>>
1575 for deregisterNodeBySafeCall {
1576 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1577 Self { nodeAddr: tuple.0 }
1578 }
1579 }
1580 }
1581 {
1582 #[doc(hidden)]
1583 type UnderlyingSolTuple<'a> = ();
1584 #[doc(hidden)]
1585 type UnderlyingRustTuple<'a> = ();
1586 #[cfg(test)]
1587 #[allow(dead_code, unreachable_patterns)]
1588 fn _type_assertion(
1589 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1590 ) {
1591 match _t {
1592 alloy_sol_types::private::AssertTypeEq::<
1593 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1594 >(_) => {}
1595 }
1596 }
1597 #[automatically_derived]
1598 #[doc(hidden)]
1599 impl ::core::convert::From<deregisterNodeBySafeReturn>
1600 for UnderlyingRustTuple<'_> {
1601 fn from(value: deregisterNodeBySafeReturn) -> Self {
1602 ()
1603 }
1604 }
1605 #[automatically_derived]
1606 #[doc(hidden)]
1607 impl ::core::convert::From<UnderlyingRustTuple<'_>>
1608 for deregisterNodeBySafeReturn {
1609 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1610 Self {}
1611 }
1612 }
1613 }
1614 impl deregisterNodeBySafeReturn {
1615 fn _tokenize(
1616 &self,
1617 ) -> <deregisterNodeBySafeCall as alloy_sol_types::SolCall>::ReturnToken<
1618 '_,
1619 > {
1620 ()
1621 }
1622 }
1623 #[automatically_derived]
1624 impl alloy_sol_types::SolCall for deregisterNodeBySafeCall {
1625 type Parameters<'a> = (alloy::sol_types::sol_data::Address,);
1626 type Token<'a> = <Self::Parameters<
1627 'a,
1628 > as alloy_sol_types::SolType>::Token<'a>;
1629 type Return = deregisterNodeBySafeReturn;
1630 type ReturnTuple<'a> = ();
1631 type ReturnToken<'a> = <Self::ReturnTuple<
1632 'a,
1633 > as alloy_sol_types::SolType>::Token<'a>;
1634 const SIGNATURE: &'static str = "deregisterNodeBySafe(address)";
1635 const SELECTOR: [u8; 4] = [145u8, 96u8, 124u8, 76u8];
1636 #[inline]
1637 fn new<'a>(
1638 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
1639 ) -> Self {
1640 tuple.into()
1641 }
1642 #[inline]
1643 fn tokenize(&self) -> Self::Token<'_> {
1644 (
1645 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
1646 &self.nodeAddr,
1647 ),
1648 )
1649 }
1650 #[inline]
1651 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
1652 deregisterNodeBySafeReturn::_tokenize(ret)
1653 }
1654 #[inline]
1655 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
1656 <Self::ReturnTuple<
1657 '_,
1658 > as alloy_sol_types::SolType>::abi_decode_sequence(data)
1659 .map(Into::into)
1660 }
1661 #[inline]
1662 fn abi_decode_returns_validate(
1663 data: &[u8],
1664 ) -> alloy_sol_types::Result<Self::Return> {
1665 <Self::ReturnTuple<
1666 '_,
1667 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
1668 .map(Into::into)
1669 }
1670 }
1671 };
1672 #[derive(serde::Serialize, serde::Deserialize)]
1673 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1674 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1679 #[derive(Clone)]
1680 pub struct domainSeparatorCall;
1681 #[derive(serde::Serialize, serde::Deserialize)]
1682 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1683 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1685 #[derive(Clone)]
1686 pub struct domainSeparatorReturn {
1687 #[allow(missing_docs)]
1688 pub _0: alloy::sol_types::private::FixedBytes<32>,
1689 }
1690 #[allow(
1691 non_camel_case_types,
1692 non_snake_case,
1693 clippy::pub_underscore_fields,
1694 clippy::style
1695 )]
1696 const _: () = {
1697 use alloy::sol_types as alloy_sol_types;
1698 {
1699 #[doc(hidden)]
1700 type UnderlyingSolTuple<'a> = ();
1701 #[doc(hidden)]
1702 type UnderlyingRustTuple<'a> = ();
1703 #[cfg(test)]
1704 #[allow(dead_code, unreachable_patterns)]
1705 fn _type_assertion(
1706 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1707 ) {
1708 match _t {
1709 alloy_sol_types::private::AssertTypeEq::<
1710 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1711 >(_) => {}
1712 }
1713 }
1714 #[automatically_derived]
1715 #[doc(hidden)]
1716 impl ::core::convert::From<domainSeparatorCall> for UnderlyingRustTuple<'_> {
1717 fn from(value: domainSeparatorCall) -> Self {
1718 ()
1719 }
1720 }
1721 #[automatically_derived]
1722 #[doc(hidden)]
1723 impl ::core::convert::From<UnderlyingRustTuple<'_>> for domainSeparatorCall {
1724 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1725 Self
1726 }
1727 }
1728 }
1729 {
1730 #[doc(hidden)]
1731 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,);
1732 #[doc(hidden)]
1733 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::FixedBytes<32>,);
1734 #[cfg(test)]
1735 #[allow(dead_code, unreachable_patterns)]
1736 fn _type_assertion(
1737 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1738 ) {
1739 match _t {
1740 alloy_sol_types::private::AssertTypeEq::<
1741 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1742 >(_) => {}
1743 }
1744 }
1745 #[automatically_derived]
1746 #[doc(hidden)]
1747 impl ::core::convert::From<domainSeparatorReturn>
1748 for UnderlyingRustTuple<'_> {
1749 fn from(value: domainSeparatorReturn) -> Self {
1750 (value._0,)
1751 }
1752 }
1753 #[automatically_derived]
1754 #[doc(hidden)]
1755 impl ::core::convert::From<UnderlyingRustTuple<'_>>
1756 for domainSeparatorReturn {
1757 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1758 Self { _0: tuple.0 }
1759 }
1760 }
1761 }
1762 #[automatically_derived]
1763 impl alloy_sol_types::SolCall for domainSeparatorCall {
1764 type Parameters<'a> = ();
1765 type Token<'a> = <Self::Parameters<
1766 'a,
1767 > as alloy_sol_types::SolType>::Token<'a>;
1768 type Return = alloy::sol_types::private::FixedBytes<32>;
1769 type ReturnTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,);
1770 type ReturnToken<'a> = <Self::ReturnTuple<
1771 'a,
1772 > as alloy_sol_types::SolType>::Token<'a>;
1773 const SIGNATURE: &'static str = "domainSeparator()";
1774 const SELECTOR: [u8; 4] = [246u8, 152u8, 218u8, 37u8];
1775 #[inline]
1776 fn new<'a>(
1777 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
1778 ) -> Self {
1779 tuple.into()
1780 }
1781 #[inline]
1782 fn tokenize(&self) -> Self::Token<'_> {
1783 ()
1784 }
1785 #[inline]
1786 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
1787 (
1788 <alloy::sol_types::sol_data::FixedBytes<
1789 32,
1790 > as alloy_sol_types::SolType>::tokenize(ret),
1791 )
1792 }
1793 #[inline]
1794 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
1795 <Self::ReturnTuple<
1796 '_,
1797 > as alloy_sol_types::SolType>::abi_decode_sequence(data)
1798 .map(|r| {
1799 let r: domainSeparatorReturn = r.into();
1800 r._0
1801 })
1802 }
1803 #[inline]
1804 fn abi_decode_returns_validate(
1805 data: &[u8],
1806 ) -> alloy_sol_types::Result<Self::Return> {
1807 <Self::ReturnTuple<
1808 '_,
1809 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
1810 .map(|r| {
1811 let r: domainSeparatorReturn = r.into();
1812 r._0
1813 })
1814 }
1815 }
1816 };
1817 #[derive(serde::Serialize, serde::Deserialize)]
1818 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1819 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1824 #[derive(Clone)]
1825 pub struct isNodeSafeRegisteredCall {
1826 #[allow(missing_docs)]
1827 pub safeAddress: alloy::sol_types::private::Address,
1828 #[allow(missing_docs)]
1829 pub nodeChainKeyAddress: alloy::sol_types::private::Address,
1830 }
1831 #[derive(serde::Serialize, serde::Deserialize)]
1832 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1833 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1835 #[derive(Clone)]
1836 pub struct isNodeSafeRegisteredReturn {
1837 #[allow(missing_docs)]
1838 pub _0: bool,
1839 }
1840 #[allow(
1841 non_camel_case_types,
1842 non_snake_case,
1843 clippy::pub_underscore_fields,
1844 clippy::style
1845 )]
1846 const _: () = {
1847 use alloy::sol_types as alloy_sol_types;
1848 {
1849 #[doc(hidden)]
1850 type UnderlyingSolTuple<'a> = (
1851 alloy::sol_types::sol_data::Address,
1852 alloy::sol_types::sol_data::Address,
1853 );
1854 #[doc(hidden)]
1855 type UnderlyingRustTuple<'a> = (
1856 alloy::sol_types::private::Address,
1857 alloy::sol_types::private::Address,
1858 );
1859 #[cfg(test)]
1860 #[allow(dead_code, unreachable_patterns)]
1861 fn _type_assertion(
1862 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1863 ) {
1864 match _t {
1865 alloy_sol_types::private::AssertTypeEq::<
1866 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1867 >(_) => {}
1868 }
1869 }
1870 #[automatically_derived]
1871 #[doc(hidden)]
1872 impl ::core::convert::From<isNodeSafeRegisteredCall>
1873 for UnderlyingRustTuple<'_> {
1874 fn from(value: isNodeSafeRegisteredCall) -> Self {
1875 (value.safeAddress, value.nodeChainKeyAddress)
1876 }
1877 }
1878 #[automatically_derived]
1879 #[doc(hidden)]
1880 impl ::core::convert::From<UnderlyingRustTuple<'_>>
1881 for isNodeSafeRegisteredCall {
1882 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1883 Self {
1884 safeAddress: tuple.0,
1885 nodeChainKeyAddress: tuple.1,
1886 }
1887 }
1888 }
1889 }
1890 {
1891 #[doc(hidden)]
1892 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Bool,);
1893 #[doc(hidden)]
1894 type UnderlyingRustTuple<'a> = (bool,);
1895 #[cfg(test)]
1896 #[allow(dead_code, unreachable_patterns)]
1897 fn _type_assertion(
1898 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1899 ) {
1900 match _t {
1901 alloy_sol_types::private::AssertTypeEq::<
1902 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1903 >(_) => {}
1904 }
1905 }
1906 #[automatically_derived]
1907 #[doc(hidden)]
1908 impl ::core::convert::From<isNodeSafeRegisteredReturn>
1909 for UnderlyingRustTuple<'_> {
1910 fn from(value: isNodeSafeRegisteredReturn) -> Self {
1911 (value._0,)
1912 }
1913 }
1914 #[automatically_derived]
1915 #[doc(hidden)]
1916 impl ::core::convert::From<UnderlyingRustTuple<'_>>
1917 for isNodeSafeRegisteredReturn {
1918 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1919 Self { _0: tuple.0 }
1920 }
1921 }
1922 }
1923 #[automatically_derived]
1924 impl alloy_sol_types::SolCall for isNodeSafeRegisteredCall {
1925 type Parameters<'a> = (
1926 alloy::sol_types::sol_data::Address,
1927 alloy::sol_types::sol_data::Address,
1928 );
1929 type Token<'a> = <Self::Parameters<
1930 'a,
1931 > as alloy_sol_types::SolType>::Token<'a>;
1932 type Return = bool;
1933 type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,);
1934 type ReturnToken<'a> = <Self::ReturnTuple<
1935 'a,
1936 > as alloy_sol_types::SolType>::Token<'a>;
1937 const SIGNATURE: &'static str = "isNodeSafeRegistered(address,address)";
1938 const SELECTOR: [u8; 4] = [55u8, 72u8, 10u8, 189u8];
1939 #[inline]
1940 fn new<'a>(
1941 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
1942 ) -> Self {
1943 tuple.into()
1944 }
1945 #[inline]
1946 fn tokenize(&self) -> Self::Token<'_> {
1947 (
1948 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
1949 &self.safeAddress,
1950 ),
1951 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
1952 &self.nodeChainKeyAddress,
1953 ),
1954 )
1955 }
1956 #[inline]
1957 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
1958 (
1959 <alloy::sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(
1960 ret,
1961 ),
1962 )
1963 }
1964 #[inline]
1965 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
1966 <Self::ReturnTuple<
1967 '_,
1968 > as alloy_sol_types::SolType>::abi_decode_sequence(data)
1969 .map(|r| {
1970 let r: isNodeSafeRegisteredReturn = r.into();
1971 r._0
1972 })
1973 }
1974 #[inline]
1975 fn abi_decode_returns_validate(
1976 data: &[u8],
1977 ) -> alloy_sol_types::Result<Self::Return> {
1978 <Self::ReturnTuple<
1979 '_,
1980 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
1981 .map(|r| {
1982 let r: isNodeSafeRegisteredReturn = r.into();
1983 r._0
1984 })
1985 }
1986 }
1987 };
1988 #[derive(serde::Serialize, serde::Deserialize)]
1989 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1990 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1995 #[derive(Clone)]
1996 pub struct nodeSigNonceCall {
1997 #[allow(missing_docs)]
1998 pub nodeAddress: alloy::sol_types::private::Address,
1999 }
2000 #[derive(serde::Serialize, serde::Deserialize)]
2001 #[derive(Default, Debug, PartialEq, Eq, Hash)]
2002 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2004 #[derive(Clone)]
2005 pub struct nodeSigNonceReturn {
2006 #[allow(missing_docs)]
2007 pub _0: alloy::sol_types::private::primitives::aliases::U256,
2008 }
2009 #[allow(
2010 non_camel_case_types,
2011 non_snake_case,
2012 clippy::pub_underscore_fields,
2013 clippy::style
2014 )]
2015 const _: () = {
2016 use alloy::sol_types as alloy_sol_types;
2017 {
2018 #[doc(hidden)]
2019 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
2020 #[doc(hidden)]
2021 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
2022 #[cfg(test)]
2023 #[allow(dead_code, unreachable_patterns)]
2024 fn _type_assertion(
2025 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
2026 ) {
2027 match _t {
2028 alloy_sol_types::private::AssertTypeEq::<
2029 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2030 >(_) => {}
2031 }
2032 }
2033 #[automatically_derived]
2034 #[doc(hidden)]
2035 impl ::core::convert::From<nodeSigNonceCall> for UnderlyingRustTuple<'_> {
2036 fn from(value: nodeSigNonceCall) -> Self {
2037 (value.nodeAddress,)
2038 }
2039 }
2040 #[automatically_derived]
2041 #[doc(hidden)]
2042 impl ::core::convert::From<UnderlyingRustTuple<'_>> for nodeSigNonceCall {
2043 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2044 Self { nodeAddress: tuple.0 }
2045 }
2046 }
2047 }
2048 {
2049 #[doc(hidden)]
2050 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
2051 #[doc(hidden)]
2052 type UnderlyingRustTuple<'a> = (
2053 alloy::sol_types::private::primitives::aliases::U256,
2054 );
2055 #[cfg(test)]
2056 #[allow(dead_code, unreachable_patterns)]
2057 fn _type_assertion(
2058 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
2059 ) {
2060 match _t {
2061 alloy_sol_types::private::AssertTypeEq::<
2062 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2063 >(_) => {}
2064 }
2065 }
2066 #[automatically_derived]
2067 #[doc(hidden)]
2068 impl ::core::convert::From<nodeSigNonceReturn> for UnderlyingRustTuple<'_> {
2069 fn from(value: nodeSigNonceReturn) -> Self {
2070 (value._0,)
2071 }
2072 }
2073 #[automatically_derived]
2074 #[doc(hidden)]
2075 impl ::core::convert::From<UnderlyingRustTuple<'_>> for nodeSigNonceReturn {
2076 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2077 Self { _0: tuple.0 }
2078 }
2079 }
2080 }
2081 #[automatically_derived]
2082 impl alloy_sol_types::SolCall for nodeSigNonceCall {
2083 type Parameters<'a> = (alloy::sol_types::sol_data::Address,);
2084 type Token<'a> = <Self::Parameters<
2085 'a,
2086 > as alloy_sol_types::SolType>::Token<'a>;
2087 type Return = alloy::sol_types::private::primitives::aliases::U256;
2088 type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
2089 type ReturnToken<'a> = <Self::ReturnTuple<
2090 'a,
2091 > as alloy_sol_types::SolType>::Token<'a>;
2092 const SIGNATURE: &'static str = "nodeSigNonce(address)";
2093 const SELECTOR: [u8; 4] = [170u8, 144u8, 242u8, 165u8];
2094 #[inline]
2095 fn new<'a>(
2096 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
2097 ) -> Self {
2098 tuple.into()
2099 }
2100 #[inline]
2101 fn tokenize(&self) -> Self::Token<'_> {
2102 (
2103 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
2104 &self.nodeAddress,
2105 ),
2106 )
2107 }
2108 #[inline]
2109 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
2110 (
2111 <alloy::sol_types::sol_data::Uint<
2112 256,
2113 > as alloy_sol_types::SolType>::tokenize(ret),
2114 )
2115 }
2116 #[inline]
2117 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
2118 <Self::ReturnTuple<
2119 '_,
2120 > as alloy_sol_types::SolType>::abi_decode_sequence(data)
2121 .map(|r| {
2122 let r: nodeSigNonceReturn = r.into();
2123 r._0
2124 })
2125 }
2126 #[inline]
2127 fn abi_decode_returns_validate(
2128 data: &[u8],
2129 ) -> alloy_sol_types::Result<Self::Return> {
2130 <Self::ReturnTuple<
2131 '_,
2132 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
2133 .map(|r| {
2134 let r: nodeSigNonceReturn = r.into();
2135 r._0
2136 })
2137 }
2138 }
2139 };
2140 #[derive(serde::Serialize, serde::Deserialize)]
2141 #[derive(Default, Debug, PartialEq, Eq, Hash)]
2142 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2147 #[derive(Clone)]
2148 pub struct nodeToSafeCall {
2149 #[allow(missing_docs)]
2150 pub nodeAddress: alloy::sol_types::private::Address,
2151 }
2152 #[derive(serde::Serialize, serde::Deserialize)]
2153 #[derive(Default, Debug, PartialEq, Eq, Hash)]
2154 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2156 #[derive(Clone)]
2157 pub struct nodeToSafeReturn {
2158 #[allow(missing_docs)]
2159 pub _0: alloy::sol_types::private::Address,
2160 }
2161 #[allow(
2162 non_camel_case_types,
2163 non_snake_case,
2164 clippy::pub_underscore_fields,
2165 clippy::style
2166 )]
2167 const _: () = {
2168 use alloy::sol_types as alloy_sol_types;
2169 {
2170 #[doc(hidden)]
2171 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
2172 #[doc(hidden)]
2173 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
2174 #[cfg(test)]
2175 #[allow(dead_code, unreachable_patterns)]
2176 fn _type_assertion(
2177 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
2178 ) {
2179 match _t {
2180 alloy_sol_types::private::AssertTypeEq::<
2181 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2182 >(_) => {}
2183 }
2184 }
2185 #[automatically_derived]
2186 #[doc(hidden)]
2187 impl ::core::convert::From<nodeToSafeCall> for UnderlyingRustTuple<'_> {
2188 fn from(value: nodeToSafeCall) -> Self {
2189 (value.nodeAddress,)
2190 }
2191 }
2192 #[automatically_derived]
2193 #[doc(hidden)]
2194 impl ::core::convert::From<UnderlyingRustTuple<'_>> for nodeToSafeCall {
2195 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2196 Self { nodeAddress: tuple.0 }
2197 }
2198 }
2199 }
2200 {
2201 #[doc(hidden)]
2202 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
2203 #[doc(hidden)]
2204 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
2205 #[cfg(test)]
2206 #[allow(dead_code, unreachable_patterns)]
2207 fn _type_assertion(
2208 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
2209 ) {
2210 match _t {
2211 alloy_sol_types::private::AssertTypeEq::<
2212 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2213 >(_) => {}
2214 }
2215 }
2216 #[automatically_derived]
2217 #[doc(hidden)]
2218 impl ::core::convert::From<nodeToSafeReturn> for UnderlyingRustTuple<'_> {
2219 fn from(value: nodeToSafeReturn) -> Self {
2220 (value._0,)
2221 }
2222 }
2223 #[automatically_derived]
2224 #[doc(hidden)]
2225 impl ::core::convert::From<UnderlyingRustTuple<'_>> for nodeToSafeReturn {
2226 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2227 Self { _0: tuple.0 }
2228 }
2229 }
2230 }
2231 #[automatically_derived]
2232 impl alloy_sol_types::SolCall for nodeToSafeCall {
2233 type Parameters<'a> = (alloy::sol_types::sol_data::Address,);
2234 type Token<'a> = <Self::Parameters<
2235 'a,
2236 > as alloy_sol_types::SolType>::Token<'a>;
2237 type Return = alloy::sol_types::private::Address;
2238 type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,);
2239 type ReturnToken<'a> = <Self::ReturnTuple<
2240 'a,
2241 > as alloy_sol_types::SolType>::Token<'a>;
2242 const SIGNATURE: &'static str = "nodeToSafe(address)";
2243 const SELECTOR: [u8; 4] = [137u8, 151u8, 140u8, 64u8];
2244 #[inline]
2245 fn new<'a>(
2246 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
2247 ) -> Self {
2248 tuple.into()
2249 }
2250 #[inline]
2251 fn tokenize(&self) -> Self::Token<'_> {
2252 (
2253 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
2254 &self.nodeAddress,
2255 ),
2256 )
2257 }
2258 #[inline]
2259 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
2260 (
2261 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
2262 ret,
2263 ),
2264 )
2265 }
2266 #[inline]
2267 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
2268 <Self::ReturnTuple<
2269 '_,
2270 > as alloy_sol_types::SolType>::abi_decode_sequence(data)
2271 .map(|r| {
2272 let r: nodeToSafeReturn = r.into();
2273 r._0
2274 })
2275 }
2276 #[inline]
2277 fn abi_decode_returns_validate(
2278 data: &[u8],
2279 ) -> alloy_sol_types::Result<Self::Return> {
2280 <Self::ReturnTuple<
2281 '_,
2282 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
2283 .map(|r| {
2284 let r: nodeToSafeReturn = r.into();
2285 r._0
2286 })
2287 }
2288 }
2289 };
2290 #[derive(serde::Serialize, serde::Deserialize)]
2291 #[derive(Default, Debug, PartialEq, Eq, Hash)]
2292 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2297 #[derive(Clone)]
2298 pub struct registerSafeByNodeCall {
2299 #[allow(missing_docs)]
2300 pub safeAddr: alloy::sol_types::private::Address,
2301 }
2302 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2304 #[derive(Clone)]
2305 pub struct registerSafeByNodeReturn {}
2306 #[allow(
2307 non_camel_case_types,
2308 non_snake_case,
2309 clippy::pub_underscore_fields,
2310 clippy::style
2311 )]
2312 const _: () = {
2313 use alloy::sol_types as alloy_sol_types;
2314 {
2315 #[doc(hidden)]
2316 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
2317 #[doc(hidden)]
2318 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
2319 #[cfg(test)]
2320 #[allow(dead_code, unreachable_patterns)]
2321 fn _type_assertion(
2322 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
2323 ) {
2324 match _t {
2325 alloy_sol_types::private::AssertTypeEq::<
2326 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2327 >(_) => {}
2328 }
2329 }
2330 #[automatically_derived]
2331 #[doc(hidden)]
2332 impl ::core::convert::From<registerSafeByNodeCall>
2333 for UnderlyingRustTuple<'_> {
2334 fn from(value: registerSafeByNodeCall) -> Self {
2335 (value.safeAddr,)
2336 }
2337 }
2338 #[automatically_derived]
2339 #[doc(hidden)]
2340 impl ::core::convert::From<UnderlyingRustTuple<'_>>
2341 for registerSafeByNodeCall {
2342 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2343 Self { safeAddr: tuple.0 }
2344 }
2345 }
2346 }
2347 {
2348 #[doc(hidden)]
2349 type UnderlyingSolTuple<'a> = ();
2350 #[doc(hidden)]
2351 type UnderlyingRustTuple<'a> = ();
2352 #[cfg(test)]
2353 #[allow(dead_code, unreachable_patterns)]
2354 fn _type_assertion(
2355 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
2356 ) {
2357 match _t {
2358 alloy_sol_types::private::AssertTypeEq::<
2359 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2360 >(_) => {}
2361 }
2362 }
2363 #[automatically_derived]
2364 #[doc(hidden)]
2365 impl ::core::convert::From<registerSafeByNodeReturn>
2366 for UnderlyingRustTuple<'_> {
2367 fn from(value: registerSafeByNodeReturn) -> Self {
2368 ()
2369 }
2370 }
2371 #[automatically_derived]
2372 #[doc(hidden)]
2373 impl ::core::convert::From<UnderlyingRustTuple<'_>>
2374 for registerSafeByNodeReturn {
2375 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2376 Self {}
2377 }
2378 }
2379 }
2380 impl registerSafeByNodeReturn {
2381 fn _tokenize(
2382 &self,
2383 ) -> <registerSafeByNodeCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
2384 ()
2385 }
2386 }
2387 #[automatically_derived]
2388 impl alloy_sol_types::SolCall for registerSafeByNodeCall {
2389 type Parameters<'a> = (alloy::sol_types::sol_data::Address,);
2390 type Token<'a> = <Self::Parameters<
2391 'a,
2392 > as alloy_sol_types::SolType>::Token<'a>;
2393 type Return = registerSafeByNodeReturn;
2394 type ReturnTuple<'a> = ();
2395 type ReturnToken<'a> = <Self::ReturnTuple<
2396 'a,
2397 > as alloy_sol_types::SolType>::Token<'a>;
2398 const SIGNATURE: &'static str = "registerSafeByNode(address)";
2399 const SELECTOR: [u8; 4] = [127u8, 147u8, 89u8, 49u8];
2400 #[inline]
2401 fn new<'a>(
2402 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
2403 ) -> Self {
2404 tuple.into()
2405 }
2406 #[inline]
2407 fn tokenize(&self) -> Self::Token<'_> {
2408 (
2409 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
2410 &self.safeAddr,
2411 ),
2412 )
2413 }
2414 #[inline]
2415 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
2416 registerSafeByNodeReturn::_tokenize(ret)
2417 }
2418 #[inline]
2419 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
2420 <Self::ReturnTuple<
2421 '_,
2422 > as alloy_sol_types::SolType>::abi_decode_sequence(data)
2423 .map(Into::into)
2424 }
2425 #[inline]
2426 fn abi_decode_returns_validate(
2427 data: &[u8],
2428 ) -> alloy_sol_types::Result<Self::Return> {
2429 <Self::ReturnTuple<
2430 '_,
2431 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
2432 .map(Into::into)
2433 }
2434 }
2435 };
2436 #[derive(serde::Serialize, serde::Deserialize)]
2437 #[derive(Default, Debug, PartialEq, Eq, Hash)]
2438 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2443 #[derive(Clone)]
2444 pub struct registerSafeWithNodeSigCall {
2445 #[allow(missing_docs)]
2446 pub safeAddress: alloy::sol_types::private::Address,
2447 #[allow(missing_docs)]
2448 pub nodeChainKeyAddress: alloy::sol_types::private::Address,
2449 #[allow(missing_docs)]
2450 pub sig: alloy::sol_types::private::Bytes,
2451 }
2452 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2454 #[derive(Clone)]
2455 pub struct registerSafeWithNodeSigReturn {}
2456 #[allow(
2457 non_camel_case_types,
2458 non_snake_case,
2459 clippy::pub_underscore_fields,
2460 clippy::style
2461 )]
2462 const _: () = {
2463 use alloy::sol_types as alloy_sol_types;
2464 {
2465 #[doc(hidden)]
2466 type UnderlyingSolTuple<'a> = (
2467 alloy::sol_types::sol_data::Address,
2468 alloy::sol_types::sol_data::Address,
2469 alloy::sol_types::sol_data::Bytes,
2470 );
2471 #[doc(hidden)]
2472 type UnderlyingRustTuple<'a> = (
2473 alloy::sol_types::private::Address,
2474 alloy::sol_types::private::Address,
2475 alloy::sol_types::private::Bytes,
2476 );
2477 #[cfg(test)]
2478 #[allow(dead_code, unreachable_patterns)]
2479 fn _type_assertion(
2480 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
2481 ) {
2482 match _t {
2483 alloy_sol_types::private::AssertTypeEq::<
2484 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2485 >(_) => {}
2486 }
2487 }
2488 #[automatically_derived]
2489 #[doc(hidden)]
2490 impl ::core::convert::From<registerSafeWithNodeSigCall>
2491 for UnderlyingRustTuple<'_> {
2492 fn from(value: registerSafeWithNodeSigCall) -> Self {
2493 (value.safeAddress, value.nodeChainKeyAddress, value.sig)
2494 }
2495 }
2496 #[automatically_derived]
2497 #[doc(hidden)]
2498 impl ::core::convert::From<UnderlyingRustTuple<'_>>
2499 for registerSafeWithNodeSigCall {
2500 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2501 Self {
2502 safeAddress: tuple.0,
2503 nodeChainKeyAddress: tuple.1,
2504 sig: tuple.2,
2505 }
2506 }
2507 }
2508 }
2509 {
2510 #[doc(hidden)]
2511 type UnderlyingSolTuple<'a> = ();
2512 #[doc(hidden)]
2513 type UnderlyingRustTuple<'a> = ();
2514 #[cfg(test)]
2515 #[allow(dead_code, unreachable_patterns)]
2516 fn _type_assertion(
2517 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
2518 ) {
2519 match _t {
2520 alloy_sol_types::private::AssertTypeEq::<
2521 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2522 >(_) => {}
2523 }
2524 }
2525 #[automatically_derived]
2526 #[doc(hidden)]
2527 impl ::core::convert::From<registerSafeWithNodeSigReturn>
2528 for UnderlyingRustTuple<'_> {
2529 fn from(value: registerSafeWithNodeSigReturn) -> Self {
2530 ()
2531 }
2532 }
2533 #[automatically_derived]
2534 #[doc(hidden)]
2535 impl ::core::convert::From<UnderlyingRustTuple<'_>>
2536 for registerSafeWithNodeSigReturn {
2537 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2538 Self {}
2539 }
2540 }
2541 }
2542 impl registerSafeWithNodeSigReturn {
2543 fn _tokenize(
2544 &self,
2545 ) -> <registerSafeWithNodeSigCall as alloy_sol_types::SolCall>::ReturnToken<
2546 '_,
2547 > {
2548 ()
2549 }
2550 }
2551 #[automatically_derived]
2552 impl alloy_sol_types::SolCall for registerSafeWithNodeSigCall {
2553 type Parameters<'a> = (
2554 alloy::sol_types::sol_data::Address,
2555 alloy::sol_types::sol_data::Address,
2556 alloy::sol_types::sol_data::Bytes,
2557 );
2558 type Token<'a> = <Self::Parameters<
2559 'a,
2560 > as alloy_sol_types::SolType>::Token<'a>;
2561 type Return = registerSafeWithNodeSigReturn;
2562 type ReturnTuple<'a> = ();
2563 type ReturnToken<'a> = <Self::ReturnTuple<
2564 'a,
2565 > as alloy_sol_types::SolType>::Token<'a>;
2566 const SIGNATURE: &'static str = "registerSafeWithNodeSig(address,address,bytes)";
2567 const SELECTOR: [u8; 4] = [73u8, 210u8, 21u8, 225u8];
2568 #[inline]
2569 fn new<'a>(
2570 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
2571 ) -> Self {
2572 tuple.into()
2573 }
2574 #[inline]
2575 fn tokenize(&self) -> Self::Token<'_> {
2576 (
2577 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
2578 &self.safeAddress,
2579 ),
2580 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
2581 &self.nodeChainKeyAddress,
2582 ),
2583 <alloy::sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
2584 &self.sig,
2585 ),
2586 )
2587 }
2588 #[inline]
2589 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
2590 registerSafeWithNodeSigReturn::_tokenize(ret)
2591 }
2592 #[inline]
2593 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
2594 <Self::ReturnTuple<
2595 '_,
2596 > as alloy_sol_types::SolType>::abi_decode_sequence(data)
2597 .map(Into::into)
2598 }
2599 #[inline]
2600 fn abi_decode_returns_validate(
2601 data: &[u8],
2602 ) -> alloy_sol_types::Result<Self::Return> {
2603 <Self::ReturnTuple<
2604 '_,
2605 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
2606 .map(Into::into)
2607 }
2608 }
2609 };
2610 #[derive(serde::Serialize, serde::Deserialize)]
2611 #[derive(Default, Debug, PartialEq, Eq, Hash)]
2612 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2617 #[derive(Clone)]
2618 pub struct updateDomainSeparatorCall;
2619 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2621 #[derive(Clone)]
2622 pub struct updateDomainSeparatorReturn {}
2623 #[allow(
2624 non_camel_case_types,
2625 non_snake_case,
2626 clippy::pub_underscore_fields,
2627 clippy::style
2628 )]
2629 const _: () = {
2630 use alloy::sol_types as alloy_sol_types;
2631 {
2632 #[doc(hidden)]
2633 type UnderlyingSolTuple<'a> = ();
2634 #[doc(hidden)]
2635 type UnderlyingRustTuple<'a> = ();
2636 #[cfg(test)]
2637 #[allow(dead_code, unreachable_patterns)]
2638 fn _type_assertion(
2639 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
2640 ) {
2641 match _t {
2642 alloy_sol_types::private::AssertTypeEq::<
2643 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2644 >(_) => {}
2645 }
2646 }
2647 #[automatically_derived]
2648 #[doc(hidden)]
2649 impl ::core::convert::From<updateDomainSeparatorCall>
2650 for UnderlyingRustTuple<'_> {
2651 fn from(value: updateDomainSeparatorCall) -> Self {
2652 ()
2653 }
2654 }
2655 #[automatically_derived]
2656 #[doc(hidden)]
2657 impl ::core::convert::From<UnderlyingRustTuple<'_>>
2658 for updateDomainSeparatorCall {
2659 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2660 Self
2661 }
2662 }
2663 }
2664 {
2665 #[doc(hidden)]
2666 type UnderlyingSolTuple<'a> = ();
2667 #[doc(hidden)]
2668 type UnderlyingRustTuple<'a> = ();
2669 #[cfg(test)]
2670 #[allow(dead_code, unreachable_patterns)]
2671 fn _type_assertion(
2672 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
2673 ) {
2674 match _t {
2675 alloy_sol_types::private::AssertTypeEq::<
2676 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2677 >(_) => {}
2678 }
2679 }
2680 #[automatically_derived]
2681 #[doc(hidden)]
2682 impl ::core::convert::From<updateDomainSeparatorReturn>
2683 for UnderlyingRustTuple<'_> {
2684 fn from(value: updateDomainSeparatorReturn) -> Self {
2685 ()
2686 }
2687 }
2688 #[automatically_derived]
2689 #[doc(hidden)]
2690 impl ::core::convert::From<UnderlyingRustTuple<'_>>
2691 for updateDomainSeparatorReturn {
2692 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2693 Self {}
2694 }
2695 }
2696 }
2697 impl updateDomainSeparatorReturn {
2698 fn _tokenize(
2699 &self,
2700 ) -> <updateDomainSeparatorCall as alloy_sol_types::SolCall>::ReturnToken<
2701 '_,
2702 > {
2703 ()
2704 }
2705 }
2706 #[automatically_derived]
2707 impl alloy_sol_types::SolCall for updateDomainSeparatorCall {
2708 type Parameters<'a> = ();
2709 type Token<'a> = <Self::Parameters<
2710 'a,
2711 > as alloy_sol_types::SolType>::Token<'a>;
2712 type Return = updateDomainSeparatorReturn;
2713 type ReturnTuple<'a> = ();
2714 type ReturnToken<'a> = <Self::ReturnTuple<
2715 'a,
2716 > as alloy_sol_types::SolType>::Token<'a>;
2717 const SIGNATURE: &'static str = "updateDomainSeparator()";
2718 const SELECTOR: [u8; 4] = [137u8, 204u8, 254u8, 137u8];
2719 #[inline]
2720 fn new<'a>(
2721 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
2722 ) -> Self {
2723 tuple.into()
2724 }
2725 #[inline]
2726 fn tokenize(&self) -> Self::Token<'_> {
2727 ()
2728 }
2729 #[inline]
2730 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
2731 updateDomainSeparatorReturn::_tokenize(ret)
2732 }
2733 #[inline]
2734 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
2735 <Self::ReturnTuple<
2736 '_,
2737 > as alloy_sol_types::SolType>::abi_decode_sequence(data)
2738 .map(Into::into)
2739 }
2740 #[inline]
2741 fn abi_decode_returns_validate(
2742 data: &[u8],
2743 ) -> alloy_sol_types::Result<Self::Return> {
2744 <Self::ReturnTuple<
2745 '_,
2746 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
2747 .map(Into::into)
2748 }
2749 }
2750 };
2751 #[derive(serde::Serialize, serde::Deserialize)]
2753 #[derive()]
2754 pub enum HoprNodeSafeRegistryCalls {
2755 #[allow(missing_docs)]
2756 NODE_SAFE_TYPEHASH(NODE_SAFE_TYPEHASHCall),
2757 #[allow(missing_docs)]
2758 VERSION(VERSIONCall),
2759 #[allow(missing_docs)]
2760 deregisterNodeBySafe(deregisterNodeBySafeCall),
2761 #[allow(missing_docs)]
2762 domainSeparator(domainSeparatorCall),
2763 #[allow(missing_docs)]
2764 isNodeSafeRegistered(isNodeSafeRegisteredCall),
2765 #[allow(missing_docs)]
2766 nodeSigNonce(nodeSigNonceCall),
2767 #[allow(missing_docs)]
2768 nodeToSafe(nodeToSafeCall),
2769 #[allow(missing_docs)]
2770 registerSafeByNode(registerSafeByNodeCall),
2771 #[allow(missing_docs)]
2772 registerSafeWithNodeSig(registerSafeWithNodeSigCall),
2773 #[allow(missing_docs)]
2774 updateDomainSeparator(updateDomainSeparatorCall),
2775 }
2776 #[automatically_derived]
2777 impl HoprNodeSafeRegistryCalls {
2778 pub const SELECTORS: &'static [[u8; 4usize]] = &[
2785 [55u8, 72u8, 10u8, 189u8],
2786 [73u8, 210u8, 21u8, 225u8],
2787 [127u8, 147u8, 89u8, 49u8],
2788 [132u8, 176u8, 222u8, 194u8],
2789 [137u8, 151u8, 140u8, 64u8],
2790 [137u8, 204u8, 254u8, 137u8],
2791 [145u8, 96u8, 124u8, 76u8],
2792 [170u8, 144u8, 242u8, 165u8],
2793 [246u8, 152u8, 218u8, 37u8],
2794 [255u8, 161u8, 173u8, 116u8],
2795 ];
2796 }
2797 #[automatically_derived]
2798 impl alloy_sol_types::SolInterface for HoprNodeSafeRegistryCalls {
2799 const NAME: &'static str = "HoprNodeSafeRegistryCalls";
2800 const MIN_DATA_LENGTH: usize = 0usize;
2801 const COUNT: usize = 10usize;
2802 #[inline]
2803 fn selector(&self) -> [u8; 4] {
2804 match self {
2805 Self::NODE_SAFE_TYPEHASH(_) => {
2806 <NODE_SAFE_TYPEHASHCall as alloy_sol_types::SolCall>::SELECTOR
2807 }
2808 Self::VERSION(_) => <VERSIONCall as alloy_sol_types::SolCall>::SELECTOR,
2809 Self::deregisterNodeBySafe(_) => {
2810 <deregisterNodeBySafeCall as alloy_sol_types::SolCall>::SELECTOR
2811 }
2812 Self::domainSeparator(_) => {
2813 <domainSeparatorCall as alloy_sol_types::SolCall>::SELECTOR
2814 }
2815 Self::isNodeSafeRegistered(_) => {
2816 <isNodeSafeRegisteredCall as alloy_sol_types::SolCall>::SELECTOR
2817 }
2818 Self::nodeSigNonce(_) => {
2819 <nodeSigNonceCall as alloy_sol_types::SolCall>::SELECTOR
2820 }
2821 Self::nodeToSafe(_) => {
2822 <nodeToSafeCall as alloy_sol_types::SolCall>::SELECTOR
2823 }
2824 Self::registerSafeByNode(_) => {
2825 <registerSafeByNodeCall as alloy_sol_types::SolCall>::SELECTOR
2826 }
2827 Self::registerSafeWithNodeSig(_) => {
2828 <registerSafeWithNodeSigCall as alloy_sol_types::SolCall>::SELECTOR
2829 }
2830 Self::updateDomainSeparator(_) => {
2831 <updateDomainSeparatorCall as alloy_sol_types::SolCall>::SELECTOR
2832 }
2833 }
2834 }
2835 #[inline]
2836 fn selector_at(i: usize) -> ::core::option::Option<[u8; 4]> {
2837 Self::SELECTORS.get(i).copied()
2838 }
2839 #[inline]
2840 fn valid_selector(selector: [u8; 4]) -> bool {
2841 Self::SELECTORS.binary_search(&selector).is_ok()
2842 }
2843 #[inline]
2844 #[allow(non_snake_case)]
2845 fn abi_decode_raw(
2846 selector: [u8; 4],
2847 data: &[u8],
2848 ) -> alloy_sol_types::Result<Self> {
2849 static DECODE_SHIMS: &[fn(
2850 &[u8],
2851 ) -> alloy_sol_types::Result<HoprNodeSafeRegistryCalls>] = &[
2852 {
2853 fn isNodeSafeRegistered(
2854 data: &[u8],
2855 ) -> alloy_sol_types::Result<HoprNodeSafeRegistryCalls> {
2856 <isNodeSafeRegisteredCall as alloy_sol_types::SolCall>::abi_decode_raw(
2857 data,
2858 )
2859 .map(HoprNodeSafeRegistryCalls::isNodeSafeRegistered)
2860 }
2861 isNodeSafeRegistered
2862 },
2863 {
2864 fn registerSafeWithNodeSig(
2865 data: &[u8],
2866 ) -> alloy_sol_types::Result<HoprNodeSafeRegistryCalls> {
2867 <registerSafeWithNodeSigCall as alloy_sol_types::SolCall>::abi_decode_raw(
2868 data,
2869 )
2870 .map(HoprNodeSafeRegistryCalls::registerSafeWithNodeSig)
2871 }
2872 registerSafeWithNodeSig
2873 },
2874 {
2875 fn registerSafeByNode(
2876 data: &[u8],
2877 ) -> alloy_sol_types::Result<HoprNodeSafeRegistryCalls> {
2878 <registerSafeByNodeCall as alloy_sol_types::SolCall>::abi_decode_raw(
2879 data,
2880 )
2881 .map(HoprNodeSafeRegistryCalls::registerSafeByNode)
2882 }
2883 registerSafeByNode
2884 },
2885 {
2886 fn NODE_SAFE_TYPEHASH(
2887 data: &[u8],
2888 ) -> alloy_sol_types::Result<HoprNodeSafeRegistryCalls> {
2889 <NODE_SAFE_TYPEHASHCall as alloy_sol_types::SolCall>::abi_decode_raw(
2890 data,
2891 )
2892 .map(HoprNodeSafeRegistryCalls::NODE_SAFE_TYPEHASH)
2893 }
2894 NODE_SAFE_TYPEHASH
2895 },
2896 {
2897 fn nodeToSafe(
2898 data: &[u8],
2899 ) -> alloy_sol_types::Result<HoprNodeSafeRegistryCalls> {
2900 <nodeToSafeCall as alloy_sol_types::SolCall>::abi_decode_raw(
2901 data,
2902 )
2903 .map(HoprNodeSafeRegistryCalls::nodeToSafe)
2904 }
2905 nodeToSafe
2906 },
2907 {
2908 fn updateDomainSeparator(
2909 data: &[u8],
2910 ) -> alloy_sol_types::Result<HoprNodeSafeRegistryCalls> {
2911 <updateDomainSeparatorCall as alloy_sol_types::SolCall>::abi_decode_raw(
2912 data,
2913 )
2914 .map(HoprNodeSafeRegistryCalls::updateDomainSeparator)
2915 }
2916 updateDomainSeparator
2917 },
2918 {
2919 fn deregisterNodeBySafe(
2920 data: &[u8],
2921 ) -> alloy_sol_types::Result<HoprNodeSafeRegistryCalls> {
2922 <deregisterNodeBySafeCall as alloy_sol_types::SolCall>::abi_decode_raw(
2923 data,
2924 )
2925 .map(HoprNodeSafeRegistryCalls::deregisterNodeBySafe)
2926 }
2927 deregisterNodeBySafe
2928 },
2929 {
2930 fn nodeSigNonce(
2931 data: &[u8],
2932 ) -> alloy_sol_types::Result<HoprNodeSafeRegistryCalls> {
2933 <nodeSigNonceCall as alloy_sol_types::SolCall>::abi_decode_raw(
2934 data,
2935 )
2936 .map(HoprNodeSafeRegistryCalls::nodeSigNonce)
2937 }
2938 nodeSigNonce
2939 },
2940 {
2941 fn domainSeparator(
2942 data: &[u8],
2943 ) -> alloy_sol_types::Result<HoprNodeSafeRegistryCalls> {
2944 <domainSeparatorCall as alloy_sol_types::SolCall>::abi_decode_raw(
2945 data,
2946 )
2947 .map(HoprNodeSafeRegistryCalls::domainSeparator)
2948 }
2949 domainSeparator
2950 },
2951 {
2952 fn VERSION(
2953 data: &[u8],
2954 ) -> alloy_sol_types::Result<HoprNodeSafeRegistryCalls> {
2955 <VERSIONCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
2956 .map(HoprNodeSafeRegistryCalls::VERSION)
2957 }
2958 VERSION
2959 },
2960 ];
2961 let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
2962 return Err(
2963 alloy_sol_types::Error::unknown_selector(
2964 <Self as alloy_sol_types::SolInterface>::NAME,
2965 selector,
2966 ),
2967 );
2968 };
2969 DECODE_SHIMS[idx](data)
2970 }
2971 #[inline]
2972 #[allow(non_snake_case)]
2973 fn abi_decode_raw_validate(
2974 selector: [u8; 4],
2975 data: &[u8],
2976 ) -> alloy_sol_types::Result<Self> {
2977 static DECODE_VALIDATE_SHIMS: &[fn(
2978 &[u8],
2979 ) -> alloy_sol_types::Result<HoprNodeSafeRegistryCalls>] = &[
2980 {
2981 fn isNodeSafeRegistered(
2982 data: &[u8],
2983 ) -> alloy_sol_types::Result<HoprNodeSafeRegistryCalls> {
2984 <isNodeSafeRegisteredCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
2985 data,
2986 )
2987 .map(HoprNodeSafeRegistryCalls::isNodeSafeRegistered)
2988 }
2989 isNodeSafeRegistered
2990 },
2991 {
2992 fn registerSafeWithNodeSig(
2993 data: &[u8],
2994 ) -> alloy_sol_types::Result<HoprNodeSafeRegistryCalls> {
2995 <registerSafeWithNodeSigCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
2996 data,
2997 )
2998 .map(HoprNodeSafeRegistryCalls::registerSafeWithNodeSig)
2999 }
3000 registerSafeWithNodeSig
3001 },
3002 {
3003 fn registerSafeByNode(
3004 data: &[u8],
3005 ) -> alloy_sol_types::Result<HoprNodeSafeRegistryCalls> {
3006 <registerSafeByNodeCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
3007 data,
3008 )
3009 .map(HoprNodeSafeRegistryCalls::registerSafeByNode)
3010 }
3011 registerSafeByNode
3012 },
3013 {
3014 fn NODE_SAFE_TYPEHASH(
3015 data: &[u8],
3016 ) -> alloy_sol_types::Result<HoprNodeSafeRegistryCalls> {
3017 <NODE_SAFE_TYPEHASHCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
3018 data,
3019 )
3020 .map(HoprNodeSafeRegistryCalls::NODE_SAFE_TYPEHASH)
3021 }
3022 NODE_SAFE_TYPEHASH
3023 },
3024 {
3025 fn nodeToSafe(
3026 data: &[u8],
3027 ) -> alloy_sol_types::Result<HoprNodeSafeRegistryCalls> {
3028 <nodeToSafeCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
3029 data,
3030 )
3031 .map(HoprNodeSafeRegistryCalls::nodeToSafe)
3032 }
3033 nodeToSafe
3034 },
3035 {
3036 fn updateDomainSeparator(
3037 data: &[u8],
3038 ) -> alloy_sol_types::Result<HoprNodeSafeRegistryCalls> {
3039 <updateDomainSeparatorCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
3040 data,
3041 )
3042 .map(HoprNodeSafeRegistryCalls::updateDomainSeparator)
3043 }
3044 updateDomainSeparator
3045 },
3046 {
3047 fn deregisterNodeBySafe(
3048 data: &[u8],
3049 ) -> alloy_sol_types::Result<HoprNodeSafeRegistryCalls> {
3050 <deregisterNodeBySafeCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
3051 data,
3052 )
3053 .map(HoprNodeSafeRegistryCalls::deregisterNodeBySafe)
3054 }
3055 deregisterNodeBySafe
3056 },
3057 {
3058 fn nodeSigNonce(
3059 data: &[u8],
3060 ) -> alloy_sol_types::Result<HoprNodeSafeRegistryCalls> {
3061 <nodeSigNonceCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
3062 data,
3063 )
3064 .map(HoprNodeSafeRegistryCalls::nodeSigNonce)
3065 }
3066 nodeSigNonce
3067 },
3068 {
3069 fn domainSeparator(
3070 data: &[u8],
3071 ) -> alloy_sol_types::Result<HoprNodeSafeRegistryCalls> {
3072 <domainSeparatorCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
3073 data,
3074 )
3075 .map(HoprNodeSafeRegistryCalls::domainSeparator)
3076 }
3077 domainSeparator
3078 },
3079 {
3080 fn VERSION(
3081 data: &[u8],
3082 ) -> alloy_sol_types::Result<HoprNodeSafeRegistryCalls> {
3083 <VERSIONCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
3084 data,
3085 )
3086 .map(HoprNodeSafeRegistryCalls::VERSION)
3087 }
3088 VERSION
3089 },
3090 ];
3091 let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
3092 return Err(
3093 alloy_sol_types::Error::unknown_selector(
3094 <Self as alloy_sol_types::SolInterface>::NAME,
3095 selector,
3096 ),
3097 );
3098 };
3099 DECODE_VALIDATE_SHIMS[idx](data)
3100 }
3101 #[inline]
3102 fn abi_encoded_size(&self) -> usize {
3103 match self {
3104 Self::NODE_SAFE_TYPEHASH(inner) => {
3105 <NODE_SAFE_TYPEHASHCall as alloy_sol_types::SolCall>::abi_encoded_size(
3106 inner,
3107 )
3108 }
3109 Self::VERSION(inner) => {
3110 <VERSIONCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
3111 }
3112 Self::deregisterNodeBySafe(inner) => {
3113 <deregisterNodeBySafeCall as alloy_sol_types::SolCall>::abi_encoded_size(
3114 inner,
3115 )
3116 }
3117 Self::domainSeparator(inner) => {
3118 <domainSeparatorCall as alloy_sol_types::SolCall>::abi_encoded_size(
3119 inner,
3120 )
3121 }
3122 Self::isNodeSafeRegistered(inner) => {
3123 <isNodeSafeRegisteredCall as alloy_sol_types::SolCall>::abi_encoded_size(
3124 inner,
3125 )
3126 }
3127 Self::nodeSigNonce(inner) => {
3128 <nodeSigNonceCall as alloy_sol_types::SolCall>::abi_encoded_size(
3129 inner,
3130 )
3131 }
3132 Self::nodeToSafe(inner) => {
3133 <nodeToSafeCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
3134 }
3135 Self::registerSafeByNode(inner) => {
3136 <registerSafeByNodeCall as alloy_sol_types::SolCall>::abi_encoded_size(
3137 inner,
3138 )
3139 }
3140 Self::registerSafeWithNodeSig(inner) => {
3141 <registerSafeWithNodeSigCall as alloy_sol_types::SolCall>::abi_encoded_size(
3142 inner,
3143 )
3144 }
3145 Self::updateDomainSeparator(inner) => {
3146 <updateDomainSeparatorCall as alloy_sol_types::SolCall>::abi_encoded_size(
3147 inner,
3148 )
3149 }
3150 }
3151 }
3152 #[inline]
3153 fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
3154 match self {
3155 Self::NODE_SAFE_TYPEHASH(inner) => {
3156 <NODE_SAFE_TYPEHASHCall as alloy_sol_types::SolCall>::abi_encode_raw(
3157 inner,
3158 out,
3159 )
3160 }
3161 Self::VERSION(inner) => {
3162 <VERSIONCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
3163 }
3164 Self::deregisterNodeBySafe(inner) => {
3165 <deregisterNodeBySafeCall as alloy_sol_types::SolCall>::abi_encode_raw(
3166 inner,
3167 out,
3168 )
3169 }
3170 Self::domainSeparator(inner) => {
3171 <domainSeparatorCall as alloy_sol_types::SolCall>::abi_encode_raw(
3172 inner,
3173 out,
3174 )
3175 }
3176 Self::isNodeSafeRegistered(inner) => {
3177 <isNodeSafeRegisteredCall as alloy_sol_types::SolCall>::abi_encode_raw(
3178 inner,
3179 out,
3180 )
3181 }
3182 Self::nodeSigNonce(inner) => {
3183 <nodeSigNonceCall as alloy_sol_types::SolCall>::abi_encode_raw(
3184 inner,
3185 out,
3186 )
3187 }
3188 Self::nodeToSafe(inner) => {
3189 <nodeToSafeCall as alloy_sol_types::SolCall>::abi_encode_raw(
3190 inner,
3191 out,
3192 )
3193 }
3194 Self::registerSafeByNode(inner) => {
3195 <registerSafeByNodeCall as alloy_sol_types::SolCall>::abi_encode_raw(
3196 inner,
3197 out,
3198 )
3199 }
3200 Self::registerSafeWithNodeSig(inner) => {
3201 <registerSafeWithNodeSigCall as alloy_sol_types::SolCall>::abi_encode_raw(
3202 inner,
3203 out,
3204 )
3205 }
3206 Self::updateDomainSeparator(inner) => {
3207 <updateDomainSeparatorCall as alloy_sol_types::SolCall>::abi_encode_raw(
3208 inner,
3209 out,
3210 )
3211 }
3212 }
3213 }
3214 }
3215 #[derive(serde::Serialize, serde::Deserialize)]
3217 #[derive(Debug, PartialEq, Eq, Hash)]
3218 pub enum HoprNodeSafeRegistryErrors {
3219 #[allow(missing_docs)]
3220 NodeAddressZero(NodeAddressZero),
3221 #[allow(missing_docs)]
3222 NodeHasSafe(NodeHasSafe),
3223 #[allow(missing_docs)]
3224 NodeIsContract(NodeIsContract),
3225 #[allow(missing_docs)]
3226 NodeNotModuleMember(NodeNotModuleMember),
3227 #[allow(missing_docs)]
3228 NotValidSafe(NotValidSafe),
3229 #[allow(missing_docs)]
3230 NotValidSignatureFromNode(NotValidSignatureFromNode),
3231 #[allow(missing_docs)]
3232 SafeAddressZero(SafeAddressZero),
3233 }
3234 #[automatically_derived]
3235 impl HoprNodeSafeRegistryErrors {
3236 pub const SELECTORS: &'static [[u8; 4usize]] = &[
3243 [20u8, 231u8, 146u8, 33u8],
3244 [86u8, 254u8, 133u8, 84u8],
3245 [103u8, 220u8, 48u8, 1u8],
3246 [125u8, 14u8, 213u8, 38u8],
3247 [126u8, 10u8, 124u8, 12u8],
3248 [180u8, 201u8, 31u8, 251u8],
3249 [186u8, 93u8, 126u8, 176u8],
3250 ];
3251 }
3252 #[automatically_derived]
3253 impl alloy_sol_types::SolInterface for HoprNodeSafeRegistryErrors {
3254 const NAME: &'static str = "HoprNodeSafeRegistryErrors";
3255 const MIN_DATA_LENGTH: usize = 0usize;
3256 const COUNT: usize = 7usize;
3257 #[inline]
3258 fn selector(&self) -> [u8; 4] {
3259 match self {
3260 Self::NodeAddressZero(_) => {
3261 <NodeAddressZero as alloy_sol_types::SolError>::SELECTOR
3262 }
3263 Self::NodeHasSafe(_) => {
3264 <NodeHasSafe as alloy_sol_types::SolError>::SELECTOR
3265 }
3266 Self::NodeIsContract(_) => {
3267 <NodeIsContract as alloy_sol_types::SolError>::SELECTOR
3268 }
3269 Self::NodeNotModuleMember(_) => {
3270 <NodeNotModuleMember as alloy_sol_types::SolError>::SELECTOR
3271 }
3272 Self::NotValidSafe(_) => {
3273 <NotValidSafe as alloy_sol_types::SolError>::SELECTOR
3274 }
3275 Self::NotValidSignatureFromNode(_) => {
3276 <NotValidSignatureFromNode as alloy_sol_types::SolError>::SELECTOR
3277 }
3278 Self::SafeAddressZero(_) => {
3279 <SafeAddressZero as alloy_sol_types::SolError>::SELECTOR
3280 }
3281 }
3282 }
3283 #[inline]
3284 fn selector_at(i: usize) -> ::core::option::Option<[u8; 4]> {
3285 Self::SELECTORS.get(i).copied()
3286 }
3287 #[inline]
3288 fn valid_selector(selector: [u8; 4]) -> bool {
3289 Self::SELECTORS.binary_search(&selector).is_ok()
3290 }
3291 #[inline]
3292 #[allow(non_snake_case)]
3293 fn abi_decode_raw(
3294 selector: [u8; 4],
3295 data: &[u8],
3296 ) -> alloy_sol_types::Result<Self> {
3297 static DECODE_SHIMS: &[fn(
3298 &[u8],
3299 ) -> alloy_sol_types::Result<HoprNodeSafeRegistryErrors>] = &[
3300 {
3301 fn SafeAddressZero(
3302 data: &[u8],
3303 ) -> alloy_sol_types::Result<HoprNodeSafeRegistryErrors> {
3304 <SafeAddressZero as alloy_sol_types::SolError>::abi_decode_raw(
3305 data,
3306 )
3307 .map(HoprNodeSafeRegistryErrors::SafeAddressZero)
3308 }
3309 SafeAddressZero
3310 },
3311 {
3312 fn NotValidSafe(
3313 data: &[u8],
3314 ) -> alloy_sol_types::Result<HoprNodeSafeRegistryErrors> {
3315 <NotValidSafe as alloy_sol_types::SolError>::abi_decode_raw(data)
3316 .map(HoprNodeSafeRegistryErrors::NotValidSafe)
3317 }
3318 NotValidSafe
3319 },
3320 {
3321 fn NodeHasSafe(
3322 data: &[u8],
3323 ) -> alloy_sol_types::Result<HoprNodeSafeRegistryErrors> {
3324 <NodeHasSafe as alloy_sol_types::SolError>::abi_decode_raw(data)
3325 .map(HoprNodeSafeRegistryErrors::NodeHasSafe)
3326 }
3327 NodeHasSafe
3328 },
3329 {
3330 fn NodeAddressZero(
3331 data: &[u8],
3332 ) -> alloy_sol_types::Result<HoprNodeSafeRegistryErrors> {
3333 <NodeAddressZero as alloy_sol_types::SolError>::abi_decode_raw(
3334 data,
3335 )
3336 .map(HoprNodeSafeRegistryErrors::NodeAddressZero)
3337 }
3338 NodeAddressZero
3339 },
3340 {
3341 fn NodeIsContract(
3342 data: &[u8],
3343 ) -> alloy_sol_types::Result<HoprNodeSafeRegistryErrors> {
3344 <NodeIsContract as alloy_sol_types::SolError>::abi_decode_raw(
3345 data,
3346 )
3347 .map(HoprNodeSafeRegistryErrors::NodeIsContract)
3348 }
3349 NodeIsContract
3350 },
3351 {
3352 fn NotValidSignatureFromNode(
3353 data: &[u8],
3354 ) -> alloy_sol_types::Result<HoprNodeSafeRegistryErrors> {
3355 <NotValidSignatureFromNode as alloy_sol_types::SolError>::abi_decode_raw(
3356 data,
3357 )
3358 .map(HoprNodeSafeRegistryErrors::NotValidSignatureFromNode)
3359 }
3360 NotValidSignatureFromNode
3361 },
3362 {
3363 fn NodeNotModuleMember(
3364 data: &[u8],
3365 ) -> alloy_sol_types::Result<HoprNodeSafeRegistryErrors> {
3366 <NodeNotModuleMember as alloy_sol_types::SolError>::abi_decode_raw(
3367 data,
3368 )
3369 .map(HoprNodeSafeRegistryErrors::NodeNotModuleMember)
3370 }
3371 NodeNotModuleMember
3372 },
3373 ];
3374 let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
3375 return Err(
3376 alloy_sol_types::Error::unknown_selector(
3377 <Self as alloy_sol_types::SolInterface>::NAME,
3378 selector,
3379 ),
3380 );
3381 };
3382 DECODE_SHIMS[idx](data)
3383 }
3384 #[inline]
3385 #[allow(non_snake_case)]
3386 fn abi_decode_raw_validate(
3387 selector: [u8; 4],
3388 data: &[u8],
3389 ) -> alloy_sol_types::Result<Self> {
3390 static DECODE_VALIDATE_SHIMS: &[fn(
3391 &[u8],
3392 ) -> alloy_sol_types::Result<HoprNodeSafeRegistryErrors>] = &[
3393 {
3394 fn SafeAddressZero(
3395 data: &[u8],
3396 ) -> alloy_sol_types::Result<HoprNodeSafeRegistryErrors> {
3397 <SafeAddressZero as alloy_sol_types::SolError>::abi_decode_raw_validate(
3398 data,
3399 )
3400 .map(HoprNodeSafeRegistryErrors::SafeAddressZero)
3401 }
3402 SafeAddressZero
3403 },
3404 {
3405 fn NotValidSafe(
3406 data: &[u8],
3407 ) -> alloy_sol_types::Result<HoprNodeSafeRegistryErrors> {
3408 <NotValidSafe as alloy_sol_types::SolError>::abi_decode_raw_validate(
3409 data,
3410 )
3411 .map(HoprNodeSafeRegistryErrors::NotValidSafe)
3412 }
3413 NotValidSafe
3414 },
3415 {
3416 fn NodeHasSafe(
3417 data: &[u8],
3418 ) -> alloy_sol_types::Result<HoprNodeSafeRegistryErrors> {
3419 <NodeHasSafe as alloy_sol_types::SolError>::abi_decode_raw_validate(
3420 data,
3421 )
3422 .map(HoprNodeSafeRegistryErrors::NodeHasSafe)
3423 }
3424 NodeHasSafe
3425 },
3426 {
3427 fn NodeAddressZero(
3428 data: &[u8],
3429 ) -> alloy_sol_types::Result<HoprNodeSafeRegistryErrors> {
3430 <NodeAddressZero as alloy_sol_types::SolError>::abi_decode_raw_validate(
3431 data,
3432 )
3433 .map(HoprNodeSafeRegistryErrors::NodeAddressZero)
3434 }
3435 NodeAddressZero
3436 },
3437 {
3438 fn NodeIsContract(
3439 data: &[u8],
3440 ) -> alloy_sol_types::Result<HoprNodeSafeRegistryErrors> {
3441 <NodeIsContract as alloy_sol_types::SolError>::abi_decode_raw_validate(
3442 data,
3443 )
3444 .map(HoprNodeSafeRegistryErrors::NodeIsContract)
3445 }
3446 NodeIsContract
3447 },
3448 {
3449 fn NotValidSignatureFromNode(
3450 data: &[u8],
3451 ) -> alloy_sol_types::Result<HoprNodeSafeRegistryErrors> {
3452 <NotValidSignatureFromNode as alloy_sol_types::SolError>::abi_decode_raw_validate(
3453 data,
3454 )
3455 .map(HoprNodeSafeRegistryErrors::NotValidSignatureFromNode)
3456 }
3457 NotValidSignatureFromNode
3458 },
3459 {
3460 fn NodeNotModuleMember(
3461 data: &[u8],
3462 ) -> alloy_sol_types::Result<HoprNodeSafeRegistryErrors> {
3463 <NodeNotModuleMember as alloy_sol_types::SolError>::abi_decode_raw_validate(
3464 data,
3465 )
3466 .map(HoprNodeSafeRegistryErrors::NodeNotModuleMember)
3467 }
3468 NodeNotModuleMember
3469 },
3470 ];
3471 let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
3472 return Err(
3473 alloy_sol_types::Error::unknown_selector(
3474 <Self as alloy_sol_types::SolInterface>::NAME,
3475 selector,
3476 ),
3477 );
3478 };
3479 DECODE_VALIDATE_SHIMS[idx](data)
3480 }
3481 #[inline]
3482 fn abi_encoded_size(&self) -> usize {
3483 match self {
3484 Self::NodeAddressZero(inner) => {
3485 <NodeAddressZero as alloy_sol_types::SolError>::abi_encoded_size(
3486 inner,
3487 )
3488 }
3489 Self::NodeHasSafe(inner) => {
3490 <NodeHasSafe as alloy_sol_types::SolError>::abi_encoded_size(inner)
3491 }
3492 Self::NodeIsContract(inner) => {
3493 <NodeIsContract as alloy_sol_types::SolError>::abi_encoded_size(
3494 inner,
3495 )
3496 }
3497 Self::NodeNotModuleMember(inner) => {
3498 <NodeNotModuleMember as alloy_sol_types::SolError>::abi_encoded_size(
3499 inner,
3500 )
3501 }
3502 Self::NotValidSafe(inner) => {
3503 <NotValidSafe as alloy_sol_types::SolError>::abi_encoded_size(inner)
3504 }
3505 Self::NotValidSignatureFromNode(inner) => {
3506 <NotValidSignatureFromNode as alloy_sol_types::SolError>::abi_encoded_size(
3507 inner,
3508 )
3509 }
3510 Self::SafeAddressZero(inner) => {
3511 <SafeAddressZero as alloy_sol_types::SolError>::abi_encoded_size(
3512 inner,
3513 )
3514 }
3515 }
3516 }
3517 #[inline]
3518 fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
3519 match self {
3520 Self::NodeAddressZero(inner) => {
3521 <NodeAddressZero as alloy_sol_types::SolError>::abi_encode_raw(
3522 inner,
3523 out,
3524 )
3525 }
3526 Self::NodeHasSafe(inner) => {
3527 <NodeHasSafe as alloy_sol_types::SolError>::abi_encode_raw(
3528 inner,
3529 out,
3530 )
3531 }
3532 Self::NodeIsContract(inner) => {
3533 <NodeIsContract as alloy_sol_types::SolError>::abi_encode_raw(
3534 inner,
3535 out,
3536 )
3537 }
3538 Self::NodeNotModuleMember(inner) => {
3539 <NodeNotModuleMember as alloy_sol_types::SolError>::abi_encode_raw(
3540 inner,
3541 out,
3542 )
3543 }
3544 Self::NotValidSafe(inner) => {
3545 <NotValidSafe as alloy_sol_types::SolError>::abi_encode_raw(
3546 inner,
3547 out,
3548 )
3549 }
3550 Self::NotValidSignatureFromNode(inner) => {
3551 <NotValidSignatureFromNode as alloy_sol_types::SolError>::abi_encode_raw(
3552 inner,
3553 out,
3554 )
3555 }
3556 Self::SafeAddressZero(inner) => {
3557 <SafeAddressZero as alloy_sol_types::SolError>::abi_encode_raw(
3558 inner,
3559 out,
3560 )
3561 }
3562 }
3563 }
3564 }
3565 #[derive(serde::Serialize, serde::Deserialize)]
3567 #[derive(Debug, PartialEq, Eq, Hash)]
3568 pub enum HoprNodeSafeRegistryEvents {
3569 #[allow(missing_docs)]
3570 DergisteredNodeSafe(DergisteredNodeSafe),
3571 #[allow(missing_docs)]
3572 DomainSeparatorUpdated(DomainSeparatorUpdated),
3573 #[allow(missing_docs)]
3574 RegisteredNodeSafe(RegisteredNodeSafe),
3575 }
3576 #[automatically_derived]
3577 impl HoprNodeSafeRegistryEvents {
3578 pub const SELECTORS: &'static [[u8; 32usize]] = &[
3585 [
3586 119u8, 31u8, 82u8, 64u8, 174u8, 95u8, 216u8, 167u8, 100u8, 13u8, 63u8,
3587 184u8, 47u8, 167u8, 10u8, 171u8, 47u8, 177u8, 219u8, 243u8, 95u8, 46u8,
3588 244u8, 100u8, 248u8, 80u8, 153u8, 70u8, 113u8, 118u8, 100u8, 197u8,
3589 ],
3590 [
3591 119u8, 109u8, 164u8, 12u8, 191u8, 44u8, 34u8, 53u8, 82u8, 102u8, 27u8,
3592 212u8, 133u8, 2u8, 206u8, 183u8, 36u8, 9u8, 179u8, 54u8, 43u8, 176u8,
3593 198u8, 109u8, 137u8, 137u8, 189u8, 126u8, 32u8, 228u8, 73u8, 125u8,
3594 ],
3595 [
3596 232u8, 55u8, 243u8, 57u8, 99u8, 146u8, 150u8, 190u8, 201u8, 244u8, 188u8,
3597 152u8, 97u8, 84u8, 245u8, 255u8, 118u8, 187u8, 190u8, 252u8, 49u8, 73u8,
3598 165u8, 18u8, 146u8, 14u8, 19u8, 17u8, 65u8, 78u8, 61u8, 161u8,
3599 ],
3600 ];
3601 }
3602 #[automatically_derived]
3603 impl alloy_sol_types::SolEventInterface for HoprNodeSafeRegistryEvents {
3604 const NAME: &'static str = "HoprNodeSafeRegistryEvents";
3605 const COUNT: usize = 3usize;
3606 fn decode_raw_log(
3607 topics: &[alloy_sol_types::Word],
3608 data: &[u8],
3609 ) -> alloy_sol_types::Result<Self> {
3610 match topics.first().copied() {
3611 Some(
3612 <DergisteredNodeSafe as alloy_sol_types::SolEvent>::SIGNATURE_HASH,
3613 ) => {
3614 <DergisteredNodeSafe as alloy_sol_types::SolEvent>::decode_raw_log(
3615 topics,
3616 data,
3617 )
3618 .map(Self::DergisteredNodeSafe)
3619 }
3620 Some(
3621 <DomainSeparatorUpdated as alloy_sol_types::SolEvent>::SIGNATURE_HASH,
3622 ) => {
3623 <DomainSeparatorUpdated as alloy_sol_types::SolEvent>::decode_raw_log(
3624 topics,
3625 data,
3626 )
3627 .map(Self::DomainSeparatorUpdated)
3628 }
3629 Some(
3630 <RegisteredNodeSafe as alloy_sol_types::SolEvent>::SIGNATURE_HASH,
3631 ) => {
3632 <RegisteredNodeSafe as alloy_sol_types::SolEvent>::decode_raw_log(
3633 topics,
3634 data,
3635 )
3636 .map(Self::RegisteredNodeSafe)
3637 }
3638 _ => {
3639 alloy_sol_types::private::Err(alloy_sol_types::Error::InvalidLog {
3640 name: <Self as alloy_sol_types::SolEventInterface>::NAME,
3641 log: alloy_sol_types::private::Box::new(
3642 alloy_sol_types::private::LogData::new_unchecked(
3643 topics.to_vec(),
3644 data.to_vec().into(),
3645 ),
3646 ),
3647 })
3648 }
3649 }
3650 }
3651 }
3652 #[automatically_derived]
3653 impl alloy_sol_types::private::IntoLogData for HoprNodeSafeRegistryEvents {
3654 fn to_log_data(&self) -> alloy_sol_types::private::LogData {
3655 match self {
3656 Self::DergisteredNodeSafe(inner) => {
3657 alloy_sol_types::private::IntoLogData::to_log_data(inner)
3658 }
3659 Self::DomainSeparatorUpdated(inner) => {
3660 alloy_sol_types::private::IntoLogData::to_log_data(inner)
3661 }
3662 Self::RegisteredNodeSafe(inner) => {
3663 alloy_sol_types::private::IntoLogData::to_log_data(inner)
3664 }
3665 }
3666 }
3667 fn into_log_data(self) -> alloy_sol_types::private::LogData {
3668 match self {
3669 Self::DergisteredNodeSafe(inner) => {
3670 alloy_sol_types::private::IntoLogData::into_log_data(inner)
3671 }
3672 Self::DomainSeparatorUpdated(inner) => {
3673 alloy_sol_types::private::IntoLogData::into_log_data(inner)
3674 }
3675 Self::RegisteredNodeSafe(inner) => {
3676 alloy_sol_types::private::IntoLogData::into_log_data(inner)
3677 }
3678 }
3679 }
3680 }
3681 use alloy::contract as alloy_contract;
3682 #[inline]
3686 pub const fn new<
3687 P: alloy_contract::private::Provider<N>,
3688 N: alloy_contract::private::Network,
3689 >(
3690 address: alloy_sol_types::private::Address,
3691 provider: P,
3692 ) -> HoprNodeSafeRegistryInstance<P, N> {
3693 HoprNodeSafeRegistryInstance::<P, N>::new(address, provider)
3694 }
3695 #[inline]
3701 pub fn deploy<
3702 P: alloy_contract::private::Provider<N>,
3703 N: alloy_contract::private::Network,
3704 >(
3705 provider: P,
3706 ) -> impl ::core::future::Future<
3707 Output = alloy_contract::Result<HoprNodeSafeRegistryInstance<P, N>>,
3708 > {
3709 HoprNodeSafeRegistryInstance::<P, N>::deploy(provider)
3710 }
3711 #[inline]
3717 pub fn deploy_builder<
3718 P: alloy_contract::private::Provider<N>,
3719 N: alloy_contract::private::Network,
3720 >(provider: P) -> alloy_contract::RawCallBuilder<P, N> {
3721 HoprNodeSafeRegistryInstance::<P, N>::deploy_builder(provider)
3722 }
3723 #[derive(Clone)]
3735 pub struct HoprNodeSafeRegistryInstance<P, N = alloy_contract::private::Ethereum> {
3736 address: alloy_sol_types::private::Address,
3737 provider: P,
3738 _network: ::core::marker::PhantomData<N>,
3739 }
3740 #[automatically_derived]
3741 impl<P, N> ::core::fmt::Debug for HoprNodeSafeRegistryInstance<P, N> {
3742 #[inline]
3743 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
3744 f.debug_tuple("HoprNodeSafeRegistryInstance").field(&self.address).finish()
3745 }
3746 }
3747 #[automatically_derived]
3749 impl<
3750 P: alloy_contract::private::Provider<N>,
3751 N: alloy_contract::private::Network,
3752 > HoprNodeSafeRegistryInstance<P, N> {
3753 #[inline]
3757 pub const fn new(
3758 address: alloy_sol_types::private::Address,
3759 provider: P,
3760 ) -> Self {
3761 Self {
3762 address,
3763 provider,
3764 _network: ::core::marker::PhantomData,
3765 }
3766 }
3767 #[inline]
3773 pub async fn deploy(
3774 provider: P,
3775 ) -> alloy_contract::Result<HoprNodeSafeRegistryInstance<P, N>> {
3776 let call_builder = Self::deploy_builder(provider);
3777 let contract_address = call_builder.deploy().await?;
3778 Ok(Self::new(contract_address, call_builder.provider))
3779 }
3780 #[inline]
3786 pub fn deploy_builder(provider: P) -> alloy_contract::RawCallBuilder<P, N> {
3787 alloy_contract::RawCallBuilder::new_raw_deploy(
3788 provider,
3789 ::core::clone::Clone::clone(&BYTECODE),
3790 )
3791 }
3792 #[inline]
3794 pub const fn address(&self) -> &alloy_sol_types::private::Address {
3795 &self.address
3796 }
3797 #[inline]
3799 pub fn set_address(&mut self, address: alloy_sol_types::private::Address) {
3800 self.address = address;
3801 }
3802 pub fn at(mut self, address: alloy_sol_types::private::Address) -> Self {
3804 self.set_address(address);
3805 self
3806 }
3807 #[inline]
3809 pub const fn provider(&self) -> &P {
3810 &self.provider
3811 }
3812 }
3813 impl<P: ::core::clone::Clone, N> HoprNodeSafeRegistryInstance<&P, N> {
3814 #[inline]
3816 pub fn with_cloned_provider(self) -> HoprNodeSafeRegistryInstance<P, N> {
3817 HoprNodeSafeRegistryInstance {
3818 address: self.address,
3819 provider: ::core::clone::Clone::clone(&self.provider),
3820 _network: ::core::marker::PhantomData,
3821 }
3822 }
3823 }
3824 #[automatically_derived]
3826 impl<
3827 P: alloy_contract::private::Provider<N>,
3828 N: alloy_contract::private::Network,
3829 > HoprNodeSafeRegistryInstance<P, N> {
3830 pub fn call_builder<C: alloy_sol_types::SolCall>(
3835 &self,
3836 call: &C,
3837 ) -> alloy_contract::SolCallBuilder<&P, C, N> {
3838 alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call)
3839 }
3840 pub fn NODE_SAFE_TYPEHASH(
3842 &self,
3843 ) -> alloy_contract::SolCallBuilder<&P, NODE_SAFE_TYPEHASHCall, N> {
3844 self.call_builder(&NODE_SAFE_TYPEHASHCall)
3845 }
3846 pub fn VERSION(&self) -> alloy_contract::SolCallBuilder<&P, VERSIONCall, N> {
3848 self.call_builder(&VERSIONCall)
3849 }
3850 pub fn deregisterNodeBySafe(
3852 &self,
3853 nodeAddr: alloy::sol_types::private::Address,
3854 ) -> alloy_contract::SolCallBuilder<&P, deregisterNodeBySafeCall, N> {
3855 self.call_builder(
3856 &deregisterNodeBySafeCall {
3857 nodeAddr,
3858 },
3859 )
3860 }
3861 pub fn domainSeparator(
3863 &self,
3864 ) -> alloy_contract::SolCallBuilder<&P, domainSeparatorCall, N> {
3865 self.call_builder(&domainSeparatorCall)
3866 }
3867 pub fn isNodeSafeRegistered(
3869 &self,
3870 safeAddress: alloy::sol_types::private::Address,
3871 nodeChainKeyAddress: alloy::sol_types::private::Address,
3872 ) -> alloy_contract::SolCallBuilder<&P, isNodeSafeRegisteredCall, N> {
3873 self.call_builder(
3874 &isNodeSafeRegisteredCall {
3875 safeAddress,
3876 nodeChainKeyAddress,
3877 },
3878 )
3879 }
3880 pub fn nodeSigNonce(
3882 &self,
3883 nodeAddress: alloy::sol_types::private::Address,
3884 ) -> alloy_contract::SolCallBuilder<&P, nodeSigNonceCall, N> {
3885 self.call_builder(&nodeSigNonceCall { nodeAddress })
3886 }
3887 pub fn nodeToSafe(
3889 &self,
3890 nodeAddress: alloy::sol_types::private::Address,
3891 ) -> alloy_contract::SolCallBuilder<&P, nodeToSafeCall, N> {
3892 self.call_builder(&nodeToSafeCall { nodeAddress })
3893 }
3894 pub fn registerSafeByNode(
3896 &self,
3897 safeAddr: alloy::sol_types::private::Address,
3898 ) -> alloy_contract::SolCallBuilder<&P, registerSafeByNodeCall, N> {
3899 self.call_builder(®isterSafeByNodeCall { safeAddr })
3900 }
3901 pub fn registerSafeWithNodeSig(
3903 &self,
3904 safeAddress: alloy::sol_types::private::Address,
3905 nodeChainKeyAddress: alloy::sol_types::private::Address,
3906 sig: alloy::sol_types::private::Bytes,
3907 ) -> alloy_contract::SolCallBuilder<&P, registerSafeWithNodeSigCall, N> {
3908 self.call_builder(
3909 ®isterSafeWithNodeSigCall {
3910 safeAddress,
3911 nodeChainKeyAddress,
3912 sig,
3913 },
3914 )
3915 }
3916 pub fn updateDomainSeparator(
3918 &self,
3919 ) -> alloy_contract::SolCallBuilder<&P, updateDomainSeparatorCall, N> {
3920 self.call_builder(&updateDomainSeparatorCall)
3921 }
3922 }
3923 #[automatically_derived]
3925 impl<
3926 P: alloy_contract::private::Provider<N>,
3927 N: alloy_contract::private::Network,
3928 > HoprNodeSafeRegistryInstance<P, N> {
3929 pub fn event_filter<E: alloy_sol_types::SolEvent>(
3934 &self,
3935 ) -> alloy_contract::Event<&P, E, N> {
3936 alloy_contract::Event::new_sol(&self.provider, &self.address)
3937 }
3938 pub fn DergisteredNodeSafe_filter(
3940 &self,
3941 ) -> alloy_contract::Event<&P, DergisteredNodeSafe, N> {
3942 self.event_filter::<DergisteredNodeSafe>()
3943 }
3944 pub fn DomainSeparatorUpdated_filter(
3946 &self,
3947 ) -> alloy_contract::Event<&P, DomainSeparatorUpdated, N> {
3948 self.event_filter::<DomainSeparatorUpdated>()
3949 }
3950 pub fn RegisteredNodeSafe_filter(
3952 &self,
3953 ) -> alloy_contract::Event<&P, RegisteredNodeSafe, N> {
3954 self.event_filter::<RegisteredNodeSafe>()
3955 }
3956 }
3957}