1#[allow(
311 non_camel_case_types,
312 non_snake_case,
313 clippy::pub_underscore_fields,
314 clippy::style,
315 clippy::empty_structs_with_brackets
316)]
317pub mod HoprAnnouncements {
318 use super::*;
319 use alloy::sol_types as alloy_sol_types;
320 #[rustfmt::skip]
326 #[allow(clippy::all)]
327 pub static BYTECODE: alloy_sol_types::private::Bytes = alloy_sol_types::private::Bytes::from_static(
328 b"`\x80`@R`\0\x80T`\xFF`\xA0\x1B\x19\x16\x90U4\x80\x15a\0\x1DW`\0\x80\xFD[P`@Qa\x10\xF78\x03\x80a\x10\xF7\x839\x81\x01`@\x81\x90Ra\0<\x91a\0\xC5V[a\0E\x81a\0KV[Pa\0\xF5V[`\0T`\x01`\xA0\x1B\x90\x04`\xFF\x16\x15a\0uW`@Qb\xDC\x14\x9F`\xE4\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`\x01`\x01`\xA0\x1B\x03\x81\x16a\0\x9CW`@QcGN\xBE/`\xE1\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`\0\x80T`\x01`\x01`\xA0\x1B\x03\x90\x92\x16`\x01`\x01`\xA8\x1B\x03\x19\x90\x92\x16\x91\x90\x91\x17`\x01`\xA0\x1B\x17\x90UV[`\0` \x82\x84\x03\x12\x15a\0\xD7W`\0\x80\xFD[\x81Q`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14a\0\xEEW`\0\x80\xFD[\x93\x92PPPV[a\x0F\xF3\x80a\x01\x04`\09`\0\xF3\xFE`\x80`@R4\x80\x15a\0\x10W`\0\x80\xFD[P`\x046\x10a\0\x93W`\x005`\xE0\x1C\x80c\xDB\xB9\x8D\x91\x11a\0fW\x80c\xDB\xB9\x8D\x91\x14a\0\xF1W\x80c\xDD\xB9\xDF\xC1\x14a\x01\x04W\x80c\xEA\nR7\x14a\x01\x17W\x80c\xF8\x84\xA9\xCB\x14a\x01*W\x80c\xFA\xD0\xE5\xA2\x14a\x01=W`\0\x80\xFD[\x80c0\x8Cq.\x14a\0\x98W\x80c\xAC\x96P\xD8\x14a\0\xADW\x80c\xB6T\x9Fu\x14a\0\xD6W\x80c\xCA\xE2\xB44\x14a\0\xDEW[`\0\x80\xFD[a\0\xABa\0\xA66`\x04a\x0B\x11V[a\x01PV[\0[a\0\xC0a\0\xBB6`\x04a\x0B.V[a\x02\x1EV[`@Qa\0\xCD\x91\x90a\x0B\xF3V[`@Q\x80\x91\x03\x90\xF3[a\0\xABa\x03\x13V[a\0\xABa\0\xEC6`\x04a\x0CUV[a\x03\xDCV[a\0\xABa\0\xFF6`\x04a\x0C\x90V[a\x04\xB0V[a\0\xABa\x01\x126`\x04a\r\x05V[a\x05\x7FV[a\0\xABa\x01%6`\x04a\rxV[a\x06`V[a\0\xABa\x0186`\x04a\r\xBAV[a\x07)V[a\0\xABa\x01K6`\x04a\x0E\x1BV[a\x07\xFEV[`\0T\x81\x90`\x01`\xA0\x1B\x90\x04`\xFF\x16a\x01|W`@Qc\x08\xA9D\x19`\xE3\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`\0T`@Qc\x02&^1`\xE6\x1B\x81R`\x01`\x01`\xA0\x1B\x03\x83\x81\x16`\x04\x83\x01R3\x92\x16\x90c\x89\x97\x8C@\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x01\xC6W=`\0\x80>=`\0\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x01\xEA\x91\x90a\x0EpV[`\x01`\x01`\xA0\x1B\x03\x16\x14a\x02\x11W`@Qc\xAC\xD5\xA8#`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a\x02\x1A\x82a\x08\xD0V[PPV[``\x81g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x029Wa\x029a\x0E\x8DV[`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15a\x02lW\x81` \x01[``\x81R` \x01\x90`\x01\x90\x03\x90\x81a\x02WW\x90P[P\x90P`\0[\x82\x81\x10\x15a\x03\x0CWa\x02\xDC0\x85\x85\x84\x81\x81\x10a\x02\x90Wa\x02\x90a\x0E\xA3V[\x90P` \x02\x81\x01\x90a\x02\xA2\x91\x90a\x0E\xB9V[\x80\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x93\x92\x91\x90\x81\x81R` \x01\x83\x83\x80\x82\x847`\0\x92\x01\x91\x90\x91RPa\t\x0F\x92PPPV[\x82\x82\x81Q\x81\x10a\x02\xEEWa\x02\xEEa\x0E\xA3V[` \x02` \x01\x01\x81\x90RP\x80\x80a\x03\x04\x90a\x0F\0V[\x91PPa\x02rV[P\x92\x91PPV[`\0T`\x01`\xA0\x1B\x90\x04`\xFF\x16a\x03=W`@Qc\x08\xA9D\x19`\xE3\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`\0\x80T`@Qc\x02&^1`\xE6\x1B\x81R3`\x04\x82\x01R`\x01`\x01`\xA0\x1B\x03\x90\x91\x16\x90c\x89\x97\x8C@\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x03\x86W=`\0\x80>=`\0\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x03\xAA\x91\x90a\x0EpV[`\x01`\x01`\xA0\x1B\x03\x16\x14a\x03\xD1W`@Qc\xAC\xD5\xA8#`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a\x03\xDA3a\x08\xD0V[V[`\0T\x84\x90`\x01`\xA0\x1B\x90\x04`\xFF\x16a\x04\x08W`@Qc\x08\xA9D\x19`\xE3\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`\0T`@Qc\x02&^1`\xE6\x1B\x81R`\x01`\x01`\xA0\x1B\x03\x83\x81\x16`\x04\x83\x01R3\x92\x16\x90c\x89\x97\x8C@\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x04RW=`\0\x80>=`\0\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x04v\x91\x90a\x0EpV[`\x01`\x01`\xA0\x1B\x03\x16\x14a\x04\x9DW`@Qc\xAC\xD5\xA8#`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a\x04\xA9\x85\x85\x85\x85a\t;V[PPPPPV[`\0T`\x01`\xA0\x1B\x90\x04`\xFF\x16a\x04\xDAW`@Qc\x08\xA9D\x19`\xE3\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`\0\x80T`@Qc\x02&^1`\xE6\x1B\x81R3`\x04\x82\x01R`\x01`\x01`\xA0\x1B\x03\x90\x91\x16\x90c\x89\x97\x8C@\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x05#W=`\0\x80>=`\0\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x05G\x91\x90a\x0EpV[`\x01`\x01`\xA0\x1B\x03\x16\x14a\x05nW`@Qc\xAC\xD5\xA8#`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a\x05z3\x84\x84\x84a\t;V[PPPV[`\0T\x86\x90`\x01`\xA0\x1B\x90\x04`\xFF\x16a\x05\xABW`@Qc\x08\xA9D\x19`\xE3\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`\0T`@Qc\x02&^1`\xE6\x1B\x81R`\x01`\x01`\xA0\x1B\x03\x83\x81\x16`\x04\x83\x01R3\x92\x16\x90c\x89\x97\x8C@\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x05\xF5W=`\0\x80>=`\0\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x06\x19\x91\x90a\x0EpV[`\x01`\x01`\xA0\x1B\x03\x16\x14a\x06@W`@Qc\xAC\xD5\xA8#`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a\x06L\x87\x87\x87\x87a\t;V[a\x06W\x87\x84\x84a\t\x91V[PPPPPPPV[`\0T`\x01`\xA0\x1B\x90\x04`\xFF\x16a\x06\x8AW`@Qc\x08\xA9D\x19`\xE3\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`\0\x80T`@Qc\x02&^1`\xE6\x1B\x81R3`\x04\x82\x01R`\x01`\x01`\xA0\x1B\x03\x90\x91\x16\x90c\x89\x97\x8C@\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x06\xD3W=`\0\x80>=`\0\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x06\xF7\x91\x90a\x0EpV[`\x01`\x01`\xA0\x1B\x03\x16\x14a\x07\x1EW`@Qc\xAC\xD5\xA8#`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a\x02\x1A3\x83\x83a\t\x91V[`\0T`\x01`\xA0\x1B\x90\x04`\xFF\x16a\x07SW`@Qc\x08\xA9D\x19`\xE3\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`\0\x80T`@Qc\x02&^1`\xE6\x1B\x81R3`\x04\x82\x01R`\x01`\x01`\xA0\x1B\x03\x90\x91\x16\x90c\x89\x97\x8C@\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x07\x9CW=`\0\x80>=`\0\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x07\xC0\x91\x90a\x0EpV[`\x01`\x01`\xA0\x1B\x03\x16\x14a\x07\xE7W`@Qc\xAC\xD5\xA8#`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a\x07\xF33\x86\x86\x86a\t;V[a\x04\xA93\x83\x83a\t\x91V[`\0T\x83\x90`\x01`\xA0\x1B\x90\x04`\xFF\x16a\x08*W`@Qc\x08\xA9D\x19`\xE3\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`\0T`@Qc\x02&^1`\xE6\x1B\x81R`\x01`\x01`\xA0\x1B\x03\x83\x81\x16`\x04\x83\x01R3\x92\x16\x90c\x89\x97\x8C@\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x08tW=`\0\x80>=`\0\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x08\x98\x91\x90a\x0EpV[`\x01`\x01`\xA0\x1B\x03\x16\x14a\x08\xBFW`@Qc\xAC\xD5\xA8#`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a\x08\xCA\x84\x84\x84a\t\x91V[PPPPV[`@Q`\x01`\x01`\xA0\x1B\x03\x82\x16\x81R\x7F\xA4\xDE0\xA5(\xBE\xCA\xDF\x82d\x9D\x13\x95\xC0\xE3\r\xD1\x8A\xE3[Z\x96\xCEq\xE9)[\xB1K\xC9\xF3\xBC\x90` \x01`@Q\x80\x91\x03\x90\xA1PV[``a\t4\x83\x83`@Q\x80``\x01`@R\x80`'\x81R` \x01a\x0F\x97`'\x919a\t\xD1V[\x93\x92PPPV[`@\x80Q\x84\x81R` \x81\x01\x84\x90R\x90\x81\x01\x82\x90R`\x01`\x01`\xA0\x1B\x03\x85\x16``\x82\x01R\x7F\xBFI\xCC\xD4\x1AA\x18\xC7\xE1\xE7!C\xBA\xD8D\xE5\xF6\xED\x12\xBF`\xCA\xA6B\xD8\x8D\x19\xCA\x10$L6\x90`\x80\x01`@Q\x80\x91\x03\x90\xA1PPPPV[\x7F\xC4\xDF[\xA1h\x14\x83\x8A\xB2a\x88)\xD6\x8F\x86#\xBB\x89s\x02\xF2M\xBD\xBA\"y\xDB\xE4Z\xDB=\x14\x83\x83\x83`@Qa\t\xC4\x93\x92\x91\x90a\x0F'V[`@Q\x80\x91\x03\x90\xA1PPPV[```\0\x80\x85`\x01`\x01`\xA0\x1B\x03\x16\x85`@Qa\t\xEE\x91\x90a\x0FgV[`\0`@Q\x80\x83\x03\x81\x85Z\xF4\x91PP=\x80`\0\x81\x14a\n)W`@Q\x91P`\x1F\x19`?=\x01\x16\x82\x01`@R=\x82R=`\0` \x84\x01>a\n.V[``\x91P[P\x91P\x91Pa\n?\x86\x83\x83\x87a\nIV[\x96\x95PPPPPPV[``\x83\x15a\n\xBDW\x82Q`\0\x03a\n\xB6W`\x01`\x01`\xA0\x1B\x03\x85\x16;a\n\xB6W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1D`$\x82\x01R\x7FAddress: call to non-contract\0\0\0`D\x82\x01R`d\x01[`@Q\x80\x91\x03\x90\xFD[P\x81a\n\xC7V[a\n\xC7\x83\x83a\n\xCFV[\x94\x93PPPPV[\x81Q\x15a\n\xDFW\x81Q\x80\x83` \x01\xFD[\x80`@QbF\x1B\xCD`\xE5\x1B\x81R`\x04\x01a\n\xAD\x91\x90a\x0F\x83V[`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14a\x0B\x0EW`\0\x80\xFD[PV[`\0` \x82\x84\x03\x12\x15a\x0B#W`\0\x80\xFD[\x815a\t4\x81a\n\xF9V[`\0\x80` \x83\x85\x03\x12\x15a\x0BAW`\0\x80\xFD[\x825g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x82\x11\x15a\x0BYW`\0\x80\xFD[\x81\x85\x01\x91P\x85`\x1F\x83\x01\x12a\x0BmW`\0\x80\xFD[\x815\x81\x81\x11\x15a\x0B|W`\0\x80\xFD[\x86` \x82`\x05\x1B\x85\x01\x01\x11\x15a\x0B\x91W`\0\x80\xFD[` \x92\x90\x92\x01\x96\x91\x95P\x90\x93PPPPV[`\0[\x83\x81\x10\x15a\x0B\xBEW\x81\x81\x01Q\x83\x82\x01R` \x01a\x0B\xA6V[PP`\0\x91\x01RV[`\0\x81Q\x80\x84Ra\x0B\xDF\x81` \x86\x01` \x86\x01a\x0B\xA3V[`\x1F\x01`\x1F\x19\x16\x92\x90\x92\x01` \x01\x92\x91PPV[`\0` \x80\x83\x01\x81\x84R\x80\x85Q\x80\x83R`@\x86\x01\x91P`@\x81`\x05\x1B\x87\x01\x01\x92P\x83\x87\x01`\0[\x82\x81\x10\x15a\x0CHW`?\x19\x88\x86\x03\x01\x84Ra\x0C6\x85\x83Qa\x0B\xC7V[\x94P\x92\x85\x01\x92\x90\x85\x01\x90`\x01\x01a\x0C\x1AV[P\x92\x97\x96PPPPPPPV[`\0\x80`\0\x80`\x80\x85\x87\x03\x12\x15a\x0CkW`\0\x80\xFD[\x845a\x0Cv\x81a\n\xF9V[\x96` \x86\x015\x96P`@\x86\x015\x95``\x015\x94P\x92PPPV[`\0\x80`\0``\x84\x86\x03\x12\x15a\x0C\xA5W`\0\x80\xFD[PP\x815\x93` \x83\x015\x93P`@\x90\x92\x015\x91\x90PV[`\0\x80\x83`\x1F\x84\x01\x12a\x0C\xCEW`\0\x80\xFD[P\x815g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x0C\xE6W`\0\x80\xFD[` \x83\x01\x91P\x83` \x82\x85\x01\x01\x11\x15a\x0C\xFEW`\0\x80\xFD[\x92P\x92\x90PV[`\0\x80`\0\x80`\0\x80`\xA0\x87\x89\x03\x12\x15a\r\x1EW`\0\x80\xFD[\x865a\r)\x81a\n\xF9V[\x95P` \x87\x015\x94P`@\x87\x015\x93P``\x87\x015\x92P`\x80\x87\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\rZW`\0\x80\xFD[a\rf\x89\x82\x8A\x01a\x0C\xBCV[\x97\x9A\x96\x99P\x94\x97P\x92\x95\x93\x94\x92PPPV[`\0\x80` \x83\x85\x03\x12\x15a\r\x8BW`\0\x80\xFD[\x825g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\r\xA2W`\0\x80\xFD[a\r\xAE\x85\x82\x86\x01a\x0C\xBCV[\x90\x96\x90\x95P\x93PPPPV[`\0\x80`\0\x80`\0`\x80\x86\x88\x03\x12\x15a\r\xD2W`\0\x80\xFD[\x855\x94P` \x86\x015\x93P`@\x86\x015\x92P``\x86\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\r\xFEW`\0\x80\xFD[a\x0E\n\x88\x82\x89\x01a\x0C\xBCV[\x96\x99\x95\x98P\x93\x96P\x92\x94\x93\x92PPPV[`\0\x80`\0`@\x84\x86\x03\x12\x15a\x0E0W`\0\x80\xFD[\x835a\x0E;\x81a\n\xF9V[\x92P` \x84\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x0EWW`\0\x80\xFD[a\x0Ec\x86\x82\x87\x01a\x0C\xBCV[\x94\x97\x90\x96P\x93\x94PPPPV[`\0` \x82\x84\x03\x12\x15a\x0E\x82W`\0\x80\xFD[\x81Qa\t4\x81a\n\xF9V[cNH{q`\xE0\x1B`\0R`A`\x04R`$`\0\xFD[cNH{q`\xE0\x1B`\0R`2`\x04R`$`\0\xFD[`\0\x80\x835`\x1E\x19\x846\x03\x01\x81\x12a\x0E\xD0W`\0\x80\xFD[\x83\x01\x805\x91Pg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x11\x15a\x0E\xEBW`\0\x80\xFD[` \x01\x91P6\x81\x90\x03\x82\x13\x15a\x0C\xFEW`\0\x80\xFD[`\0`\x01\x82\x01a\x0F WcNH{q`\xE0\x1B`\0R`\x11`\x04R`$`\0\xFD[P`\x01\x01\x90V[`\x01`\x01`\xA0\x1B\x03\x84\x16\x81R`@` \x82\x01\x81\x90R\x81\x01\x82\x90R\x81\x83``\x83\x017`\0\x81\x83\x01``\x90\x81\x01\x91\x90\x91R`\x1F\x90\x92\x01`\x1F\x19\x16\x01\x01\x92\x91PPV[`\0\x82Qa\x0Fy\x81\x84` \x87\x01a\x0B\xA3V[\x91\x90\x91\x01\x92\x91PPV[` \x81R`\0a\t4` \x83\x01\x84a\x0B\xC7V\xFEAddress: low-level delegate call failed\xA2dipfsX\"\x12 N\x94\xA7\xA2b\xA0:\x87\xBD\xDA_\xC2Z\x81_,\xB6\xC72k5\\\xB1\xDB\x90b\x0F\\\x8Bt\\qdsolcC\0\x08\x13\x003",
329 );
330 #[rustfmt::skip]
336 #[allow(clippy::all)]
337 pub static DEPLOYED_BYTECODE: alloy_sol_types::private::Bytes = alloy_sol_types::private::Bytes::from_static(
338 b"`\x80`@R4\x80\x15a\0\x10W`\0\x80\xFD[P`\x046\x10a\0\x93W`\x005`\xE0\x1C\x80c\xDB\xB9\x8D\x91\x11a\0fW\x80c\xDB\xB9\x8D\x91\x14a\0\xF1W\x80c\xDD\xB9\xDF\xC1\x14a\x01\x04W\x80c\xEA\nR7\x14a\x01\x17W\x80c\xF8\x84\xA9\xCB\x14a\x01*W\x80c\xFA\xD0\xE5\xA2\x14a\x01=W`\0\x80\xFD[\x80c0\x8Cq.\x14a\0\x98W\x80c\xAC\x96P\xD8\x14a\0\xADW\x80c\xB6T\x9Fu\x14a\0\xD6W\x80c\xCA\xE2\xB44\x14a\0\xDEW[`\0\x80\xFD[a\0\xABa\0\xA66`\x04a\x0B\x11V[a\x01PV[\0[a\0\xC0a\0\xBB6`\x04a\x0B.V[a\x02\x1EV[`@Qa\0\xCD\x91\x90a\x0B\xF3V[`@Q\x80\x91\x03\x90\xF3[a\0\xABa\x03\x13V[a\0\xABa\0\xEC6`\x04a\x0CUV[a\x03\xDCV[a\0\xABa\0\xFF6`\x04a\x0C\x90V[a\x04\xB0V[a\0\xABa\x01\x126`\x04a\r\x05V[a\x05\x7FV[a\0\xABa\x01%6`\x04a\rxV[a\x06`V[a\0\xABa\x0186`\x04a\r\xBAV[a\x07)V[a\0\xABa\x01K6`\x04a\x0E\x1BV[a\x07\xFEV[`\0T\x81\x90`\x01`\xA0\x1B\x90\x04`\xFF\x16a\x01|W`@Qc\x08\xA9D\x19`\xE3\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`\0T`@Qc\x02&^1`\xE6\x1B\x81R`\x01`\x01`\xA0\x1B\x03\x83\x81\x16`\x04\x83\x01R3\x92\x16\x90c\x89\x97\x8C@\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x01\xC6W=`\0\x80>=`\0\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x01\xEA\x91\x90a\x0EpV[`\x01`\x01`\xA0\x1B\x03\x16\x14a\x02\x11W`@Qc\xAC\xD5\xA8#`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a\x02\x1A\x82a\x08\xD0V[PPV[``\x81g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x029Wa\x029a\x0E\x8DV[`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15a\x02lW\x81` \x01[``\x81R` \x01\x90`\x01\x90\x03\x90\x81a\x02WW\x90P[P\x90P`\0[\x82\x81\x10\x15a\x03\x0CWa\x02\xDC0\x85\x85\x84\x81\x81\x10a\x02\x90Wa\x02\x90a\x0E\xA3V[\x90P` \x02\x81\x01\x90a\x02\xA2\x91\x90a\x0E\xB9V[\x80\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x93\x92\x91\x90\x81\x81R` \x01\x83\x83\x80\x82\x847`\0\x92\x01\x91\x90\x91RPa\t\x0F\x92PPPV[\x82\x82\x81Q\x81\x10a\x02\xEEWa\x02\xEEa\x0E\xA3V[` \x02` \x01\x01\x81\x90RP\x80\x80a\x03\x04\x90a\x0F\0V[\x91PPa\x02rV[P\x92\x91PPV[`\0T`\x01`\xA0\x1B\x90\x04`\xFF\x16a\x03=W`@Qc\x08\xA9D\x19`\xE3\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`\0\x80T`@Qc\x02&^1`\xE6\x1B\x81R3`\x04\x82\x01R`\x01`\x01`\xA0\x1B\x03\x90\x91\x16\x90c\x89\x97\x8C@\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x03\x86W=`\0\x80>=`\0\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x03\xAA\x91\x90a\x0EpV[`\x01`\x01`\xA0\x1B\x03\x16\x14a\x03\xD1W`@Qc\xAC\xD5\xA8#`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a\x03\xDA3a\x08\xD0V[V[`\0T\x84\x90`\x01`\xA0\x1B\x90\x04`\xFF\x16a\x04\x08W`@Qc\x08\xA9D\x19`\xE3\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`\0T`@Qc\x02&^1`\xE6\x1B\x81R`\x01`\x01`\xA0\x1B\x03\x83\x81\x16`\x04\x83\x01R3\x92\x16\x90c\x89\x97\x8C@\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x04RW=`\0\x80>=`\0\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x04v\x91\x90a\x0EpV[`\x01`\x01`\xA0\x1B\x03\x16\x14a\x04\x9DW`@Qc\xAC\xD5\xA8#`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a\x04\xA9\x85\x85\x85\x85a\t;V[PPPPPV[`\0T`\x01`\xA0\x1B\x90\x04`\xFF\x16a\x04\xDAW`@Qc\x08\xA9D\x19`\xE3\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`\0\x80T`@Qc\x02&^1`\xE6\x1B\x81R3`\x04\x82\x01R`\x01`\x01`\xA0\x1B\x03\x90\x91\x16\x90c\x89\x97\x8C@\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x05#W=`\0\x80>=`\0\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x05G\x91\x90a\x0EpV[`\x01`\x01`\xA0\x1B\x03\x16\x14a\x05nW`@Qc\xAC\xD5\xA8#`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a\x05z3\x84\x84\x84a\t;V[PPPV[`\0T\x86\x90`\x01`\xA0\x1B\x90\x04`\xFF\x16a\x05\xABW`@Qc\x08\xA9D\x19`\xE3\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`\0T`@Qc\x02&^1`\xE6\x1B\x81R`\x01`\x01`\xA0\x1B\x03\x83\x81\x16`\x04\x83\x01R3\x92\x16\x90c\x89\x97\x8C@\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x05\xF5W=`\0\x80>=`\0\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x06\x19\x91\x90a\x0EpV[`\x01`\x01`\xA0\x1B\x03\x16\x14a\x06@W`@Qc\xAC\xD5\xA8#`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a\x06L\x87\x87\x87\x87a\t;V[a\x06W\x87\x84\x84a\t\x91V[PPPPPPPV[`\0T`\x01`\xA0\x1B\x90\x04`\xFF\x16a\x06\x8AW`@Qc\x08\xA9D\x19`\xE3\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`\0\x80T`@Qc\x02&^1`\xE6\x1B\x81R3`\x04\x82\x01R`\x01`\x01`\xA0\x1B\x03\x90\x91\x16\x90c\x89\x97\x8C@\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x06\xD3W=`\0\x80>=`\0\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x06\xF7\x91\x90a\x0EpV[`\x01`\x01`\xA0\x1B\x03\x16\x14a\x07\x1EW`@Qc\xAC\xD5\xA8#`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a\x02\x1A3\x83\x83a\t\x91V[`\0T`\x01`\xA0\x1B\x90\x04`\xFF\x16a\x07SW`@Qc\x08\xA9D\x19`\xE3\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`\0\x80T`@Qc\x02&^1`\xE6\x1B\x81R3`\x04\x82\x01R`\x01`\x01`\xA0\x1B\x03\x90\x91\x16\x90c\x89\x97\x8C@\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x07\x9CW=`\0\x80>=`\0\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x07\xC0\x91\x90a\x0EpV[`\x01`\x01`\xA0\x1B\x03\x16\x14a\x07\xE7W`@Qc\xAC\xD5\xA8#`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a\x07\xF33\x86\x86\x86a\t;V[a\x04\xA93\x83\x83a\t\x91V[`\0T\x83\x90`\x01`\xA0\x1B\x90\x04`\xFF\x16a\x08*W`@Qc\x08\xA9D\x19`\xE3\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`\0T`@Qc\x02&^1`\xE6\x1B\x81R`\x01`\x01`\xA0\x1B\x03\x83\x81\x16`\x04\x83\x01R3\x92\x16\x90c\x89\x97\x8C@\x90`$\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x08tW=`\0\x80>=`\0\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x08\x98\x91\x90a\x0EpV[`\x01`\x01`\xA0\x1B\x03\x16\x14a\x08\xBFW`@Qc\xAC\xD5\xA8#`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a\x08\xCA\x84\x84\x84a\t\x91V[PPPPV[`@Q`\x01`\x01`\xA0\x1B\x03\x82\x16\x81R\x7F\xA4\xDE0\xA5(\xBE\xCA\xDF\x82d\x9D\x13\x95\xC0\xE3\r\xD1\x8A\xE3[Z\x96\xCEq\xE9)[\xB1K\xC9\xF3\xBC\x90` \x01`@Q\x80\x91\x03\x90\xA1PV[``a\t4\x83\x83`@Q\x80``\x01`@R\x80`'\x81R` \x01a\x0F\x97`'\x919a\t\xD1V[\x93\x92PPPV[`@\x80Q\x84\x81R` \x81\x01\x84\x90R\x90\x81\x01\x82\x90R`\x01`\x01`\xA0\x1B\x03\x85\x16``\x82\x01R\x7F\xBFI\xCC\xD4\x1AA\x18\xC7\xE1\xE7!C\xBA\xD8D\xE5\xF6\xED\x12\xBF`\xCA\xA6B\xD8\x8D\x19\xCA\x10$L6\x90`\x80\x01`@Q\x80\x91\x03\x90\xA1PPPPV[\x7F\xC4\xDF[\xA1h\x14\x83\x8A\xB2a\x88)\xD6\x8F\x86#\xBB\x89s\x02\xF2M\xBD\xBA\"y\xDB\xE4Z\xDB=\x14\x83\x83\x83`@Qa\t\xC4\x93\x92\x91\x90a\x0F'V[`@Q\x80\x91\x03\x90\xA1PPPV[```\0\x80\x85`\x01`\x01`\xA0\x1B\x03\x16\x85`@Qa\t\xEE\x91\x90a\x0FgV[`\0`@Q\x80\x83\x03\x81\x85Z\xF4\x91PP=\x80`\0\x81\x14a\n)W`@Q\x91P`\x1F\x19`?=\x01\x16\x82\x01`@R=\x82R=`\0` \x84\x01>a\n.V[``\x91P[P\x91P\x91Pa\n?\x86\x83\x83\x87a\nIV[\x96\x95PPPPPPV[``\x83\x15a\n\xBDW\x82Q`\0\x03a\n\xB6W`\x01`\x01`\xA0\x1B\x03\x85\x16;a\n\xB6W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1D`$\x82\x01R\x7FAddress: call to non-contract\0\0\0`D\x82\x01R`d\x01[`@Q\x80\x91\x03\x90\xFD[P\x81a\n\xC7V[a\n\xC7\x83\x83a\n\xCFV[\x94\x93PPPPV[\x81Q\x15a\n\xDFW\x81Q\x80\x83` \x01\xFD[\x80`@QbF\x1B\xCD`\xE5\x1B\x81R`\x04\x01a\n\xAD\x91\x90a\x0F\x83V[`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14a\x0B\x0EW`\0\x80\xFD[PV[`\0` \x82\x84\x03\x12\x15a\x0B#W`\0\x80\xFD[\x815a\t4\x81a\n\xF9V[`\0\x80` \x83\x85\x03\x12\x15a\x0BAW`\0\x80\xFD[\x825g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x82\x11\x15a\x0BYW`\0\x80\xFD[\x81\x85\x01\x91P\x85`\x1F\x83\x01\x12a\x0BmW`\0\x80\xFD[\x815\x81\x81\x11\x15a\x0B|W`\0\x80\xFD[\x86` \x82`\x05\x1B\x85\x01\x01\x11\x15a\x0B\x91W`\0\x80\xFD[` \x92\x90\x92\x01\x96\x91\x95P\x90\x93PPPPV[`\0[\x83\x81\x10\x15a\x0B\xBEW\x81\x81\x01Q\x83\x82\x01R` \x01a\x0B\xA6V[PP`\0\x91\x01RV[`\0\x81Q\x80\x84Ra\x0B\xDF\x81` \x86\x01` \x86\x01a\x0B\xA3V[`\x1F\x01`\x1F\x19\x16\x92\x90\x92\x01` \x01\x92\x91PPV[`\0` \x80\x83\x01\x81\x84R\x80\x85Q\x80\x83R`@\x86\x01\x91P`@\x81`\x05\x1B\x87\x01\x01\x92P\x83\x87\x01`\0[\x82\x81\x10\x15a\x0CHW`?\x19\x88\x86\x03\x01\x84Ra\x0C6\x85\x83Qa\x0B\xC7V[\x94P\x92\x85\x01\x92\x90\x85\x01\x90`\x01\x01a\x0C\x1AV[P\x92\x97\x96PPPPPPPV[`\0\x80`\0\x80`\x80\x85\x87\x03\x12\x15a\x0CkW`\0\x80\xFD[\x845a\x0Cv\x81a\n\xF9V[\x96` \x86\x015\x96P`@\x86\x015\x95``\x015\x94P\x92PPPV[`\0\x80`\0``\x84\x86\x03\x12\x15a\x0C\xA5W`\0\x80\xFD[PP\x815\x93` \x83\x015\x93P`@\x90\x92\x015\x91\x90PV[`\0\x80\x83`\x1F\x84\x01\x12a\x0C\xCEW`\0\x80\xFD[P\x815g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x0C\xE6W`\0\x80\xFD[` \x83\x01\x91P\x83` \x82\x85\x01\x01\x11\x15a\x0C\xFEW`\0\x80\xFD[\x92P\x92\x90PV[`\0\x80`\0\x80`\0\x80`\xA0\x87\x89\x03\x12\x15a\r\x1EW`\0\x80\xFD[\x865a\r)\x81a\n\xF9V[\x95P` \x87\x015\x94P`@\x87\x015\x93P``\x87\x015\x92P`\x80\x87\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\rZW`\0\x80\xFD[a\rf\x89\x82\x8A\x01a\x0C\xBCV[\x97\x9A\x96\x99P\x94\x97P\x92\x95\x93\x94\x92PPPV[`\0\x80` \x83\x85\x03\x12\x15a\r\x8BW`\0\x80\xFD[\x825g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\r\xA2W`\0\x80\xFD[a\r\xAE\x85\x82\x86\x01a\x0C\xBCV[\x90\x96\x90\x95P\x93PPPPV[`\0\x80`\0\x80`\0`\x80\x86\x88\x03\x12\x15a\r\xD2W`\0\x80\xFD[\x855\x94P` \x86\x015\x93P`@\x86\x015\x92P``\x86\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\r\xFEW`\0\x80\xFD[a\x0E\n\x88\x82\x89\x01a\x0C\xBCV[\x96\x99\x95\x98P\x93\x96P\x92\x94\x93\x92PPPV[`\0\x80`\0`@\x84\x86\x03\x12\x15a\x0E0W`\0\x80\xFD[\x835a\x0E;\x81a\n\xF9V[\x92P` \x84\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x0EWW`\0\x80\xFD[a\x0Ec\x86\x82\x87\x01a\x0C\xBCV[\x94\x97\x90\x96P\x93\x94PPPPV[`\0` \x82\x84\x03\x12\x15a\x0E\x82W`\0\x80\xFD[\x81Qa\t4\x81a\n\xF9V[cNH{q`\xE0\x1B`\0R`A`\x04R`$`\0\xFD[cNH{q`\xE0\x1B`\0R`2`\x04R`$`\0\xFD[`\0\x80\x835`\x1E\x19\x846\x03\x01\x81\x12a\x0E\xD0W`\0\x80\xFD[\x83\x01\x805\x91Pg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x11\x15a\x0E\xEBW`\0\x80\xFD[` \x01\x91P6\x81\x90\x03\x82\x13\x15a\x0C\xFEW`\0\x80\xFD[`\0`\x01\x82\x01a\x0F WcNH{q`\xE0\x1B`\0R`\x11`\x04R`$`\0\xFD[P`\x01\x01\x90V[`\x01`\x01`\xA0\x1B\x03\x84\x16\x81R`@` \x82\x01\x81\x90R\x81\x01\x82\x90R\x81\x83``\x83\x017`\0\x81\x83\x01``\x90\x81\x01\x91\x90\x91R`\x1F\x90\x92\x01`\x1F\x19\x16\x01\x01\x92\x91PPV[`\0\x82Qa\x0Fy\x81\x84` \x87\x01a\x0B\xA3V[\x91\x90\x91\x01\x92\x91PPV[` \x81R`\0a\t4` \x83\x01\x84a\x0B\xC7V\xFEAddress: low-level delegate call failed\xA2dipfsX\"\x12 N\x94\xA7\xA2b\xA0:\x87\xBD\xDA_\xC2Z\x81_,\xB6\xC72k5\\\xB1\xDB\x90b\x0F\\\x8Bt\\qdsolcC\0\x08\x13\x003",
339 );
340 #[derive(serde::Serialize, serde::Deserialize)]
341 #[derive(Default, Debug, PartialEq, Eq, Hash)]
342 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
347 #[derive(Clone)]
348 pub struct AlreadyInitialized;
349 #[allow(
350 non_camel_case_types,
351 non_snake_case,
352 clippy::pub_underscore_fields,
353 clippy::style
354 )]
355 const _: () = {
356 use alloy::sol_types as alloy_sol_types;
357 #[doc(hidden)]
358 type UnderlyingSolTuple<'a> = ();
359 #[doc(hidden)]
360 type UnderlyingRustTuple<'a> = ();
361 #[cfg(test)]
362 #[allow(dead_code, unreachable_patterns)]
363 fn _type_assertion(
364 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
365 ) {
366 match _t {
367 alloy_sol_types::private::AssertTypeEq::<
368 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
369 >(_) => {}
370 }
371 }
372 #[automatically_derived]
373 #[doc(hidden)]
374 impl ::core::convert::From<AlreadyInitialized> for UnderlyingRustTuple<'_> {
375 fn from(value: AlreadyInitialized) -> Self {
376 ()
377 }
378 }
379 #[automatically_derived]
380 #[doc(hidden)]
381 impl ::core::convert::From<UnderlyingRustTuple<'_>> for AlreadyInitialized {
382 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
383 Self
384 }
385 }
386 #[automatically_derived]
387 impl alloy_sol_types::SolError for AlreadyInitialized {
388 type Parameters<'a> = UnderlyingSolTuple<'a>;
389 type Token<'a> = <Self::Parameters<
390 'a,
391 > as alloy_sol_types::SolType>::Token<'a>;
392 const SIGNATURE: &'static str = "AlreadyInitialized()";
393 const SELECTOR: [u8; 4] = [13u8, 193u8, 73u8, 240u8];
394 #[inline]
395 fn new<'a>(
396 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
397 ) -> Self {
398 tuple.into()
399 }
400 #[inline]
401 fn tokenize(&self) -> Self::Token<'_> {
402 ()
403 }
404 #[inline]
405 fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
406 <Self::Parameters<
407 '_,
408 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
409 .map(Self::new)
410 }
411 }
412 };
413 #[derive(serde::Serialize, serde::Deserialize)]
414 #[derive(Default, Debug, PartialEq, Eq, Hash)]
415 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
420 #[derive(Clone)]
421 pub struct ContractNotResponsible;
422 #[allow(
423 non_camel_case_types,
424 non_snake_case,
425 clippy::pub_underscore_fields,
426 clippy::style
427 )]
428 const _: () = {
429 use alloy::sol_types as alloy_sol_types;
430 #[doc(hidden)]
431 type UnderlyingSolTuple<'a> = ();
432 #[doc(hidden)]
433 type UnderlyingRustTuple<'a> = ();
434 #[cfg(test)]
435 #[allow(dead_code, unreachable_patterns)]
436 fn _type_assertion(
437 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
438 ) {
439 match _t {
440 alloy_sol_types::private::AssertTypeEq::<
441 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
442 >(_) => {}
443 }
444 }
445 #[automatically_derived]
446 #[doc(hidden)]
447 impl ::core::convert::From<ContractNotResponsible> for UnderlyingRustTuple<'_> {
448 fn from(value: ContractNotResponsible) -> Self {
449 ()
450 }
451 }
452 #[automatically_derived]
453 #[doc(hidden)]
454 impl ::core::convert::From<UnderlyingRustTuple<'_>> for ContractNotResponsible {
455 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
456 Self
457 }
458 }
459 #[automatically_derived]
460 impl alloy_sol_types::SolError for ContractNotResponsible {
461 type Parameters<'a> = UnderlyingSolTuple<'a>;
462 type Token<'a> = <Self::Parameters<
463 'a,
464 > as alloy_sol_types::SolType>::Token<'a>;
465 const SIGNATURE: &'static str = "ContractNotResponsible()";
466 const SELECTOR: [u8; 4] = [172u8, 213u8, 168u8, 35u8];
467 #[inline]
468 fn new<'a>(
469 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
470 ) -> Self {
471 tuple.into()
472 }
473 #[inline]
474 fn tokenize(&self) -> Self::Token<'_> {
475 ()
476 }
477 #[inline]
478 fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
479 <Self::Parameters<
480 '_,
481 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
482 .map(Self::new)
483 }
484 }
485 };
486 #[derive(serde::Serialize, serde::Deserialize)]
487 #[derive(Default, Debug, PartialEq, Eq, Hash)]
488 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
493 #[derive(Clone)]
494 pub struct InvalidSafeAddress;
495 #[allow(
496 non_camel_case_types,
497 non_snake_case,
498 clippy::pub_underscore_fields,
499 clippy::style
500 )]
501 const _: () = {
502 use alloy::sol_types as alloy_sol_types;
503 #[doc(hidden)]
504 type UnderlyingSolTuple<'a> = ();
505 #[doc(hidden)]
506 type UnderlyingRustTuple<'a> = ();
507 #[cfg(test)]
508 #[allow(dead_code, unreachable_patterns)]
509 fn _type_assertion(
510 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
511 ) {
512 match _t {
513 alloy_sol_types::private::AssertTypeEq::<
514 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
515 >(_) => {}
516 }
517 }
518 #[automatically_derived]
519 #[doc(hidden)]
520 impl ::core::convert::From<InvalidSafeAddress> for UnderlyingRustTuple<'_> {
521 fn from(value: InvalidSafeAddress) -> Self {
522 ()
523 }
524 }
525 #[automatically_derived]
526 #[doc(hidden)]
527 impl ::core::convert::From<UnderlyingRustTuple<'_>> for InvalidSafeAddress {
528 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
529 Self
530 }
531 }
532 #[automatically_derived]
533 impl alloy_sol_types::SolError for InvalidSafeAddress {
534 type Parameters<'a> = UnderlyingSolTuple<'a>;
535 type Token<'a> = <Self::Parameters<
536 'a,
537 > as alloy_sol_types::SolType>::Token<'a>;
538 const SIGNATURE: &'static str = "InvalidSafeAddress()";
539 const SELECTOR: [u8; 4] = [142u8, 157u8, 124u8, 94u8];
540 #[inline]
541 fn new<'a>(
542 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
543 ) -> Self {
544 tuple.into()
545 }
546 #[inline]
547 fn tokenize(&self) -> Self::Token<'_> {
548 ()
549 }
550 #[inline]
551 fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
552 <Self::Parameters<
553 '_,
554 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
555 .map(Self::new)
556 }
557 }
558 };
559 #[derive(serde::Serialize, serde::Deserialize)]
560 #[derive(Default, Debug, PartialEq, Eq, Hash)]
561 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
566 #[derive(Clone)]
567 pub struct MultiSigUninitialized;
568 #[allow(
569 non_camel_case_types,
570 non_snake_case,
571 clippy::pub_underscore_fields,
572 clippy::style
573 )]
574 const _: () = {
575 use alloy::sol_types as alloy_sol_types;
576 #[doc(hidden)]
577 type UnderlyingSolTuple<'a> = ();
578 #[doc(hidden)]
579 type UnderlyingRustTuple<'a> = ();
580 #[cfg(test)]
581 #[allow(dead_code, unreachable_patterns)]
582 fn _type_assertion(
583 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
584 ) {
585 match _t {
586 alloy_sol_types::private::AssertTypeEq::<
587 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
588 >(_) => {}
589 }
590 }
591 #[automatically_derived]
592 #[doc(hidden)]
593 impl ::core::convert::From<MultiSigUninitialized> for UnderlyingRustTuple<'_> {
594 fn from(value: MultiSigUninitialized) -> Self {
595 ()
596 }
597 }
598 #[automatically_derived]
599 #[doc(hidden)]
600 impl ::core::convert::From<UnderlyingRustTuple<'_>> for MultiSigUninitialized {
601 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
602 Self
603 }
604 }
605 #[automatically_derived]
606 impl alloy_sol_types::SolError for MultiSigUninitialized {
607 type Parameters<'a> = UnderlyingSolTuple<'a>;
608 type Token<'a> = <Self::Parameters<
609 'a,
610 > as alloy_sol_types::SolType>::Token<'a>;
611 const SIGNATURE: &'static str = "MultiSigUninitialized()";
612 const SELECTOR: [u8; 4] = [69u8, 74u8, 32u8, 200u8];
613 #[inline]
614 fn new<'a>(
615 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
616 ) -> Self {
617 tuple.into()
618 }
619 #[inline]
620 fn tokenize(&self) -> Self::Token<'_> {
621 ()
622 }
623 #[inline]
624 fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
625 <Self::Parameters<
626 '_,
627 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
628 .map(Self::new)
629 }
630 }
631 };
632 #[derive(serde::Serialize, serde::Deserialize)]
633 #[derive(Default, Debug, PartialEq, Eq, Hash)]
634 #[allow(
639 non_camel_case_types,
640 non_snake_case,
641 clippy::pub_underscore_fields,
642 clippy::style
643 )]
644 #[derive(Clone)]
645 pub struct AddressAnnouncement {
646 #[allow(missing_docs)]
647 pub node: alloy::sol_types::private::Address,
648 #[allow(missing_docs)]
649 pub baseMultiaddr: alloy::sol_types::private::String,
650 }
651 #[allow(
652 non_camel_case_types,
653 non_snake_case,
654 clippy::pub_underscore_fields,
655 clippy::style
656 )]
657 const _: () = {
658 use alloy::sol_types as alloy_sol_types;
659 #[automatically_derived]
660 impl alloy_sol_types::SolEvent for AddressAnnouncement {
661 type DataTuple<'a> = (
662 alloy::sol_types::sol_data::Address,
663 alloy::sol_types::sol_data::String,
664 );
665 type DataToken<'a> = <Self::DataTuple<
666 'a,
667 > as alloy_sol_types::SolType>::Token<'a>;
668 type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,);
669 const SIGNATURE: &'static str = "AddressAnnouncement(address,string)";
670 const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([
671 196u8, 223u8, 91u8, 161u8, 104u8, 20u8, 131u8, 138u8, 178u8, 97u8, 136u8,
672 41u8, 214u8, 143u8, 134u8, 35u8, 187u8, 137u8, 115u8, 2u8, 242u8, 77u8,
673 189u8, 186u8, 34u8, 121u8, 219u8, 228u8, 90u8, 219u8, 61u8, 20u8,
674 ]);
675 const ANONYMOUS: bool = false;
676 #[allow(unused_variables)]
677 #[inline]
678 fn new(
679 topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
680 data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
681 ) -> Self {
682 Self {
683 node: data.0,
684 baseMultiaddr: data.1,
685 }
686 }
687 #[inline]
688 fn check_signature(
689 topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
690 ) -> alloy_sol_types::Result<()> {
691 if topics.0 != Self::SIGNATURE_HASH {
692 return Err(
693 alloy_sol_types::Error::invalid_event_signature_hash(
694 Self::SIGNATURE,
695 topics.0,
696 Self::SIGNATURE_HASH,
697 ),
698 );
699 }
700 Ok(())
701 }
702 #[inline]
703 fn tokenize_body(&self) -> Self::DataToken<'_> {
704 (
705 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
706 &self.node,
707 ),
708 <alloy::sol_types::sol_data::String as alloy_sol_types::SolType>::tokenize(
709 &self.baseMultiaddr,
710 ),
711 )
712 }
713 #[inline]
714 fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
715 (Self::SIGNATURE_HASH.into(),)
716 }
717 #[inline]
718 fn encode_topics_raw(
719 &self,
720 out: &mut [alloy_sol_types::abi::token::WordToken],
721 ) -> alloy_sol_types::Result<()> {
722 if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
723 return Err(alloy_sol_types::Error::Overrun);
724 }
725 out[0usize] = alloy_sol_types::abi::token::WordToken(
726 Self::SIGNATURE_HASH,
727 );
728 Ok(())
729 }
730 }
731 #[automatically_derived]
732 impl alloy_sol_types::private::IntoLogData for AddressAnnouncement {
733 fn to_log_data(&self) -> alloy_sol_types::private::LogData {
734 From::from(self)
735 }
736 fn into_log_data(self) -> alloy_sol_types::private::LogData {
737 From::from(&self)
738 }
739 }
740 #[automatically_derived]
741 impl From<&AddressAnnouncement> for alloy_sol_types::private::LogData {
742 #[inline]
743 fn from(this: &AddressAnnouncement) -> alloy_sol_types::private::LogData {
744 alloy_sol_types::SolEvent::encode_log_data(this)
745 }
746 }
747 };
748 #[derive(serde::Serialize, serde::Deserialize)]
749 #[derive(Default, Debug, PartialEq, Eq, Hash)]
750 #[allow(
755 non_camel_case_types,
756 non_snake_case,
757 clippy::pub_underscore_fields,
758 clippy::style
759 )]
760 #[derive(Clone)]
761 pub struct KeyBinding {
762 #[allow(missing_docs)]
763 pub ed25519_sig_0: alloy::sol_types::private::FixedBytes<32>,
764 #[allow(missing_docs)]
765 pub ed25519_sig_1: alloy::sol_types::private::FixedBytes<32>,
766 #[allow(missing_docs)]
767 pub ed25519_pub_key: alloy::sol_types::private::FixedBytes<32>,
768 #[allow(missing_docs)]
769 pub chain_key: alloy::sol_types::private::Address,
770 }
771 #[allow(
772 non_camel_case_types,
773 non_snake_case,
774 clippy::pub_underscore_fields,
775 clippy::style
776 )]
777 const _: () = {
778 use alloy::sol_types as alloy_sol_types;
779 #[automatically_derived]
780 impl alloy_sol_types::SolEvent for KeyBinding {
781 type DataTuple<'a> = (
782 alloy::sol_types::sol_data::FixedBytes<32>,
783 alloy::sol_types::sol_data::FixedBytes<32>,
784 alloy::sol_types::sol_data::FixedBytes<32>,
785 alloy::sol_types::sol_data::Address,
786 );
787 type DataToken<'a> = <Self::DataTuple<
788 'a,
789 > as alloy_sol_types::SolType>::Token<'a>;
790 type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,);
791 const SIGNATURE: &'static str = "KeyBinding(bytes32,bytes32,bytes32,address)";
792 const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([
793 191u8, 73u8, 204u8, 212u8, 26u8, 65u8, 24u8, 199u8, 225u8, 231u8, 33u8,
794 67u8, 186u8, 216u8, 68u8, 229u8, 246u8, 237u8, 18u8, 191u8, 96u8, 202u8,
795 166u8, 66u8, 216u8, 141u8, 25u8, 202u8, 16u8, 36u8, 76u8, 54u8,
796 ]);
797 const ANONYMOUS: bool = false;
798 #[allow(unused_variables)]
799 #[inline]
800 fn new(
801 topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
802 data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
803 ) -> Self {
804 Self {
805 ed25519_sig_0: data.0,
806 ed25519_sig_1: data.1,
807 ed25519_pub_key: data.2,
808 chain_key: data.3,
809 }
810 }
811 #[inline]
812 fn check_signature(
813 topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
814 ) -> alloy_sol_types::Result<()> {
815 if topics.0 != Self::SIGNATURE_HASH {
816 return Err(
817 alloy_sol_types::Error::invalid_event_signature_hash(
818 Self::SIGNATURE,
819 topics.0,
820 Self::SIGNATURE_HASH,
821 ),
822 );
823 }
824 Ok(())
825 }
826 #[inline]
827 fn tokenize_body(&self) -> Self::DataToken<'_> {
828 (
829 <alloy::sol_types::sol_data::FixedBytes<
830 32,
831 > as alloy_sol_types::SolType>::tokenize(&self.ed25519_sig_0),
832 <alloy::sol_types::sol_data::FixedBytes<
833 32,
834 > as alloy_sol_types::SolType>::tokenize(&self.ed25519_sig_1),
835 <alloy::sol_types::sol_data::FixedBytes<
836 32,
837 > as alloy_sol_types::SolType>::tokenize(&self.ed25519_pub_key),
838 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
839 &self.chain_key,
840 ),
841 )
842 }
843 #[inline]
844 fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
845 (Self::SIGNATURE_HASH.into(),)
846 }
847 #[inline]
848 fn encode_topics_raw(
849 &self,
850 out: &mut [alloy_sol_types::abi::token::WordToken],
851 ) -> alloy_sol_types::Result<()> {
852 if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
853 return Err(alloy_sol_types::Error::Overrun);
854 }
855 out[0usize] = alloy_sol_types::abi::token::WordToken(
856 Self::SIGNATURE_HASH,
857 );
858 Ok(())
859 }
860 }
861 #[automatically_derived]
862 impl alloy_sol_types::private::IntoLogData for KeyBinding {
863 fn to_log_data(&self) -> alloy_sol_types::private::LogData {
864 From::from(self)
865 }
866 fn into_log_data(self) -> alloy_sol_types::private::LogData {
867 From::from(&self)
868 }
869 }
870 #[automatically_derived]
871 impl From<&KeyBinding> for alloy_sol_types::private::LogData {
872 #[inline]
873 fn from(this: &KeyBinding) -> alloy_sol_types::private::LogData {
874 alloy_sol_types::SolEvent::encode_log_data(this)
875 }
876 }
877 };
878 #[derive(serde::Serialize, serde::Deserialize)]
879 #[derive(Default, Debug, PartialEq, Eq, Hash)]
880 #[allow(
885 non_camel_case_types,
886 non_snake_case,
887 clippy::pub_underscore_fields,
888 clippy::style
889 )]
890 #[derive(Clone)]
891 pub struct RevokeAnnouncement {
892 #[allow(missing_docs)]
893 pub node: alloy::sol_types::private::Address,
894 }
895 #[allow(
896 non_camel_case_types,
897 non_snake_case,
898 clippy::pub_underscore_fields,
899 clippy::style
900 )]
901 const _: () = {
902 use alloy::sol_types as alloy_sol_types;
903 #[automatically_derived]
904 impl alloy_sol_types::SolEvent for RevokeAnnouncement {
905 type DataTuple<'a> = (alloy::sol_types::sol_data::Address,);
906 type DataToken<'a> = <Self::DataTuple<
907 'a,
908 > as alloy_sol_types::SolType>::Token<'a>;
909 type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,);
910 const SIGNATURE: &'static str = "RevokeAnnouncement(address)";
911 const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([
912 164u8, 222u8, 48u8, 165u8, 40u8, 190u8, 202u8, 223u8, 130u8, 100u8,
913 157u8, 19u8, 149u8, 192u8, 227u8, 13u8, 209u8, 138u8, 227u8, 91u8, 90u8,
914 150u8, 206u8, 113u8, 233u8, 41u8, 91u8, 177u8, 75u8, 201u8, 243u8, 188u8,
915 ]);
916 const ANONYMOUS: bool = false;
917 #[allow(unused_variables)]
918 #[inline]
919 fn new(
920 topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
921 data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
922 ) -> Self {
923 Self { node: data.0 }
924 }
925 #[inline]
926 fn check_signature(
927 topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
928 ) -> alloy_sol_types::Result<()> {
929 if topics.0 != Self::SIGNATURE_HASH {
930 return Err(
931 alloy_sol_types::Error::invalid_event_signature_hash(
932 Self::SIGNATURE,
933 topics.0,
934 Self::SIGNATURE_HASH,
935 ),
936 );
937 }
938 Ok(())
939 }
940 #[inline]
941 fn tokenize_body(&self) -> Self::DataToken<'_> {
942 (
943 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
944 &self.node,
945 ),
946 )
947 }
948 #[inline]
949 fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
950 (Self::SIGNATURE_HASH.into(),)
951 }
952 #[inline]
953 fn encode_topics_raw(
954 &self,
955 out: &mut [alloy_sol_types::abi::token::WordToken],
956 ) -> alloy_sol_types::Result<()> {
957 if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
958 return Err(alloy_sol_types::Error::Overrun);
959 }
960 out[0usize] = alloy_sol_types::abi::token::WordToken(
961 Self::SIGNATURE_HASH,
962 );
963 Ok(())
964 }
965 }
966 #[automatically_derived]
967 impl alloy_sol_types::private::IntoLogData for RevokeAnnouncement {
968 fn to_log_data(&self) -> alloy_sol_types::private::LogData {
969 From::from(self)
970 }
971 fn into_log_data(self) -> alloy_sol_types::private::LogData {
972 From::from(&self)
973 }
974 }
975 #[automatically_derived]
976 impl From<&RevokeAnnouncement> for alloy_sol_types::private::LogData {
977 #[inline]
978 fn from(this: &RevokeAnnouncement) -> alloy_sol_types::private::LogData {
979 alloy_sol_types::SolEvent::encode_log_data(this)
980 }
981 }
982 };
983 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
988 #[derive(Clone)]
989 pub struct constructorCall {
990 #[allow(missing_docs)]
991 pub safeRegistry: alloy::sol_types::private::Address,
992 }
993 const _: () = {
994 use alloy::sol_types as alloy_sol_types;
995 {
996 #[doc(hidden)]
997 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
998 #[doc(hidden)]
999 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
1000 #[cfg(test)]
1001 #[allow(dead_code, unreachable_patterns)]
1002 fn _type_assertion(
1003 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1004 ) {
1005 match _t {
1006 alloy_sol_types::private::AssertTypeEq::<
1007 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1008 >(_) => {}
1009 }
1010 }
1011 #[automatically_derived]
1012 #[doc(hidden)]
1013 impl ::core::convert::From<constructorCall> for UnderlyingRustTuple<'_> {
1014 fn from(value: constructorCall) -> Self {
1015 (value.safeRegistry,)
1016 }
1017 }
1018 #[automatically_derived]
1019 #[doc(hidden)]
1020 impl ::core::convert::From<UnderlyingRustTuple<'_>> for constructorCall {
1021 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1022 Self { safeRegistry: tuple.0 }
1023 }
1024 }
1025 }
1026 #[automatically_derived]
1027 impl alloy_sol_types::SolConstructor for constructorCall {
1028 type Parameters<'a> = (alloy::sol_types::sol_data::Address,);
1029 type Token<'a> = <Self::Parameters<
1030 'a,
1031 > as alloy_sol_types::SolType>::Token<'a>;
1032 #[inline]
1033 fn new<'a>(
1034 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
1035 ) -> Self {
1036 tuple.into()
1037 }
1038 #[inline]
1039 fn tokenize(&self) -> Self::Token<'_> {
1040 (
1041 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
1042 &self.safeRegistry,
1043 ),
1044 )
1045 }
1046 }
1047 };
1048 #[derive(serde::Serialize, serde::Deserialize)]
1049 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1050 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1055 #[derive(Clone)]
1056 pub struct announceCall {
1057 #[allow(missing_docs)]
1058 pub baseMultiaddr: alloy::sol_types::private::String,
1059 }
1060 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1062 #[derive(Clone)]
1063 pub struct announceReturn {}
1064 #[allow(
1065 non_camel_case_types,
1066 non_snake_case,
1067 clippy::pub_underscore_fields,
1068 clippy::style
1069 )]
1070 const _: () = {
1071 use alloy::sol_types as alloy_sol_types;
1072 {
1073 #[doc(hidden)]
1074 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::String,);
1075 #[doc(hidden)]
1076 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::String,);
1077 #[cfg(test)]
1078 #[allow(dead_code, unreachable_patterns)]
1079 fn _type_assertion(
1080 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1081 ) {
1082 match _t {
1083 alloy_sol_types::private::AssertTypeEq::<
1084 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1085 >(_) => {}
1086 }
1087 }
1088 #[automatically_derived]
1089 #[doc(hidden)]
1090 impl ::core::convert::From<announceCall> for UnderlyingRustTuple<'_> {
1091 fn from(value: announceCall) -> Self {
1092 (value.baseMultiaddr,)
1093 }
1094 }
1095 #[automatically_derived]
1096 #[doc(hidden)]
1097 impl ::core::convert::From<UnderlyingRustTuple<'_>> for announceCall {
1098 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1099 Self { baseMultiaddr: tuple.0 }
1100 }
1101 }
1102 }
1103 {
1104 #[doc(hidden)]
1105 type UnderlyingSolTuple<'a> = ();
1106 #[doc(hidden)]
1107 type UnderlyingRustTuple<'a> = ();
1108 #[cfg(test)]
1109 #[allow(dead_code, unreachable_patterns)]
1110 fn _type_assertion(
1111 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1112 ) {
1113 match _t {
1114 alloy_sol_types::private::AssertTypeEq::<
1115 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1116 >(_) => {}
1117 }
1118 }
1119 #[automatically_derived]
1120 #[doc(hidden)]
1121 impl ::core::convert::From<announceReturn> for UnderlyingRustTuple<'_> {
1122 fn from(value: announceReturn) -> Self {
1123 ()
1124 }
1125 }
1126 #[automatically_derived]
1127 #[doc(hidden)]
1128 impl ::core::convert::From<UnderlyingRustTuple<'_>> for announceReturn {
1129 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1130 Self {}
1131 }
1132 }
1133 }
1134 impl announceReturn {
1135 fn _tokenize(
1136 &self,
1137 ) -> <announceCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
1138 ()
1139 }
1140 }
1141 #[automatically_derived]
1142 impl alloy_sol_types::SolCall for announceCall {
1143 type Parameters<'a> = (alloy::sol_types::sol_data::String,);
1144 type Token<'a> = <Self::Parameters<
1145 'a,
1146 > as alloy_sol_types::SolType>::Token<'a>;
1147 type Return = announceReturn;
1148 type ReturnTuple<'a> = ();
1149 type ReturnToken<'a> = <Self::ReturnTuple<
1150 'a,
1151 > as alloy_sol_types::SolType>::Token<'a>;
1152 const SIGNATURE: &'static str = "announce(string)";
1153 const SELECTOR: [u8; 4] = [234u8, 10u8, 82u8, 55u8];
1154 #[inline]
1155 fn new<'a>(
1156 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
1157 ) -> Self {
1158 tuple.into()
1159 }
1160 #[inline]
1161 fn tokenize(&self) -> Self::Token<'_> {
1162 (
1163 <alloy::sol_types::sol_data::String as alloy_sol_types::SolType>::tokenize(
1164 &self.baseMultiaddr,
1165 ),
1166 )
1167 }
1168 #[inline]
1169 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
1170 announceReturn::_tokenize(ret)
1171 }
1172 #[inline]
1173 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
1174 <Self::ReturnTuple<
1175 '_,
1176 > as alloy_sol_types::SolType>::abi_decode_sequence(data)
1177 .map(Into::into)
1178 }
1179 #[inline]
1180 fn abi_decode_returns_validate(
1181 data: &[u8],
1182 ) -> alloy_sol_types::Result<Self::Return> {
1183 <Self::ReturnTuple<
1184 '_,
1185 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
1186 .map(Into::into)
1187 }
1188 }
1189 };
1190 #[derive(serde::Serialize, serde::Deserialize)]
1191 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1192 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1197 #[derive(Clone)]
1198 pub struct announceSafeCall {
1199 #[allow(missing_docs)]
1200 pub selfAddress: alloy::sol_types::private::Address,
1201 #[allow(missing_docs)]
1202 pub baseMultiaddr: alloy::sol_types::private::String,
1203 }
1204 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1206 #[derive(Clone)]
1207 pub struct announceSafeReturn {}
1208 #[allow(
1209 non_camel_case_types,
1210 non_snake_case,
1211 clippy::pub_underscore_fields,
1212 clippy::style
1213 )]
1214 const _: () = {
1215 use alloy::sol_types as alloy_sol_types;
1216 {
1217 #[doc(hidden)]
1218 type UnderlyingSolTuple<'a> = (
1219 alloy::sol_types::sol_data::Address,
1220 alloy::sol_types::sol_data::String,
1221 );
1222 #[doc(hidden)]
1223 type UnderlyingRustTuple<'a> = (
1224 alloy::sol_types::private::Address,
1225 alloy::sol_types::private::String,
1226 );
1227 #[cfg(test)]
1228 #[allow(dead_code, unreachable_patterns)]
1229 fn _type_assertion(
1230 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1231 ) {
1232 match _t {
1233 alloy_sol_types::private::AssertTypeEq::<
1234 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1235 >(_) => {}
1236 }
1237 }
1238 #[automatically_derived]
1239 #[doc(hidden)]
1240 impl ::core::convert::From<announceSafeCall> for UnderlyingRustTuple<'_> {
1241 fn from(value: announceSafeCall) -> Self {
1242 (value.selfAddress, value.baseMultiaddr)
1243 }
1244 }
1245 #[automatically_derived]
1246 #[doc(hidden)]
1247 impl ::core::convert::From<UnderlyingRustTuple<'_>> for announceSafeCall {
1248 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1249 Self {
1250 selfAddress: tuple.0,
1251 baseMultiaddr: tuple.1,
1252 }
1253 }
1254 }
1255 }
1256 {
1257 #[doc(hidden)]
1258 type UnderlyingSolTuple<'a> = ();
1259 #[doc(hidden)]
1260 type UnderlyingRustTuple<'a> = ();
1261 #[cfg(test)]
1262 #[allow(dead_code, unreachable_patterns)]
1263 fn _type_assertion(
1264 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1265 ) {
1266 match _t {
1267 alloy_sol_types::private::AssertTypeEq::<
1268 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1269 >(_) => {}
1270 }
1271 }
1272 #[automatically_derived]
1273 #[doc(hidden)]
1274 impl ::core::convert::From<announceSafeReturn> for UnderlyingRustTuple<'_> {
1275 fn from(value: announceSafeReturn) -> Self {
1276 ()
1277 }
1278 }
1279 #[automatically_derived]
1280 #[doc(hidden)]
1281 impl ::core::convert::From<UnderlyingRustTuple<'_>> for announceSafeReturn {
1282 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1283 Self {}
1284 }
1285 }
1286 }
1287 impl announceSafeReturn {
1288 fn _tokenize(
1289 &self,
1290 ) -> <announceSafeCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
1291 ()
1292 }
1293 }
1294 #[automatically_derived]
1295 impl alloy_sol_types::SolCall for announceSafeCall {
1296 type Parameters<'a> = (
1297 alloy::sol_types::sol_data::Address,
1298 alloy::sol_types::sol_data::String,
1299 );
1300 type Token<'a> = <Self::Parameters<
1301 'a,
1302 > as alloy_sol_types::SolType>::Token<'a>;
1303 type Return = announceSafeReturn;
1304 type ReturnTuple<'a> = ();
1305 type ReturnToken<'a> = <Self::ReturnTuple<
1306 'a,
1307 > as alloy_sol_types::SolType>::Token<'a>;
1308 const SIGNATURE: &'static str = "announceSafe(address,string)";
1309 const SELECTOR: [u8; 4] = [250u8, 208u8, 229u8, 162u8];
1310 #[inline]
1311 fn new<'a>(
1312 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
1313 ) -> Self {
1314 tuple.into()
1315 }
1316 #[inline]
1317 fn tokenize(&self) -> Self::Token<'_> {
1318 (
1319 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
1320 &self.selfAddress,
1321 ),
1322 <alloy::sol_types::sol_data::String as alloy_sol_types::SolType>::tokenize(
1323 &self.baseMultiaddr,
1324 ),
1325 )
1326 }
1327 #[inline]
1328 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
1329 announceSafeReturn::_tokenize(ret)
1330 }
1331 #[inline]
1332 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
1333 <Self::ReturnTuple<
1334 '_,
1335 > as alloy_sol_types::SolType>::abi_decode_sequence(data)
1336 .map(Into::into)
1337 }
1338 #[inline]
1339 fn abi_decode_returns_validate(
1340 data: &[u8],
1341 ) -> alloy_sol_types::Result<Self::Return> {
1342 <Self::ReturnTuple<
1343 '_,
1344 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
1345 .map(Into::into)
1346 }
1347 }
1348 };
1349 #[derive(serde::Serialize, serde::Deserialize)]
1350 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1351 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1356 #[derive(Clone)]
1357 pub struct bindKeysCall {
1358 #[allow(missing_docs)]
1359 pub ed25519_sig_0: alloy::sol_types::private::FixedBytes<32>,
1360 #[allow(missing_docs)]
1361 pub ed25519_sig_1: alloy::sol_types::private::FixedBytes<32>,
1362 #[allow(missing_docs)]
1363 pub ed25519_pub_key: alloy::sol_types::private::FixedBytes<32>,
1364 }
1365 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1367 #[derive(Clone)]
1368 pub struct bindKeysReturn {}
1369 #[allow(
1370 non_camel_case_types,
1371 non_snake_case,
1372 clippy::pub_underscore_fields,
1373 clippy::style
1374 )]
1375 const _: () = {
1376 use alloy::sol_types as alloy_sol_types;
1377 {
1378 #[doc(hidden)]
1379 type UnderlyingSolTuple<'a> = (
1380 alloy::sol_types::sol_data::FixedBytes<32>,
1381 alloy::sol_types::sol_data::FixedBytes<32>,
1382 alloy::sol_types::sol_data::FixedBytes<32>,
1383 );
1384 #[doc(hidden)]
1385 type UnderlyingRustTuple<'a> = (
1386 alloy::sol_types::private::FixedBytes<32>,
1387 alloy::sol_types::private::FixedBytes<32>,
1388 alloy::sol_types::private::FixedBytes<32>,
1389 );
1390 #[cfg(test)]
1391 #[allow(dead_code, unreachable_patterns)]
1392 fn _type_assertion(
1393 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1394 ) {
1395 match _t {
1396 alloy_sol_types::private::AssertTypeEq::<
1397 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1398 >(_) => {}
1399 }
1400 }
1401 #[automatically_derived]
1402 #[doc(hidden)]
1403 impl ::core::convert::From<bindKeysCall> for UnderlyingRustTuple<'_> {
1404 fn from(value: bindKeysCall) -> Self {
1405 (value.ed25519_sig_0, value.ed25519_sig_1, value.ed25519_pub_key)
1406 }
1407 }
1408 #[automatically_derived]
1409 #[doc(hidden)]
1410 impl ::core::convert::From<UnderlyingRustTuple<'_>> for bindKeysCall {
1411 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1412 Self {
1413 ed25519_sig_0: tuple.0,
1414 ed25519_sig_1: tuple.1,
1415 ed25519_pub_key: tuple.2,
1416 }
1417 }
1418 }
1419 }
1420 {
1421 #[doc(hidden)]
1422 type UnderlyingSolTuple<'a> = ();
1423 #[doc(hidden)]
1424 type UnderlyingRustTuple<'a> = ();
1425 #[cfg(test)]
1426 #[allow(dead_code, unreachable_patterns)]
1427 fn _type_assertion(
1428 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1429 ) {
1430 match _t {
1431 alloy_sol_types::private::AssertTypeEq::<
1432 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1433 >(_) => {}
1434 }
1435 }
1436 #[automatically_derived]
1437 #[doc(hidden)]
1438 impl ::core::convert::From<bindKeysReturn> for UnderlyingRustTuple<'_> {
1439 fn from(value: bindKeysReturn) -> Self {
1440 ()
1441 }
1442 }
1443 #[automatically_derived]
1444 #[doc(hidden)]
1445 impl ::core::convert::From<UnderlyingRustTuple<'_>> for bindKeysReturn {
1446 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1447 Self {}
1448 }
1449 }
1450 }
1451 impl bindKeysReturn {
1452 fn _tokenize(
1453 &self,
1454 ) -> <bindKeysCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
1455 ()
1456 }
1457 }
1458 #[automatically_derived]
1459 impl alloy_sol_types::SolCall for bindKeysCall {
1460 type Parameters<'a> = (
1461 alloy::sol_types::sol_data::FixedBytes<32>,
1462 alloy::sol_types::sol_data::FixedBytes<32>,
1463 alloy::sol_types::sol_data::FixedBytes<32>,
1464 );
1465 type Token<'a> = <Self::Parameters<
1466 'a,
1467 > as alloy_sol_types::SolType>::Token<'a>;
1468 type Return = bindKeysReturn;
1469 type ReturnTuple<'a> = ();
1470 type ReturnToken<'a> = <Self::ReturnTuple<
1471 'a,
1472 > as alloy_sol_types::SolType>::Token<'a>;
1473 const SIGNATURE: &'static str = "bindKeys(bytes32,bytes32,bytes32)";
1474 const SELECTOR: [u8; 4] = [219u8, 185u8, 141u8, 145u8];
1475 #[inline]
1476 fn new<'a>(
1477 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
1478 ) -> Self {
1479 tuple.into()
1480 }
1481 #[inline]
1482 fn tokenize(&self) -> Self::Token<'_> {
1483 (
1484 <alloy::sol_types::sol_data::FixedBytes<
1485 32,
1486 > as alloy_sol_types::SolType>::tokenize(&self.ed25519_sig_0),
1487 <alloy::sol_types::sol_data::FixedBytes<
1488 32,
1489 > as alloy_sol_types::SolType>::tokenize(&self.ed25519_sig_1),
1490 <alloy::sol_types::sol_data::FixedBytes<
1491 32,
1492 > as alloy_sol_types::SolType>::tokenize(&self.ed25519_pub_key),
1493 )
1494 }
1495 #[inline]
1496 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
1497 bindKeysReturn::_tokenize(ret)
1498 }
1499 #[inline]
1500 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
1501 <Self::ReturnTuple<
1502 '_,
1503 > as alloy_sol_types::SolType>::abi_decode_sequence(data)
1504 .map(Into::into)
1505 }
1506 #[inline]
1507 fn abi_decode_returns_validate(
1508 data: &[u8],
1509 ) -> alloy_sol_types::Result<Self::Return> {
1510 <Self::ReturnTuple<
1511 '_,
1512 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
1513 .map(Into::into)
1514 }
1515 }
1516 };
1517 #[derive(serde::Serialize, serde::Deserialize)]
1518 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1519 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1524 #[derive(Clone)]
1525 pub struct bindKeysAnnounceCall {
1526 #[allow(missing_docs)]
1527 pub ed25519_sig_0: alloy::sol_types::private::FixedBytes<32>,
1528 #[allow(missing_docs)]
1529 pub ed25519_sig_1: alloy::sol_types::private::FixedBytes<32>,
1530 #[allow(missing_docs)]
1531 pub ed25519_pub_key: alloy::sol_types::private::FixedBytes<32>,
1532 #[allow(missing_docs)]
1533 pub baseMultiaddr: alloy::sol_types::private::String,
1534 }
1535 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1537 #[derive(Clone)]
1538 pub struct bindKeysAnnounceReturn {}
1539 #[allow(
1540 non_camel_case_types,
1541 non_snake_case,
1542 clippy::pub_underscore_fields,
1543 clippy::style
1544 )]
1545 const _: () = {
1546 use alloy::sol_types as alloy_sol_types;
1547 {
1548 #[doc(hidden)]
1549 type UnderlyingSolTuple<'a> = (
1550 alloy::sol_types::sol_data::FixedBytes<32>,
1551 alloy::sol_types::sol_data::FixedBytes<32>,
1552 alloy::sol_types::sol_data::FixedBytes<32>,
1553 alloy::sol_types::sol_data::String,
1554 );
1555 #[doc(hidden)]
1556 type UnderlyingRustTuple<'a> = (
1557 alloy::sol_types::private::FixedBytes<32>,
1558 alloy::sol_types::private::FixedBytes<32>,
1559 alloy::sol_types::private::FixedBytes<32>,
1560 alloy::sol_types::private::String,
1561 );
1562 #[cfg(test)]
1563 #[allow(dead_code, unreachable_patterns)]
1564 fn _type_assertion(
1565 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1566 ) {
1567 match _t {
1568 alloy_sol_types::private::AssertTypeEq::<
1569 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1570 >(_) => {}
1571 }
1572 }
1573 #[automatically_derived]
1574 #[doc(hidden)]
1575 impl ::core::convert::From<bindKeysAnnounceCall>
1576 for UnderlyingRustTuple<'_> {
1577 fn from(value: bindKeysAnnounceCall) -> Self {
1578 (
1579 value.ed25519_sig_0,
1580 value.ed25519_sig_1,
1581 value.ed25519_pub_key,
1582 value.baseMultiaddr,
1583 )
1584 }
1585 }
1586 #[automatically_derived]
1587 #[doc(hidden)]
1588 impl ::core::convert::From<UnderlyingRustTuple<'_>>
1589 for bindKeysAnnounceCall {
1590 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1591 Self {
1592 ed25519_sig_0: tuple.0,
1593 ed25519_sig_1: tuple.1,
1594 ed25519_pub_key: tuple.2,
1595 baseMultiaddr: tuple.3,
1596 }
1597 }
1598 }
1599 }
1600 {
1601 #[doc(hidden)]
1602 type UnderlyingSolTuple<'a> = ();
1603 #[doc(hidden)]
1604 type UnderlyingRustTuple<'a> = ();
1605 #[cfg(test)]
1606 #[allow(dead_code, unreachable_patterns)]
1607 fn _type_assertion(
1608 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1609 ) {
1610 match _t {
1611 alloy_sol_types::private::AssertTypeEq::<
1612 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1613 >(_) => {}
1614 }
1615 }
1616 #[automatically_derived]
1617 #[doc(hidden)]
1618 impl ::core::convert::From<bindKeysAnnounceReturn>
1619 for UnderlyingRustTuple<'_> {
1620 fn from(value: bindKeysAnnounceReturn) -> Self {
1621 ()
1622 }
1623 }
1624 #[automatically_derived]
1625 #[doc(hidden)]
1626 impl ::core::convert::From<UnderlyingRustTuple<'_>>
1627 for bindKeysAnnounceReturn {
1628 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1629 Self {}
1630 }
1631 }
1632 }
1633 impl bindKeysAnnounceReturn {
1634 fn _tokenize(
1635 &self,
1636 ) -> <bindKeysAnnounceCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
1637 ()
1638 }
1639 }
1640 #[automatically_derived]
1641 impl alloy_sol_types::SolCall for bindKeysAnnounceCall {
1642 type Parameters<'a> = (
1643 alloy::sol_types::sol_data::FixedBytes<32>,
1644 alloy::sol_types::sol_data::FixedBytes<32>,
1645 alloy::sol_types::sol_data::FixedBytes<32>,
1646 alloy::sol_types::sol_data::String,
1647 );
1648 type Token<'a> = <Self::Parameters<
1649 'a,
1650 > as alloy_sol_types::SolType>::Token<'a>;
1651 type Return = bindKeysAnnounceReturn;
1652 type ReturnTuple<'a> = ();
1653 type ReturnToken<'a> = <Self::ReturnTuple<
1654 'a,
1655 > as alloy_sol_types::SolType>::Token<'a>;
1656 const SIGNATURE: &'static str = "bindKeysAnnounce(bytes32,bytes32,bytes32,string)";
1657 const SELECTOR: [u8; 4] = [248u8, 132u8, 169u8, 203u8];
1658 #[inline]
1659 fn new<'a>(
1660 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
1661 ) -> Self {
1662 tuple.into()
1663 }
1664 #[inline]
1665 fn tokenize(&self) -> Self::Token<'_> {
1666 (
1667 <alloy::sol_types::sol_data::FixedBytes<
1668 32,
1669 > as alloy_sol_types::SolType>::tokenize(&self.ed25519_sig_0),
1670 <alloy::sol_types::sol_data::FixedBytes<
1671 32,
1672 > as alloy_sol_types::SolType>::tokenize(&self.ed25519_sig_1),
1673 <alloy::sol_types::sol_data::FixedBytes<
1674 32,
1675 > as alloy_sol_types::SolType>::tokenize(&self.ed25519_pub_key),
1676 <alloy::sol_types::sol_data::String as alloy_sol_types::SolType>::tokenize(
1677 &self.baseMultiaddr,
1678 ),
1679 )
1680 }
1681 #[inline]
1682 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
1683 bindKeysAnnounceReturn::_tokenize(ret)
1684 }
1685 #[inline]
1686 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
1687 <Self::ReturnTuple<
1688 '_,
1689 > as alloy_sol_types::SolType>::abi_decode_sequence(data)
1690 .map(Into::into)
1691 }
1692 #[inline]
1693 fn abi_decode_returns_validate(
1694 data: &[u8],
1695 ) -> alloy_sol_types::Result<Self::Return> {
1696 <Self::ReturnTuple<
1697 '_,
1698 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
1699 .map(Into::into)
1700 }
1701 }
1702 };
1703 #[derive(serde::Serialize, serde::Deserialize)]
1704 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1705 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1710 #[derive(Clone)]
1711 pub struct bindKeysAnnounceSafeCall {
1712 #[allow(missing_docs)]
1713 pub selfAddress: alloy::sol_types::private::Address,
1714 #[allow(missing_docs)]
1715 pub ed25519_sig_0: alloy::sol_types::private::FixedBytes<32>,
1716 #[allow(missing_docs)]
1717 pub ed25519_sig_1: alloy::sol_types::private::FixedBytes<32>,
1718 #[allow(missing_docs)]
1719 pub ed25519_pub_key: alloy::sol_types::private::FixedBytes<32>,
1720 #[allow(missing_docs)]
1721 pub baseMultiaddr: alloy::sol_types::private::String,
1722 }
1723 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1725 #[derive(Clone)]
1726 pub struct bindKeysAnnounceSafeReturn {}
1727 #[allow(
1728 non_camel_case_types,
1729 non_snake_case,
1730 clippy::pub_underscore_fields,
1731 clippy::style
1732 )]
1733 const _: () = {
1734 use alloy::sol_types as alloy_sol_types;
1735 {
1736 #[doc(hidden)]
1737 type UnderlyingSolTuple<'a> = (
1738 alloy::sol_types::sol_data::Address,
1739 alloy::sol_types::sol_data::FixedBytes<32>,
1740 alloy::sol_types::sol_data::FixedBytes<32>,
1741 alloy::sol_types::sol_data::FixedBytes<32>,
1742 alloy::sol_types::sol_data::String,
1743 );
1744 #[doc(hidden)]
1745 type UnderlyingRustTuple<'a> = (
1746 alloy::sol_types::private::Address,
1747 alloy::sol_types::private::FixedBytes<32>,
1748 alloy::sol_types::private::FixedBytes<32>,
1749 alloy::sol_types::private::FixedBytes<32>,
1750 alloy::sol_types::private::String,
1751 );
1752 #[cfg(test)]
1753 #[allow(dead_code, unreachable_patterns)]
1754 fn _type_assertion(
1755 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1756 ) {
1757 match _t {
1758 alloy_sol_types::private::AssertTypeEq::<
1759 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1760 >(_) => {}
1761 }
1762 }
1763 #[automatically_derived]
1764 #[doc(hidden)]
1765 impl ::core::convert::From<bindKeysAnnounceSafeCall>
1766 for UnderlyingRustTuple<'_> {
1767 fn from(value: bindKeysAnnounceSafeCall) -> Self {
1768 (
1769 value.selfAddress,
1770 value.ed25519_sig_0,
1771 value.ed25519_sig_1,
1772 value.ed25519_pub_key,
1773 value.baseMultiaddr,
1774 )
1775 }
1776 }
1777 #[automatically_derived]
1778 #[doc(hidden)]
1779 impl ::core::convert::From<UnderlyingRustTuple<'_>>
1780 for bindKeysAnnounceSafeCall {
1781 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1782 Self {
1783 selfAddress: tuple.0,
1784 ed25519_sig_0: tuple.1,
1785 ed25519_sig_1: tuple.2,
1786 ed25519_pub_key: tuple.3,
1787 baseMultiaddr: tuple.4,
1788 }
1789 }
1790 }
1791 }
1792 {
1793 #[doc(hidden)]
1794 type UnderlyingSolTuple<'a> = ();
1795 #[doc(hidden)]
1796 type UnderlyingRustTuple<'a> = ();
1797 #[cfg(test)]
1798 #[allow(dead_code, unreachable_patterns)]
1799 fn _type_assertion(
1800 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1801 ) {
1802 match _t {
1803 alloy_sol_types::private::AssertTypeEq::<
1804 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1805 >(_) => {}
1806 }
1807 }
1808 #[automatically_derived]
1809 #[doc(hidden)]
1810 impl ::core::convert::From<bindKeysAnnounceSafeReturn>
1811 for UnderlyingRustTuple<'_> {
1812 fn from(value: bindKeysAnnounceSafeReturn) -> Self {
1813 ()
1814 }
1815 }
1816 #[automatically_derived]
1817 #[doc(hidden)]
1818 impl ::core::convert::From<UnderlyingRustTuple<'_>>
1819 for bindKeysAnnounceSafeReturn {
1820 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1821 Self {}
1822 }
1823 }
1824 }
1825 impl bindKeysAnnounceSafeReturn {
1826 fn _tokenize(
1827 &self,
1828 ) -> <bindKeysAnnounceSafeCall as alloy_sol_types::SolCall>::ReturnToken<
1829 '_,
1830 > {
1831 ()
1832 }
1833 }
1834 #[automatically_derived]
1835 impl alloy_sol_types::SolCall for bindKeysAnnounceSafeCall {
1836 type Parameters<'a> = (
1837 alloy::sol_types::sol_data::Address,
1838 alloy::sol_types::sol_data::FixedBytes<32>,
1839 alloy::sol_types::sol_data::FixedBytes<32>,
1840 alloy::sol_types::sol_data::FixedBytes<32>,
1841 alloy::sol_types::sol_data::String,
1842 );
1843 type Token<'a> = <Self::Parameters<
1844 'a,
1845 > as alloy_sol_types::SolType>::Token<'a>;
1846 type Return = bindKeysAnnounceSafeReturn;
1847 type ReturnTuple<'a> = ();
1848 type ReturnToken<'a> = <Self::ReturnTuple<
1849 'a,
1850 > as alloy_sol_types::SolType>::Token<'a>;
1851 const SIGNATURE: &'static str = "bindKeysAnnounceSafe(address,bytes32,bytes32,bytes32,string)";
1852 const SELECTOR: [u8; 4] = [221u8, 185u8, 223u8, 193u8];
1853 #[inline]
1854 fn new<'a>(
1855 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
1856 ) -> Self {
1857 tuple.into()
1858 }
1859 #[inline]
1860 fn tokenize(&self) -> Self::Token<'_> {
1861 (
1862 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
1863 &self.selfAddress,
1864 ),
1865 <alloy::sol_types::sol_data::FixedBytes<
1866 32,
1867 > as alloy_sol_types::SolType>::tokenize(&self.ed25519_sig_0),
1868 <alloy::sol_types::sol_data::FixedBytes<
1869 32,
1870 > as alloy_sol_types::SolType>::tokenize(&self.ed25519_sig_1),
1871 <alloy::sol_types::sol_data::FixedBytes<
1872 32,
1873 > as alloy_sol_types::SolType>::tokenize(&self.ed25519_pub_key),
1874 <alloy::sol_types::sol_data::String as alloy_sol_types::SolType>::tokenize(
1875 &self.baseMultiaddr,
1876 ),
1877 )
1878 }
1879 #[inline]
1880 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
1881 bindKeysAnnounceSafeReturn::_tokenize(ret)
1882 }
1883 #[inline]
1884 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
1885 <Self::ReturnTuple<
1886 '_,
1887 > as alloy_sol_types::SolType>::abi_decode_sequence(data)
1888 .map(Into::into)
1889 }
1890 #[inline]
1891 fn abi_decode_returns_validate(
1892 data: &[u8],
1893 ) -> alloy_sol_types::Result<Self::Return> {
1894 <Self::ReturnTuple<
1895 '_,
1896 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
1897 .map(Into::into)
1898 }
1899 }
1900 };
1901 #[derive(serde::Serialize, serde::Deserialize)]
1902 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1903 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1908 #[derive(Clone)]
1909 pub struct bindKeysSafeCall {
1910 #[allow(missing_docs)]
1911 pub selfAddress: alloy::sol_types::private::Address,
1912 #[allow(missing_docs)]
1913 pub ed25519_sig_0: alloy::sol_types::private::FixedBytes<32>,
1914 #[allow(missing_docs)]
1915 pub ed25519_sig_1: alloy::sol_types::private::FixedBytes<32>,
1916 #[allow(missing_docs)]
1917 pub ed25519_pub_key: alloy::sol_types::private::FixedBytes<32>,
1918 }
1919 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1921 #[derive(Clone)]
1922 pub struct bindKeysSafeReturn {}
1923 #[allow(
1924 non_camel_case_types,
1925 non_snake_case,
1926 clippy::pub_underscore_fields,
1927 clippy::style
1928 )]
1929 const _: () = {
1930 use alloy::sol_types as alloy_sol_types;
1931 {
1932 #[doc(hidden)]
1933 type UnderlyingSolTuple<'a> = (
1934 alloy::sol_types::sol_data::Address,
1935 alloy::sol_types::sol_data::FixedBytes<32>,
1936 alloy::sol_types::sol_data::FixedBytes<32>,
1937 alloy::sol_types::sol_data::FixedBytes<32>,
1938 );
1939 #[doc(hidden)]
1940 type UnderlyingRustTuple<'a> = (
1941 alloy::sol_types::private::Address,
1942 alloy::sol_types::private::FixedBytes<32>,
1943 alloy::sol_types::private::FixedBytes<32>,
1944 alloy::sol_types::private::FixedBytes<32>,
1945 );
1946 #[cfg(test)]
1947 #[allow(dead_code, unreachable_patterns)]
1948 fn _type_assertion(
1949 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1950 ) {
1951 match _t {
1952 alloy_sol_types::private::AssertTypeEq::<
1953 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1954 >(_) => {}
1955 }
1956 }
1957 #[automatically_derived]
1958 #[doc(hidden)]
1959 impl ::core::convert::From<bindKeysSafeCall> for UnderlyingRustTuple<'_> {
1960 fn from(value: bindKeysSafeCall) -> Self {
1961 (
1962 value.selfAddress,
1963 value.ed25519_sig_0,
1964 value.ed25519_sig_1,
1965 value.ed25519_pub_key,
1966 )
1967 }
1968 }
1969 #[automatically_derived]
1970 #[doc(hidden)]
1971 impl ::core::convert::From<UnderlyingRustTuple<'_>> for bindKeysSafeCall {
1972 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1973 Self {
1974 selfAddress: tuple.0,
1975 ed25519_sig_0: tuple.1,
1976 ed25519_sig_1: tuple.2,
1977 ed25519_pub_key: tuple.3,
1978 }
1979 }
1980 }
1981 }
1982 {
1983 #[doc(hidden)]
1984 type UnderlyingSolTuple<'a> = ();
1985 #[doc(hidden)]
1986 type UnderlyingRustTuple<'a> = ();
1987 #[cfg(test)]
1988 #[allow(dead_code, unreachable_patterns)]
1989 fn _type_assertion(
1990 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1991 ) {
1992 match _t {
1993 alloy_sol_types::private::AssertTypeEq::<
1994 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1995 >(_) => {}
1996 }
1997 }
1998 #[automatically_derived]
1999 #[doc(hidden)]
2000 impl ::core::convert::From<bindKeysSafeReturn> for UnderlyingRustTuple<'_> {
2001 fn from(value: bindKeysSafeReturn) -> Self {
2002 ()
2003 }
2004 }
2005 #[automatically_derived]
2006 #[doc(hidden)]
2007 impl ::core::convert::From<UnderlyingRustTuple<'_>> for bindKeysSafeReturn {
2008 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2009 Self {}
2010 }
2011 }
2012 }
2013 impl bindKeysSafeReturn {
2014 fn _tokenize(
2015 &self,
2016 ) -> <bindKeysSafeCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
2017 ()
2018 }
2019 }
2020 #[automatically_derived]
2021 impl alloy_sol_types::SolCall for bindKeysSafeCall {
2022 type Parameters<'a> = (
2023 alloy::sol_types::sol_data::Address,
2024 alloy::sol_types::sol_data::FixedBytes<32>,
2025 alloy::sol_types::sol_data::FixedBytes<32>,
2026 alloy::sol_types::sol_data::FixedBytes<32>,
2027 );
2028 type Token<'a> = <Self::Parameters<
2029 'a,
2030 > as alloy_sol_types::SolType>::Token<'a>;
2031 type Return = bindKeysSafeReturn;
2032 type ReturnTuple<'a> = ();
2033 type ReturnToken<'a> = <Self::ReturnTuple<
2034 'a,
2035 > as alloy_sol_types::SolType>::Token<'a>;
2036 const SIGNATURE: &'static str = "bindKeysSafe(address,bytes32,bytes32,bytes32)";
2037 const SELECTOR: [u8; 4] = [202u8, 226u8, 180u8, 52u8];
2038 #[inline]
2039 fn new<'a>(
2040 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
2041 ) -> Self {
2042 tuple.into()
2043 }
2044 #[inline]
2045 fn tokenize(&self) -> Self::Token<'_> {
2046 (
2047 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
2048 &self.selfAddress,
2049 ),
2050 <alloy::sol_types::sol_data::FixedBytes<
2051 32,
2052 > as alloy_sol_types::SolType>::tokenize(&self.ed25519_sig_0),
2053 <alloy::sol_types::sol_data::FixedBytes<
2054 32,
2055 > as alloy_sol_types::SolType>::tokenize(&self.ed25519_sig_1),
2056 <alloy::sol_types::sol_data::FixedBytes<
2057 32,
2058 > as alloy_sol_types::SolType>::tokenize(&self.ed25519_pub_key),
2059 )
2060 }
2061 #[inline]
2062 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
2063 bindKeysSafeReturn::_tokenize(ret)
2064 }
2065 #[inline]
2066 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
2067 <Self::ReturnTuple<
2068 '_,
2069 > as alloy_sol_types::SolType>::abi_decode_sequence(data)
2070 .map(Into::into)
2071 }
2072 #[inline]
2073 fn abi_decode_returns_validate(
2074 data: &[u8],
2075 ) -> alloy_sol_types::Result<Self::Return> {
2076 <Self::ReturnTuple<
2077 '_,
2078 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
2079 .map(Into::into)
2080 }
2081 }
2082 };
2083 #[derive(serde::Serialize, serde::Deserialize)]
2084 #[derive(Default, Debug, PartialEq, Eq, Hash)]
2085 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2090 #[derive(Clone)]
2091 pub struct multicallCall {
2092 #[allow(missing_docs)]
2093 pub data: alloy::sol_types::private::Vec<alloy::sol_types::private::Bytes>,
2094 }
2095 #[derive(serde::Serialize, serde::Deserialize)]
2096 #[derive(Default, Debug, PartialEq, Eq, Hash)]
2097 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2099 #[derive(Clone)]
2100 pub struct multicallReturn {
2101 #[allow(missing_docs)]
2102 pub results: alloy::sol_types::private::Vec<alloy::sol_types::private::Bytes>,
2103 }
2104 #[allow(
2105 non_camel_case_types,
2106 non_snake_case,
2107 clippy::pub_underscore_fields,
2108 clippy::style
2109 )]
2110 const _: () = {
2111 use alloy::sol_types as alloy_sol_types;
2112 {
2113 #[doc(hidden)]
2114 type UnderlyingSolTuple<'a> = (
2115 alloy::sol_types::sol_data::Array<alloy::sol_types::sol_data::Bytes>,
2116 );
2117 #[doc(hidden)]
2118 type UnderlyingRustTuple<'a> = (
2119 alloy::sol_types::private::Vec<alloy::sol_types::private::Bytes>,
2120 );
2121 #[cfg(test)]
2122 #[allow(dead_code, unreachable_patterns)]
2123 fn _type_assertion(
2124 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
2125 ) {
2126 match _t {
2127 alloy_sol_types::private::AssertTypeEq::<
2128 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2129 >(_) => {}
2130 }
2131 }
2132 #[automatically_derived]
2133 #[doc(hidden)]
2134 impl ::core::convert::From<multicallCall> for UnderlyingRustTuple<'_> {
2135 fn from(value: multicallCall) -> Self {
2136 (value.data,)
2137 }
2138 }
2139 #[automatically_derived]
2140 #[doc(hidden)]
2141 impl ::core::convert::From<UnderlyingRustTuple<'_>> for multicallCall {
2142 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2143 Self { data: tuple.0 }
2144 }
2145 }
2146 }
2147 {
2148 #[doc(hidden)]
2149 type UnderlyingSolTuple<'a> = (
2150 alloy::sol_types::sol_data::Array<alloy::sol_types::sol_data::Bytes>,
2151 );
2152 #[doc(hidden)]
2153 type UnderlyingRustTuple<'a> = (
2154 alloy::sol_types::private::Vec<alloy::sol_types::private::Bytes>,
2155 );
2156 #[cfg(test)]
2157 #[allow(dead_code, unreachable_patterns)]
2158 fn _type_assertion(
2159 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
2160 ) {
2161 match _t {
2162 alloy_sol_types::private::AssertTypeEq::<
2163 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2164 >(_) => {}
2165 }
2166 }
2167 #[automatically_derived]
2168 #[doc(hidden)]
2169 impl ::core::convert::From<multicallReturn> for UnderlyingRustTuple<'_> {
2170 fn from(value: multicallReturn) -> Self {
2171 (value.results,)
2172 }
2173 }
2174 #[automatically_derived]
2175 #[doc(hidden)]
2176 impl ::core::convert::From<UnderlyingRustTuple<'_>> for multicallReturn {
2177 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2178 Self { results: tuple.0 }
2179 }
2180 }
2181 }
2182 #[automatically_derived]
2183 impl alloy_sol_types::SolCall for multicallCall {
2184 type Parameters<'a> = (
2185 alloy::sol_types::sol_data::Array<alloy::sol_types::sol_data::Bytes>,
2186 );
2187 type Token<'a> = <Self::Parameters<
2188 'a,
2189 > as alloy_sol_types::SolType>::Token<'a>;
2190 type Return = alloy::sol_types::private::Vec<
2191 alloy::sol_types::private::Bytes,
2192 >;
2193 type ReturnTuple<'a> = (
2194 alloy::sol_types::sol_data::Array<alloy::sol_types::sol_data::Bytes>,
2195 );
2196 type ReturnToken<'a> = <Self::ReturnTuple<
2197 'a,
2198 > as alloy_sol_types::SolType>::Token<'a>;
2199 const SIGNATURE: &'static str = "multicall(bytes[])";
2200 const SELECTOR: [u8; 4] = [172u8, 150u8, 80u8, 216u8];
2201 #[inline]
2202 fn new<'a>(
2203 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
2204 ) -> Self {
2205 tuple.into()
2206 }
2207 #[inline]
2208 fn tokenize(&self) -> Self::Token<'_> {
2209 (
2210 <alloy::sol_types::sol_data::Array<
2211 alloy::sol_types::sol_data::Bytes,
2212 > as alloy_sol_types::SolType>::tokenize(&self.data),
2213 )
2214 }
2215 #[inline]
2216 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
2217 (
2218 <alloy::sol_types::sol_data::Array<
2219 alloy::sol_types::sol_data::Bytes,
2220 > as alloy_sol_types::SolType>::tokenize(ret),
2221 )
2222 }
2223 #[inline]
2224 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
2225 <Self::ReturnTuple<
2226 '_,
2227 > as alloy_sol_types::SolType>::abi_decode_sequence(data)
2228 .map(|r| {
2229 let r: multicallReturn = r.into();
2230 r.results
2231 })
2232 }
2233 #[inline]
2234 fn abi_decode_returns_validate(
2235 data: &[u8],
2236 ) -> alloy_sol_types::Result<Self::Return> {
2237 <Self::ReturnTuple<
2238 '_,
2239 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
2240 .map(|r| {
2241 let r: multicallReturn = r.into();
2242 r.results
2243 })
2244 }
2245 }
2246 };
2247 #[derive(serde::Serialize, serde::Deserialize)]
2248 #[derive(Default, Debug, PartialEq, Eq, Hash)]
2249 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2254 #[derive(Clone)]
2255 pub struct revokeCall;
2256 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2258 #[derive(Clone)]
2259 pub struct revokeReturn {}
2260 #[allow(
2261 non_camel_case_types,
2262 non_snake_case,
2263 clippy::pub_underscore_fields,
2264 clippy::style
2265 )]
2266 const _: () = {
2267 use alloy::sol_types as alloy_sol_types;
2268 {
2269 #[doc(hidden)]
2270 type UnderlyingSolTuple<'a> = ();
2271 #[doc(hidden)]
2272 type UnderlyingRustTuple<'a> = ();
2273 #[cfg(test)]
2274 #[allow(dead_code, unreachable_patterns)]
2275 fn _type_assertion(
2276 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
2277 ) {
2278 match _t {
2279 alloy_sol_types::private::AssertTypeEq::<
2280 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2281 >(_) => {}
2282 }
2283 }
2284 #[automatically_derived]
2285 #[doc(hidden)]
2286 impl ::core::convert::From<revokeCall> for UnderlyingRustTuple<'_> {
2287 fn from(value: revokeCall) -> Self {
2288 ()
2289 }
2290 }
2291 #[automatically_derived]
2292 #[doc(hidden)]
2293 impl ::core::convert::From<UnderlyingRustTuple<'_>> for revokeCall {
2294 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2295 Self
2296 }
2297 }
2298 }
2299 {
2300 #[doc(hidden)]
2301 type UnderlyingSolTuple<'a> = ();
2302 #[doc(hidden)]
2303 type UnderlyingRustTuple<'a> = ();
2304 #[cfg(test)]
2305 #[allow(dead_code, unreachable_patterns)]
2306 fn _type_assertion(
2307 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
2308 ) {
2309 match _t {
2310 alloy_sol_types::private::AssertTypeEq::<
2311 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2312 >(_) => {}
2313 }
2314 }
2315 #[automatically_derived]
2316 #[doc(hidden)]
2317 impl ::core::convert::From<revokeReturn> for UnderlyingRustTuple<'_> {
2318 fn from(value: revokeReturn) -> Self {
2319 ()
2320 }
2321 }
2322 #[automatically_derived]
2323 #[doc(hidden)]
2324 impl ::core::convert::From<UnderlyingRustTuple<'_>> for revokeReturn {
2325 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2326 Self {}
2327 }
2328 }
2329 }
2330 impl revokeReturn {
2331 fn _tokenize(
2332 &self,
2333 ) -> <revokeCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
2334 ()
2335 }
2336 }
2337 #[automatically_derived]
2338 impl alloy_sol_types::SolCall for revokeCall {
2339 type Parameters<'a> = ();
2340 type Token<'a> = <Self::Parameters<
2341 'a,
2342 > as alloy_sol_types::SolType>::Token<'a>;
2343 type Return = revokeReturn;
2344 type ReturnTuple<'a> = ();
2345 type ReturnToken<'a> = <Self::ReturnTuple<
2346 'a,
2347 > as alloy_sol_types::SolType>::Token<'a>;
2348 const SIGNATURE: &'static str = "revoke()";
2349 const SELECTOR: [u8; 4] = [182u8, 84u8, 159u8, 117u8];
2350 #[inline]
2351 fn new<'a>(
2352 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
2353 ) -> Self {
2354 tuple.into()
2355 }
2356 #[inline]
2357 fn tokenize(&self) -> Self::Token<'_> {
2358 ()
2359 }
2360 #[inline]
2361 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
2362 revokeReturn::_tokenize(ret)
2363 }
2364 #[inline]
2365 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
2366 <Self::ReturnTuple<
2367 '_,
2368 > as alloy_sol_types::SolType>::abi_decode_sequence(data)
2369 .map(Into::into)
2370 }
2371 #[inline]
2372 fn abi_decode_returns_validate(
2373 data: &[u8],
2374 ) -> alloy_sol_types::Result<Self::Return> {
2375 <Self::ReturnTuple<
2376 '_,
2377 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
2378 .map(Into::into)
2379 }
2380 }
2381 };
2382 #[derive(serde::Serialize, serde::Deserialize)]
2383 #[derive(Default, Debug, PartialEq, Eq, Hash)]
2384 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2389 #[derive(Clone)]
2390 pub struct revokeSafeCall {
2391 #[allow(missing_docs)]
2392 pub selfAddress: alloy::sol_types::private::Address,
2393 }
2394 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2396 #[derive(Clone)]
2397 pub struct revokeSafeReturn {}
2398 #[allow(
2399 non_camel_case_types,
2400 non_snake_case,
2401 clippy::pub_underscore_fields,
2402 clippy::style
2403 )]
2404 const _: () = {
2405 use alloy::sol_types as alloy_sol_types;
2406 {
2407 #[doc(hidden)]
2408 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
2409 #[doc(hidden)]
2410 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
2411 #[cfg(test)]
2412 #[allow(dead_code, unreachable_patterns)]
2413 fn _type_assertion(
2414 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
2415 ) {
2416 match _t {
2417 alloy_sol_types::private::AssertTypeEq::<
2418 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2419 >(_) => {}
2420 }
2421 }
2422 #[automatically_derived]
2423 #[doc(hidden)]
2424 impl ::core::convert::From<revokeSafeCall> for UnderlyingRustTuple<'_> {
2425 fn from(value: revokeSafeCall) -> Self {
2426 (value.selfAddress,)
2427 }
2428 }
2429 #[automatically_derived]
2430 #[doc(hidden)]
2431 impl ::core::convert::From<UnderlyingRustTuple<'_>> for revokeSafeCall {
2432 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2433 Self { selfAddress: tuple.0 }
2434 }
2435 }
2436 }
2437 {
2438 #[doc(hidden)]
2439 type UnderlyingSolTuple<'a> = ();
2440 #[doc(hidden)]
2441 type UnderlyingRustTuple<'a> = ();
2442 #[cfg(test)]
2443 #[allow(dead_code, unreachable_patterns)]
2444 fn _type_assertion(
2445 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
2446 ) {
2447 match _t {
2448 alloy_sol_types::private::AssertTypeEq::<
2449 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2450 >(_) => {}
2451 }
2452 }
2453 #[automatically_derived]
2454 #[doc(hidden)]
2455 impl ::core::convert::From<revokeSafeReturn> for UnderlyingRustTuple<'_> {
2456 fn from(value: revokeSafeReturn) -> Self {
2457 ()
2458 }
2459 }
2460 #[automatically_derived]
2461 #[doc(hidden)]
2462 impl ::core::convert::From<UnderlyingRustTuple<'_>> for revokeSafeReturn {
2463 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2464 Self {}
2465 }
2466 }
2467 }
2468 impl revokeSafeReturn {
2469 fn _tokenize(
2470 &self,
2471 ) -> <revokeSafeCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
2472 ()
2473 }
2474 }
2475 #[automatically_derived]
2476 impl alloy_sol_types::SolCall for revokeSafeCall {
2477 type Parameters<'a> = (alloy::sol_types::sol_data::Address,);
2478 type Token<'a> = <Self::Parameters<
2479 'a,
2480 > as alloy_sol_types::SolType>::Token<'a>;
2481 type Return = revokeSafeReturn;
2482 type ReturnTuple<'a> = ();
2483 type ReturnToken<'a> = <Self::ReturnTuple<
2484 'a,
2485 > as alloy_sol_types::SolType>::Token<'a>;
2486 const SIGNATURE: &'static str = "revokeSafe(address)";
2487 const SELECTOR: [u8; 4] = [48u8, 140u8, 113u8, 46u8];
2488 #[inline]
2489 fn new<'a>(
2490 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
2491 ) -> Self {
2492 tuple.into()
2493 }
2494 #[inline]
2495 fn tokenize(&self) -> Self::Token<'_> {
2496 (
2497 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
2498 &self.selfAddress,
2499 ),
2500 )
2501 }
2502 #[inline]
2503 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
2504 revokeSafeReturn::_tokenize(ret)
2505 }
2506 #[inline]
2507 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
2508 <Self::ReturnTuple<
2509 '_,
2510 > as alloy_sol_types::SolType>::abi_decode_sequence(data)
2511 .map(Into::into)
2512 }
2513 #[inline]
2514 fn abi_decode_returns_validate(
2515 data: &[u8],
2516 ) -> alloy_sol_types::Result<Self::Return> {
2517 <Self::ReturnTuple<
2518 '_,
2519 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
2520 .map(Into::into)
2521 }
2522 }
2523 };
2524 #[derive(serde::Serialize, serde::Deserialize)]
2526 #[derive()]
2527 pub enum HoprAnnouncementsCalls {
2528 #[allow(missing_docs)]
2529 announce(announceCall),
2530 #[allow(missing_docs)]
2531 announceSafe(announceSafeCall),
2532 #[allow(missing_docs)]
2533 bindKeys(bindKeysCall),
2534 #[allow(missing_docs)]
2535 bindKeysAnnounce(bindKeysAnnounceCall),
2536 #[allow(missing_docs)]
2537 bindKeysAnnounceSafe(bindKeysAnnounceSafeCall),
2538 #[allow(missing_docs)]
2539 bindKeysSafe(bindKeysSafeCall),
2540 #[allow(missing_docs)]
2541 multicall(multicallCall),
2542 #[allow(missing_docs)]
2543 revoke(revokeCall),
2544 #[allow(missing_docs)]
2545 revokeSafe(revokeSafeCall),
2546 }
2547 #[automatically_derived]
2548 impl HoprAnnouncementsCalls {
2549 pub const SELECTORS: &'static [[u8; 4usize]] = &[
2556 [48u8, 140u8, 113u8, 46u8],
2557 [172u8, 150u8, 80u8, 216u8],
2558 [182u8, 84u8, 159u8, 117u8],
2559 [202u8, 226u8, 180u8, 52u8],
2560 [219u8, 185u8, 141u8, 145u8],
2561 [221u8, 185u8, 223u8, 193u8],
2562 [234u8, 10u8, 82u8, 55u8],
2563 [248u8, 132u8, 169u8, 203u8],
2564 [250u8, 208u8, 229u8, 162u8],
2565 ];
2566 }
2567 #[automatically_derived]
2568 impl alloy_sol_types::SolInterface for HoprAnnouncementsCalls {
2569 const NAME: &'static str = "HoprAnnouncementsCalls";
2570 const MIN_DATA_LENGTH: usize = 0usize;
2571 const COUNT: usize = 9usize;
2572 #[inline]
2573 fn selector(&self) -> [u8; 4] {
2574 match self {
2575 Self::announce(_) => <announceCall as alloy_sol_types::SolCall>::SELECTOR,
2576 Self::announceSafe(_) => {
2577 <announceSafeCall as alloy_sol_types::SolCall>::SELECTOR
2578 }
2579 Self::bindKeys(_) => <bindKeysCall as alloy_sol_types::SolCall>::SELECTOR,
2580 Self::bindKeysAnnounce(_) => {
2581 <bindKeysAnnounceCall as alloy_sol_types::SolCall>::SELECTOR
2582 }
2583 Self::bindKeysAnnounceSafe(_) => {
2584 <bindKeysAnnounceSafeCall as alloy_sol_types::SolCall>::SELECTOR
2585 }
2586 Self::bindKeysSafe(_) => {
2587 <bindKeysSafeCall as alloy_sol_types::SolCall>::SELECTOR
2588 }
2589 Self::multicall(_) => {
2590 <multicallCall as alloy_sol_types::SolCall>::SELECTOR
2591 }
2592 Self::revoke(_) => <revokeCall as alloy_sol_types::SolCall>::SELECTOR,
2593 Self::revokeSafe(_) => {
2594 <revokeSafeCall as alloy_sol_types::SolCall>::SELECTOR
2595 }
2596 }
2597 }
2598 #[inline]
2599 fn selector_at(i: usize) -> ::core::option::Option<[u8; 4]> {
2600 Self::SELECTORS.get(i).copied()
2601 }
2602 #[inline]
2603 fn valid_selector(selector: [u8; 4]) -> bool {
2604 Self::SELECTORS.binary_search(&selector).is_ok()
2605 }
2606 #[inline]
2607 #[allow(non_snake_case)]
2608 fn abi_decode_raw(
2609 selector: [u8; 4],
2610 data: &[u8],
2611 ) -> alloy_sol_types::Result<Self> {
2612 static DECODE_SHIMS: &[fn(
2613 &[u8],
2614 ) -> alloy_sol_types::Result<HoprAnnouncementsCalls>] = &[
2615 {
2616 fn revokeSafe(
2617 data: &[u8],
2618 ) -> alloy_sol_types::Result<HoprAnnouncementsCalls> {
2619 <revokeSafeCall as alloy_sol_types::SolCall>::abi_decode_raw(
2620 data,
2621 )
2622 .map(HoprAnnouncementsCalls::revokeSafe)
2623 }
2624 revokeSafe
2625 },
2626 {
2627 fn multicall(
2628 data: &[u8],
2629 ) -> alloy_sol_types::Result<HoprAnnouncementsCalls> {
2630 <multicallCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
2631 .map(HoprAnnouncementsCalls::multicall)
2632 }
2633 multicall
2634 },
2635 {
2636 fn revoke(
2637 data: &[u8],
2638 ) -> alloy_sol_types::Result<HoprAnnouncementsCalls> {
2639 <revokeCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
2640 .map(HoprAnnouncementsCalls::revoke)
2641 }
2642 revoke
2643 },
2644 {
2645 fn bindKeysSafe(
2646 data: &[u8],
2647 ) -> alloy_sol_types::Result<HoprAnnouncementsCalls> {
2648 <bindKeysSafeCall as alloy_sol_types::SolCall>::abi_decode_raw(
2649 data,
2650 )
2651 .map(HoprAnnouncementsCalls::bindKeysSafe)
2652 }
2653 bindKeysSafe
2654 },
2655 {
2656 fn bindKeys(
2657 data: &[u8],
2658 ) -> alloy_sol_types::Result<HoprAnnouncementsCalls> {
2659 <bindKeysCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
2660 .map(HoprAnnouncementsCalls::bindKeys)
2661 }
2662 bindKeys
2663 },
2664 {
2665 fn bindKeysAnnounceSafe(
2666 data: &[u8],
2667 ) -> alloy_sol_types::Result<HoprAnnouncementsCalls> {
2668 <bindKeysAnnounceSafeCall as alloy_sol_types::SolCall>::abi_decode_raw(
2669 data,
2670 )
2671 .map(HoprAnnouncementsCalls::bindKeysAnnounceSafe)
2672 }
2673 bindKeysAnnounceSafe
2674 },
2675 {
2676 fn announce(
2677 data: &[u8],
2678 ) -> alloy_sol_types::Result<HoprAnnouncementsCalls> {
2679 <announceCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
2680 .map(HoprAnnouncementsCalls::announce)
2681 }
2682 announce
2683 },
2684 {
2685 fn bindKeysAnnounce(
2686 data: &[u8],
2687 ) -> alloy_sol_types::Result<HoprAnnouncementsCalls> {
2688 <bindKeysAnnounceCall as alloy_sol_types::SolCall>::abi_decode_raw(
2689 data,
2690 )
2691 .map(HoprAnnouncementsCalls::bindKeysAnnounce)
2692 }
2693 bindKeysAnnounce
2694 },
2695 {
2696 fn announceSafe(
2697 data: &[u8],
2698 ) -> alloy_sol_types::Result<HoprAnnouncementsCalls> {
2699 <announceSafeCall as alloy_sol_types::SolCall>::abi_decode_raw(
2700 data,
2701 )
2702 .map(HoprAnnouncementsCalls::announceSafe)
2703 }
2704 announceSafe
2705 },
2706 ];
2707 let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
2708 return Err(
2709 alloy_sol_types::Error::unknown_selector(
2710 <Self as alloy_sol_types::SolInterface>::NAME,
2711 selector,
2712 ),
2713 );
2714 };
2715 DECODE_SHIMS[idx](data)
2716 }
2717 #[inline]
2718 #[allow(non_snake_case)]
2719 fn abi_decode_raw_validate(
2720 selector: [u8; 4],
2721 data: &[u8],
2722 ) -> alloy_sol_types::Result<Self> {
2723 static DECODE_VALIDATE_SHIMS: &[fn(
2724 &[u8],
2725 ) -> alloy_sol_types::Result<HoprAnnouncementsCalls>] = &[
2726 {
2727 fn revokeSafe(
2728 data: &[u8],
2729 ) -> alloy_sol_types::Result<HoprAnnouncementsCalls> {
2730 <revokeSafeCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
2731 data,
2732 )
2733 .map(HoprAnnouncementsCalls::revokeSafe)
2734 }
2735 revokeSafe
2736 },
2737 {
2738 fn multicall(
2739 data: &[u8],
2740 ) -> alloy_sol_types::Result<HoprAnnouncementsCalls> {
2741 <multicallCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
2742 data,
2743 )
2744 .map(HoprAnnouncementsCalls::multicall)
2745 }
2746 multicall
2747 },
2748 {
2749 fn revoke(
2750 data: &[u8],
2751 ) -> alloy_sol_types::Result<HoprAnnouncementsCalls> {
2752 <revokeCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
2753 data,
2754 )
2755 .map(HoprAnnouncementsCalls::revoke)
2756 }
2757 revoke
2758 },
2759 {
2760 fn bindKeysSafe(
2761 data: &[u8],
2762 ) -> alloy_sol_types::Result<HoprAnnouncementsCalls> {
2763 <bindKeysSafeCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
2764 data,
2765 )
2766 .map(HoprAnnouncementsCalls::bindKeysSafe)
2767 }
2768 bindKeysSafe
2769 },
2770 {
2771 fn bindKeys(
2772 data: &[u8],
2773 ) -> alloy_sol_types::Result<HoprAnnouncementsCalls> {
2774 <bindKeysCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
2775 data,
2776 )
2777 .map(HoprAnnouncementsCalls::bindKeys)
2778 }
2779 bindKeys
2780 },
2781 {
2782 fn bindKeysAnnounceSafe(
2783 data: &[u8],
2784 ) -> alloy_sol_types::Result<HoprAnnouncementsCalls> {
2785 <bindKeysAnnounceSafeCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
2786 data,
2787 )
2788 .map(HoprAnnouncementsCalls::bindKeysAnnounceSafe)
2789 }
2790 bindKeysAnnounceSafe
2791 },
2792 {
2793 fn announce(
2794 data: &[u8],
2795 ) -> alloy_sol_types::Result<HoprAnnouncementsCalls> {
2796 <announceCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
2797 data,
2798 )
2799 .map(HoprAnnouncementsCalls::announce)
2800 }
2801 announce
2802 },
2803 {
2804 fn bindKeysAnnounce(
2805 data: &[u8],
2806 ) -> alloy_sol_types::Result<HoprAnnouncementsCalls> {
2807 <bindKeysAnnounceCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
2808 data,
2809 )
2810 .map(HoprAnnouncementsCalls::bindKeysAnnounce)
2811 }
2812 bindKeysAnnounce
2813 },
2814 {
2815 fn announceSafe(
2816 data: &[u8],
2817 ) -> alloy_sol_types::Result<HoprAnnouncementsCalls> {
2818 <announceSafeCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
2819 data,
2820 )
2821 .map(HoprAnnouncementsCalls::announceSafe)
2822 }
2823 announceSafe
2824 },
2825 ];
2826 let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
2827 return Err(
2828 alloy_sol_types::Error::unknown_selector(
2829 <Self as alloy_sol_types::SolInterface>::NAME,
2830 selector,
2831 ),
2832 );
2833 };
2834 DECODE_VALIDATE_SHIMS[idx](data)
2835 }
2836 #[inline]
2837 fn abi_encoded_size(&self) -> usize {
2838 match self {
2839 Self::announce(inner) => {
2840 <announceCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
2841 }
2842 Self::announceSafe(inner) => {
2843 <announceSafeCall as alloy_sol_types::SolCall>::abi_encoded_size(
2844 inner,
2845 )
2846 }
2847 Self::bindKeys(inner) => {
2848 <bindKeysCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
2849 }
2850 Self::bindKeysAnnounce(inner) => {
2851 <bindKeysAnnounceCall as alloy_sol_types::SolCall>::abi_encoded_size(
2852 inner,
2853 )
2854 }
2855 Self::bindKeysAnnounceSafe(inner) => {
2856 <bindKeysAnnounceSafeCall as alloy_sol_types::SolCall>::abi_encoded_size(
2857 inner,
2858 )
2859 }
2860 Self::bindKeysSafe(inner) => {
2861 <bindKeysSafeCall as alloy_sol_types::SolCall>::abi_encoded_size(
2862 inner,
2863 )
2864 }
2865 Self::multicall(inner) => {
2866 <multicallCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
2867 }
2868 Self::revoke(inner) => {
2869 <revokeCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
2870 }
2871 Self::revokeSafe(inner) => {
2872 <revokeSafeCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
2873 }
2874 }
2875 }
2876 #[inline]
2877 fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
2878 match self {
2879 Self::announce(inner) => {
2880 <announceCall as alloy_sol_types::SolCall>::abi_encode_raw(
2881 inner,
2882 out,
2883 )
2884 }
2885 Self::announceSafe(inner) => {
2886 <announceSafeCall as alloy_sol_types::SolCall>::abi_encode_raw(
2887 inner,
2888 out,
2889 )
2890 }
2891 Self::bindKeys(inner) => {
2892 <bindKeysCall as alloy_sol_types::SolCall>::abi_encode_raw(
2893 inner,
2894 out,
2895 )
2896 }
2897 Self::bindKeysAnnounce(inner) => {
2898 <bindKeysAnnounceCall as alloy_sol_types::SolCall>::abi_encode_raw(
2899 inner,
2900 out,
2901 )
2902 }
2903 Self::bindKeysAnnounceSafe(inner) => {
2904 <bindKeysAnnounceSafeCall as alloy_sol_types::SolCall>::abi_encode_raw(
2905 inner,
2906 out,
2907 )
2908 }
2909 Self::bindKeysSafe(inner) => {
2910 <bindKeysSafeCall as alloy_sol_types::SolCall>::abi_encode_raw(
2911 inner,
2912 out,
2913 )
2914 }
2915 Self::multicall(inner) => {
2916 <multicallCall as alloy_sol_types::SolCall>::abi_encode_raw(
2917 inner,
2918 out,
2919 )
2920 }
2921 Self::revoke(inner) => {
2922 <revokeCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
2923 }
2924 Self::revokeSafe(inner) => {
2925 <revokeSafeCall as alloy_sol_types::SolCall>::abi_encode_raw(
2926 inner,
2927 out,
2928 )
2929 }
2930 }
2931 }
2932 }
2933 #[derive(serde::Serialize, serde::Deserialize)]
2935 #[derive(Debug, PartialEq, Eq, Hash)]
2936 pub enum HoprAnnouncementsErrors {
2937 #[allow(missing_docs)]
2938 AlreadyInitialized(AlreadyInitialized),
2939 #[allow(missing_docs)]
2940 ContractNotResponsible(ContractNotResponsible),
2941 #[allow(missing_docs)]
2942 InvalidSafeAddress(InvalidSafeAddress),
2943 #[allow(missing_docs)]
2944 MultiSigUninitialized(MultiSigUninitialized),
2945 }
2946 #[automatically_derived]
2947 impl HoprAnnouncementsErrors {
2948 pub const SELECTORS: &'static [[u8; 4usize]] = &[
2955 [13u8, 193u8, 73u8, 240u8],
2956 [69u8, 74u8, 32u8, 200u8],
2957 [142u8, 157u8, 124u8, 94u8],
2958 [172u8, 213u8, 168u8, 35u8],
2959 ];
2960 }
2961 #[automatically_derived]
2962 impl alloy_sol_types::SolInterface for HoprAnnouncementsErrors {
2963 const NAME: &'static str = "HoprAnnouncementsErrors";
2964 const MIN_DATA_LENGTH: usize = 0usize;
2965 const COUNT: usize = 4usize;
2966 #[inline]
2967 fn selector(&self) -> [u8; 4] {
2968 match self {
2969 Self::AlreadyInitialized(_) => {
2970 <AlreadyInitialized as alloy_sol_types::SolError>::SELECTOR
2971 }
2972 Self::ContractNotResponsible(_) => {
2973 <ContractNotResponsible as alloy_sol_types::SolError>::SELECTOR
2974 }
2975 Self::InvalidSafeAddress(_) => {
2976 <InvalidSafeAddress as alloy_sol_types::SolError>::SELECTOR
2977 }
2978 Self::MultiSigUninitialized(_) => {
2979 <MultiSigUninitialized as alloy_sol_types::SolError>::SELECTOR
2980 }
2981 }
2982 }
2983 #[inline]
2984 fn selector_at(i: usize) -> ::core::option::Option<[u8; 4]> {
2985 Self::SELECTORS.get(i).copied()
2986 }
2987 #[inline]
2988 fn valid_selector(selector: [u8; 4]) -> bool {
2989 Self::SELECTORS.binary_search(&selector).is_ok()
2990 }
2991 #[inline]
2992 #[allow(non_snake_case)]
2993 fn abi_decode_raw(
2994 selector: [u8; 4],
2995 data: &[u8],
2996 ) -> alloy_sol_types::Result<Self> {
2997 static DECODE_SHIMS: &[fn(
2998 &[u8],
2999 ) -> alloy_sol_types::Result<HoprAnnouncementsErrors>] = &[
3000 {
3001 fn AlreadyInitialized(
3002 data: &[u8],
3003 ) -> alloy_sol_types::Result<HoprAnnouncementsErrors> {
3004 <AlreadyInitialized as alloy_sol_types::SolError>::abi_decode_raw(
3005 data,
3006 )
3007 .map(HoprAnnouncementsErrors::AlreadyInitialized)
3008 }
3009 AlreadyInitialized
3010 },
3011 {
3012 fn MultiSigUninitialized(
3013 data: &[u8],
3014 ) -> alloy_sol_types::Result<HoprAnnouncementsErrors> {
3015 <MultiSigUninitialized as alloy_sol_types::SolError>::abi_decode_raw(
3016 data,
3017 )
3018 .map(HoprAnnouncementsErrors::MultiSigUninitialized)
3019 }
3020 MultiSigUninitialized
3021 },
3022 {
3023 fn InvalidSafeAddress(
3024 data: &[u8],
3025 ) -> alloy_sol_types::Result<HoprAnnouncementsErrors> {
3026 <InvalidSafeAddress as alloy_sol_types::SolError>::abi_decode_raw(
3027 data,
3028 )
3029 .map(HoprAnnouncementsErrors::InvalidSafeAddress)
3030 }
3031 InvalidSafeAddress
3032 },
3033 {
3034 fn ContractNotResponsible(
3035 data: &[u8],
3036 ) -> alloy_sol_types::Result<HoprAnnouncementsErrors> {
3037 <ContractNotResponsible as alloy_sol_types::SolError>::abi_decode_raw(
3038 data,
3039 )
3040 .map(HoprAnnouncementsErrors::ContractNotResponsible)
3041 }
3042 ContractNotResponsible
3043 },
3044 ];
3045 let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
3046 return Err(
3047 alloy_sol_types::Error::unknown_selector(
3048 <Self as alloy_sol_types::SolInterface>::NAME,
3049 selector,
3050 ),
3051 );
3052 };
3053 DECODE_SHIMS[idx](data)
3054 }
3055 #[inline]
3056 #[allow(non_snake_case)]
3057 fn abi_decode_raw_validate(
3058 selector: [u8; 4],
3059 data: &[u8],
3060 ) -> alloy_sol_types::Result<Self> {
3061 static DECODE_VALIDATE_SHIMS: &[fn(
3062 &[u8],
3063 ) -> alloy_sol_types::Result<HoprAnnouncementsErrors>] = &[
3064 {
3065 fn AlreadyInitialized(
3066 data: &[u8],
3067 ) -> alloy_sol_types::Result<HoprAnnouncementsErrors> {
3068 <AlreadyInitialized as alloy_sol_types::SolError>::abi_decode_raw_validate(
3069 data,
3070 )
3071 .map(HoprAnnouncementsErrors::AlreadyInitialized)
3072 }
3073 AlreadyInitialized
3074 },
3075 {
3076 fn MultiSigUninitialized(
3077 data: &[u8],
3078 ) -> alloy_sol_types::Result<HoprAnnouncementsErrors> {
3079 <MultiSigUninitialized as alloy_sol_types::SolError>::abi_decode_raw_validate(
3080 data,
3081 )
3082 .map(HoprAnnouncementsErrors::MultiSigUninitialized)
3083 }
3084 MultiSigUninitialized
3085 },
3086 {
3087 fn InvalidSafeAddress(
3088 data: &[u8],
3089 ) -> alloy_sol_types::Result<HoprAnnouncementsErrors> {
3090 <InvalidSafeAddress as alloy_sol_types::SolError>::abi_decode_raw_validate(
3091 data,
3092 )
3093 .map(HoprAnnouncementsErrors::InvalidSafeAddress)
3094 }
3095 InvalidSafeAddress
3096 },
3097 {
3098 fn ContractNotResponsible(
3099 data: &[u8],
3100 ) -> alloy_sol_types::Result<HoprAnnouncementsErrors> {
3101 <ContractNotResponsible as alloy_sol_types::SolError>::abi_decode_raw_validate(
3102 data,
3103 )
3104 .map(HoprAnnouncementsErrors::ContractNotResponsible)
3105 }
3106 ContractNotResponsible
3107 },
3108 ];
3109 let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
3110 return Err(
3111 alloy_sol_types::Error::unknown_selector(
3112 <Self as alloy_sol_types::SolInterface>::NAME,
3113 selector,
3114 ),
3115 );
3116 };
3117 DECODE_VALIDATE_SHIMS[idx](data)
3118 }
3119 #[inline]
3120 fn abi_encoded_size(&self) -> usize {
3121 match self {
3122 Self::AlreadyInitialized(inner) => {
3123 <AlreadyInitialized as alloy_sol_types::SolError>::abi_encoded_size(
3124 inner,
3125 )
3126 }
3127 Self::ContractNotResponsible(inner) => {
3128 <ContractNotResponsible as alloy_sol_types::SolError>::abi_encoded_size(
3129 inner,
3130 )
3131 }
3132 Self::InvalidSafeAddress(inner) => {
3133 <InvalidSafeAddress as alloy_sol_types::SolError>::abi_encoded_size(
3134 inner,
3135 )
3136 }
3137 Self::MultiSigUninitialized(inner) => {
3138 <MultiSigUninitialized as alloy_sol_types::SolError>::abi_encoded_size(
3139 inner,
3140 )
3141 }
3142 }
3143 }
3144 #[inline]
3145 fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
3146 match self {
3147 Self::AlreadyInitialized(inner) => {
3148 <AlreadyInitialized as alloy_sol_types::SolError>::abi_encode_raw(
3149 inner,
3150 out,
3151 )
3152 }
3153 Self::ContractNotResponsible(inner) => {
3154 <ContractNotResponsible as alloy_sol_types::SolError>::abi_encode_raw(
3155 inner,
3156 out,
3157 )
3158 }
3159 Self::InvalidSafeAddress(inner) => {
3160 <InvalidSafeAddress as alloy_sol_types::SolError>::abi_encode_raw(
3161 inner,
3162 out,
3163 )
3164 }
3165 Self::MultiSigUninitialized(inner) => {
3166 <MultiSigUninitialized as alloy_sol_types::SolError>::abi_encode_raw(
3167 inner,
3168 out,
3169 )
3170 }
3171 }
3172 }
3173 }
3174 #[derive(serde::Serialize, serde::Deserialize)]
3176 #[derive(Debug, PartialEq, Eq, Hash)]
3177 pub enum HoprAnnouncementsEvents {
3178 #[allow(missing_docs)]
3179 AddressAnnouncement(AddressAnnouncement),
3180 #[allow(missing_docs)]
3181 KeyBinding(KeyBinding),
3182 #[allow(missing_docs)]
3183 RevokeAnnouncement(RevokeAnnouncement),
3184 }
3185 #[automatically_derived]
3186 impl HoprAnnouncementsEvents {
3187 pub const SELECTORS: &'static [[u8; 32usize]] = &[
3194 [
3195 164u8, 222u8, 48u8, 165u8, 40u8, 190u8, 202u8, 223u8, 130u8, 100u8,
3196 157u8, 19u8, 149u8, 192u8, 227u8, 13u8, 209u8, 138u8, 227u8, 91u8, 90u8,
3197 150u8, 206u8, 113u8, 233u8, 41u8, 91u8, 177u8, 75u8, 201u8, 243u8, 188u8,
3198 ],
3199 [
3200 191u8, 73u8, 204u8, 212u8, 26u8, 65u8, 24u8, 199u8, 225u8, 231u8, 33u8,
3201 67u8, 186u8, 216u8, 68u8, 229u8, 246u8, 237u8, 18u8, 191u8, 96u8, 202u8,
3202 166u8, 66u8, 216u8, 141u8, 25u8, 202u8, 16u8, 36u8, 76u8, 54u8,
3203 ],
3204 [
3205 196u8, 223u8, 91u8, 161u8, 104u8, 20u8, 131u8, 138u8, 178u8, 97u8, 136u8,
3206 41u8, 214u8, 143u8, 134u8, 35u8, 187u8, 137u8, 115u8, 2u8, 242u8, 77u8,
3207 189u8, 186u8, 34u8, 121u8, 219u8, 228u8, 90u8, 219u8, 61u8, 20u8,
3208 ],
3209 ];
3210 }
3211 #[automatically_derived]
3212 impl alloy_sol_types::SolEventInterface for HoprAnnouncementsEvents {
3213 const NAME: &'static str = "HoprAnnouncementsEvents";
3214 const COUNT: usize = 3usize;
3215 fn decode_raw_log(
3216 topics: &[alloy_sol_types::Word],
3217 data: &[u8],
3218 ) -> alloy_sol_types::Result<Self> {
3219 match topics.first().copied() {
3220 Some(
3221 <AddressAnnouncement as alloy_sol_types::SolEvent>::SIGNATURE_HASH,
3222 ) => {
3223 <AddressAnnouncement as alloy_sol_types::SolEvent>::decode_raw_log(
3224 topics,
3225 data,
3226 )
3227 .map(Self::AddressAnnouncement)
3228 }
3229 Some(<KeyBinding as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
3230 <KeyBinding as alloy_sol_types::SolEvent>::decode_raw_log(
3231 topics,
3232 data,
3233 )
3234 .map(Self::KeyBinding)
3235 }
3236 Some(
3237 <RevokeAnnouncement as alloy_sol_types::SolEvent>::SIGNATURE_HASH,
3238 ) => {
3239 <RevokeAnnouncement as alloy_sol_types::SolEvent>::decode_raw_log(
3240 topics,
3241 data,
3242 )
3243 .map(Self::RevokeAnnouncement)
3244 }
3245 _ => {
3246 alloy_sol_types::private::Err(alloy_sol_types::Error::InvalidLog {
3247 name: <Self as alloy_sol_types::SolEventInterface>::NAME,
3248 log: alloy_sol_types::private::Box::new(
3249 alloy_sol_types::private::LogData::new_unchecked(
3250 topics.to_vec(),
3251 data.to_vec().into(),
3252 ),
3253 ),
3254 })
3255 }
3256 }
3257 }
3258 }
3259 #[automatically_derived]
3260 impl alloy_sol_types::private::IntoLogData for HoprAnnouncementsEvents {
3261 fn to_log_data(&self) -> alloy_sol_types::private::LogData {
3262 match self {
3263 Self::AddressAnnouncement(inner) => {
3264 alloy_sol_types::private::IntoLogData::to_log_data(inner)
3265 }
3266 Self::KeyBinding(inner) => {
3267 alloy_sol_types::private::IntoLogData::to_log_data(inner)
3268 }
3269 Self::RevokeAnnouncement(inner) => {
3270 alloy_sol_types::private::IntoLogData::to_log_data(inner)
3271 }
3272 }
3273 }
3274 fn into_log_data(self) -> alloy_sol_types::private::LogData {
3275 match self {
3276 Self::AddressAnnouncement(inner) => {
3277 alloy_sol_types::private::IntoLogData::into_log_data(inner)
3278 }
3279 Self::KeyBinding(inner) => {
3280 alloy_sol_types::private::IntoLogData::into_log_data(inner)
3281 }
3282 Self::RevokeAnnouncement(inner) => {
3283 alloy_sol_types::private::IntoLogData::into_log_data(inner)
3284 }
3285 }
3286 }
3287 }
3288 use alloy::contract as alloy_contract;
3289 #[inline]
3293 pub const fn new<
3294 P: alloy_contract::private::Provider<N>,
3295 N: alloy_contract::private::Network,
3296 >(
3297 address: alloy_sol_types::private::Address,
3298 provider: P,
3299 ) -> HoprAnnouncementsInstance<P, N> {
3300 HoprAnnouncementsInstance::<P, N>::new(address, provider)
3301 }
3302 #[inline]
3308 pub fn deploy<
3309 P: alloy_contract::private::Provider<N>,
3310 N: alloy_contract::private::Network,
3311 >(
3312 provider: P,
3313 safeRegistry: alloy::sol_types::private::Address,
3314 ) -> impl ::core::future::Future<
3315 Output = alloy_contract::Result<HoprAnnouncementsInstance<P, N>>,
3316 > {
3317 HoprAnnouncementsInstance::<P, N>::deploy(provider, safeRegistry)
3318 }
3319 #[inline]
3325 pub fn deploy_builder<
3326 P: alloy_contract::private::Provider<N>,
3327 N: alloy_contract::private::Network,
3328 >(
3329 provider: P,
3330 safeRegistry: alloy::sol_types::private::Address,
3331 ) -> alloy_contract::RawCallBuilder<P, N> {
3332 HoprAnnouncementsInstance::<P, N>::deploy_builder(provider, safeRegistry)
3333 }
3334 #[derive(Clone)]
3346 pub struct HoprAnnouncementsInstance<P, N = alloy_contract::private::Ethereum> {
3347 address: alloy_sol_types::private::Address,
3348 provider: P,
3349 _network: ::core::marker::PhantomData<N>,
3350 }
3351 #[automatically_derived]
3352 impl<P, N> ::core::fmt::Debug for HoprAnnouncementsInstance<P, N> {
3353 #[inline]
3354 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
3355 f.debug_tuple("HoprAnnouncementsInstance").field(&self.address).finish()
3356 }
3357 }
3358 #[automatically_derived]
3360 impl<
3361 P: alloy_contract::private::Provider<N>,
3362 N: alloy_contract::private::Network,
3363 > HoprAnnouncementsInstance<P, N> {
3364 #[inline]
3368 pub const fn new(
3369 address: alloy_sol_types::private::Address,
3370 provider: P,
3371 ) -> Self {
3372 Self {
3373 address,
3374 provider,
3375 _network: ::core::marker::PhantomData,
3376 }
3377 }
3378 #[inline]
3384 pub async fn deploy(
3385 provider: P,
3386 safeRegistry: alloy::sol_types::private::Address,
3387 ) -> alloy_contract::Result<HoprAnnouncementsInstance<P, N>> {
3388 let call_builder = Self::deploy_builder(provider, safeRegistry);
3389 let contract_address = call_builder.deploy().await?;
3390 Ok(Self::new(contract_address, call_builder.provider))
3391 }
3392 #[inline]
3398 pub fn deploy_builder(
3399 provider: P,
3400 safeRegistry: alloy::sol_types::private::Address,
3401 ) -> alloy_contract::RawCallBuilder<P, N> {
3402 alloy_contract::RawCallBuilder::new_raw_deploy(
3403 provider,
3404 [
3405 &BYTECODE[..],
3406 &alloy_sol_types::SolConstructor::abi_encode(
3407 &constructorCall { safeRegistry },
3408 )[..],
3409 ]
3410 .concat()
3411 .into(),
3412 )
3413 }
3414 #[inline]
3416 pub const fn address(&self) -> &alloy_sol_types::private::Address {
3417 &self.address
3418 }
3419 #[inline]
3421 pub fn set_address(&mut self, address: alloy_sol_types::private::Address) {
3422 self.address = address;
3423 }
3424 pub fn at(mut self, address: alloy_sol_types::private::Address) -> Self {
3426 self.set_address(address);
3427 self
3428 }
3429 #[inline]
3431 pub const fn provider(&self) -> &P {
3432 &self.provider
3433 }
3434 }
3435 impl<P: ::core::clone::Clone, N> HoprAnnouncementsInstance<&P, N> {
3436 #[inline]
3438 pub fn with_cloned_provider(self) -> HoprAnnouncementsInstance<P, N> {
3439 HoprAnnouncementsInstance {
3440 address: self.address,
3441 provider: ::core::clone::Clone::clone(&self.provider),
3442 _network: ::core::marker::PhantomData,
3443 }
3444 }
3445 }
3446 #[automatically_derived]
3448 impl<
3449 P: alloy_contract::private::Provider<N>,
3450 N: alloy_contract::private::Network,
3451 > HoprAnnouncementsInstance<P, N> {
3452 pub fn call_builder<C: alloy_sol_types::SolCall>(
3457 &self,
3458 call: &C,
3459 ) -> alloy_contract::SolCallBuilder<&P, C, N> {
3460 alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call)
3461 }
3462 pub fn announce(
3464 &self,
3465 baseMultiaddr: alloy::sol_types::private::String,
3466 ) -> alloy_contract::SolCallBuilder<&P, announceCall, N> {
3467 self.call_builder(&announceCall { baseMultiaddr })
3468 }
3469 pub fn announceSafe(
3471 &self,
3472 selfAddress: alloy::sol_types::private::Address,
3473 baseMultiaddr: alloy::sol_types::private::String,
3474 ) -> alloy_contract::SolCallBuilder<&P, announceSafeCall, N> {
3475 self.call_builder(
3476 &announceSafeCall {
3477 selfAddress,
3478 baseMultiaddr,
3479 },
3480 )
3481 }
3482 pub fn bindKeys(
3484 &self,
3485 ed25519_sig_0: alloy::sol_types::private::FixedBytes<32>,
3486 ed25519_sig_1: alloy::sol_types::private::FixedBytes<32>,
3487 ed25519_pub_key: alloy::sol_types::private::FixedBytes<32>,
3488 ) -> alloy_contract::SolCallBuilder<&P, bindKeysCall, N> {
3489 self.call_builder(
3490 &bindKeysCall {
3491 ed25519_sig_0,
3492 ed25519_sig_1,
3493 ed25519_pub_key,
3494 },
3495 )
3496 }
3497 pub fn bindKeysAnnounce(
3499 &self,
3500 ed25519_sig_0: alloy::sol_types::private::FixedBytes<32>,
3501 ed25519_sig_1: alloy::sol_types::private::FixedBytes<32>,
3502 ed25519_pub_key: alloy::sol_types::private::FixedBytes<32>,
3503 baseMultiaddr: alloy::sol_types::private::String,
3504 ) -> alloy_contract::SolCallBuilder<&P, bindKeysAnnounceCall, N> {
3505 self.call_builder(
3506 &bindKeysAnnounceCall {
3507 ed25519_sig_0,
3508 ed25519_sig_1,
3509 ed25519_pub_key,
3510 baseMultiaddr,
3511 },
3512 )
3513 }
3514 pub fn bindKeysAnnounceSafe(
3516 &self,
3517 selfAddress: alloy::sol_types::private::Address,
3518 ed25519_sig_0: alloy::sol_types::private::FixedBytes<32>,
3519 ed25519_sig_1: alloy::sol_types::private::FixedBytes<32>,
3520 ed25519_pub_key: alloy::sol_types::private::FixedBytes<32>,
3521 baseMultiaddr: alloy::sol_types::private::String,
3522 ) -> alloy_contract::SolCallBuilder<&P, bindKeysAnnounceSafeCall, N> {
3523 self.call_builder(
3524 &bindKeysAnnounceSafeCall {
3525 selfAddress,
3526 ed25519_sig_0,
3527 ed25519_sig_1,
3528 ed25519_pub_key,
3529 baseMultiaddr,
3530 },
3531 )
3532 }
3533 pub fn bindKeysSafe(
3535 &self,
3536 selfAddress: alloy::sol_types::private::Address,
3537 ed25519_sig_0: alloy::sol_types::private::FixedBytes<32>,
3538 ed25519_sig_1: alloy::sol_types::private::FixedBytes<32>,
3539 ed25519_pub_key: alloy::sol_types::private::FixedBytes<32>,
3540 ) -> alloy_contract::SolCallBuilder<&P, bindKeysSafeCall, N> {
3541 self.call_builder(
3542 &bindKeysSafeCall {
3543 selfAddress,
3544 ed25519_sig_0,
3545 ed25519_sig_1,
3546 ed25519_pub_key,
3547 },
3548 )
3549 }
3550 pub fn multicall(
3552 &self,
3553 data: alloy::sol_types::private::Vec<alloy::sol_types::private::Bytes>,
3554 ) -> alloy_contract::SolCallBuilder<&P, multicallCall, N> {
3555 self.call_builder(&multicallCall { data })
3556 }
3557 pub fn revoke(&self) -> alloy_contract::SolCallBuilder<&P, revokeCall, N> {
3559 self.call_builder(&revokeCall)
3560 }
3561 pub fn revokeSafe(
3563 &self,
3564 selfAddress: alloy::sol_types::private::Address,
3565 ) -> alloy_contract::SolCallBuilder<&P, revokeSafeCall, N> {
3566 self.call_builder(&revokeSafeCall { selfAddress })
3567 }
3568 }
3569 #[automatically_derived]
3571 impl<
3572 P: alloy_contract::private::Provider<N>,
3573 N: alloy_contract::private::Network,
3574 > HoprAnnouncementsInstance<P, N> {
3575 pub fn event_filter<E: alloy_sol_types::SolEvent>(
3580 &self,
3581 ) -> alloy_contract::Event<&P, E, N> {
3582 alloy_contract::Event::new_sol(&self.provider, &self.address)
3583 }
3584 pub fn AddressAnnouncement_filter(
3586 &self,
3587 ) -> alloy_contract::Event<&P, AddressAnnouncement, N> {
3588 self.event_filter::<AddressAnnouncement>()
3589 }
3590 pub fn KeyBinding_filter(&self) -> alloy_contract::Event<&P, KeyBinding, N> {
3592 self.event_filter::<KeyBinding>()
3593 }
3594 pub fn RevokeAnnouncement_filter(
3596 &self,
3597 ) -> alloy_contract::Event<&P, RevokeAnnouncement, N> {
3598 self.event_filter::<RevokeAnnouncement>()
3599 }
3600 }
3601}