1#[allow(
567 non_camel_case_types,
568 non_snake_case,
569 clippy::pub_underscore_fields,
570 clippy::style,
571 clippy::empty_structs_with_brackets
572)]
573pub mod Application {
574 use super::*;
575 use alloy::sol_types as alloy_sol_types;
576 #[rustfmt::skip]
582 #[allow(clippy::all)]
583 pub static BYTECODE: alloy_sol_types::private::Bytes = alloy_sol_types::private::Bytes::from_static(
584 b"`\xC0`@R4a\x02\xB8Wa\x11\xBD\x808\x03\x80a\0\x19\x81a\x02\xBCV[\x92\x839\x81\x01\x90`\x80\x81\x83\x03\x12a\x02\xB8W\x80Q`\x01`\x01`\xA0\x1B\x03\x81\x16\x91\x90\x82\x90\x03a\x02\xB8W` \x81\x01Q`\x01`\x01`\xA0\x1B\x03\x81\x16\x90\x81\x90\x03a\x02\xB8W`@\x82\x01Q``\x83\x01Q\x90\x92`\x01`\x01`@\x1B\x03\x82\x11a\x02\xB8W\x01\x84`\x1F\x82\x01\x12\x15a\x02\xB8W\x80Q\x90`\x01`\x01`@\x1B\x03\x82\x11a\x02\x91Wa\0\x9F`\x1F\x83\x01`\x1F\x19\x16` \x01a\x02\xBCV[\x95\x82\x87R` \x83\x83\x01\x01\x11a\x02\xB8W\x81_\x92` \x80\x93\x01\x83\x89\x01^\x86\x01\x01R\x80\x15a\x02\xA5W_\x80T`\x01`\x01`\xA0\x1B\x03\x19\x81\x16\x83\x17\x82U`\x01`\x01`\xA0\x1B\x03\x16\x90\x7F\x8B\xE0\x07\x9CS\x16Y\x14\x13D\xCD\x1F\xD0\xA4\xF2\x84\x19I\x7F\x97\"\xA3\xDA\xAF\xE3\xB4\x18okdW\xE0\x90\x80\xA3`\x01\x80UC`\x80R`\xA0R`\x03\x80T`\x01`\x01`\xA0\x1B\x03\x19\x16\x91\x90\x91\x17\x90U\x80Q`\x01`\x01`@\x1B\x03\x81\x11a\x02\x91W`\x04T`\x01\x81\x81\x1C\x91\x16\x80\x15a\x02\x87W[` \x82\x10\x14a\x02sW`\x1F\x81\x11a\x02\x10W[P` \x91`\x1F\x82\x11`\x01\x14a\x01\xB0W\x91\x81\x92_\x92a\x01\xA5W[PP\x81`\x01\x1B\x91_\x19\x90`\x03\x1B\x1C\x19\x16\x17`\x04U[`@Qa\x0E\xDB\x90\x81a\x02\xE2\x829`\x80Q\x81a\x06\x87\x01R`\xA0Q\x81a\x05g\x01R\xF3[\x01Q\x90P_\x80a\x01oV[`\x1F\x19\x82\x16\x92`\x04_R\x80_ \x91_[\x85\x81\x10a\x01\xF8WP\x83`\x01\x95\x10a\x01\xE0W[PPP\x81\x1B\x01`\x04Ua\x01\x84V[\x01Q_\x19`\xF8\x84`\x03\x1B\x16\x1C\x19\x16\x90U_\x80\x80a\x01\xD2V[\x91\x92` `\x01\x81\x92\x86\x85\x01Q\x81U\x01\x94\x01\x92\x01a\x01\xC0V[`\x04_R\x7F\x8A5\xAC\xFB\xC1_\xF8\x1A9\xAE}4O\xD7\t\xF2\x8E\x86\0\xB4\xAA\x8Ce\xC6\xB6K\xFE\x7F\xE3k\xD1\x9B`\x1F\x83\x01`\x05\x1C\x81\x01\x91` \x84\x10a\x02iW[`\x1F\x01`\x05\x1C\x01\x90[\x81\x81\x10a\x02^WPa\x01VV[_\x81U`\x01\x01a\x02QV[\x90\x91P\x81\x90a\x02HV[cNH{q`\xE0\x1B_R`\"`\x04R`$_\xFD[\x90`\x7F\x16\x90a\x01DV[cNH{q`\xE0\x1B_R`A`\x04R`$_\xFD[c\x1EO\xBD\xF7`\xE0\x1B_R_`\x04R`$_\xFD[_\x80\xFD[`@Q\x91\x90`\x1F\x01`\x1F\x19\x16\x82\x01`\x01`\x01`@\x1B\x03\x81\x11\x83\x82\x10\x17a\x02\x91W`@RV\xFE`\x80`@R`\x046\x10\x15a\0\x1AW[6\x15a\0\x18W_\x80\xFD[\0[_5`\xE0\x1C\x80c\x01\xFF\xC9\xA7\x14a\x01)W\x80c\x08\xEB\x89\xAB\x14a\x01$W\x80c\x15\x0Bz\x02\x14a\x01\x1FW\x80c3\x13{v\x14a\x01\x1AW\x80ca\xB1,f\x14a\x01\x15W\x80cqP\x18\xA6\x14a\x01\x10W\x80cq\x89\x1D\xB0\x14a\x01\x0BW\x80c\x8D\xA5\xCB[\x14a\x01\x06W\x80c\xA9M\xFCZ\x14a\x01\x01W\x80c\xB3\xA1\xAC\xD8\x14a\0\xFCW\x80c\xBC\x19|\x81\x14a\0\xF7W\x80c\xBF\x8A\xBF\xF8\x14a\0\xF2W\x80c\xE6O\xABM\x14a\0\xEDW\x80c\xE8\x8D9\xC0\x14a\0\xE8W\x80c\xF0$x\xDE\x14a\0\xE3W\x80c\xF2:na\x14a\0\xDEWc\xF2\xFD\xE3\x8B\x03a\0\x0EWa\t\xC6V[a\tmV[a\x08~V[a\x08=V[a\x08 V[a\x07\xAFV[a\x07\x11V[a\x06pV[a\x06HV[a\x06!V[a\x05\xE1V[a\x05\x8AV[a\x05PV[a\x03KV[a\x02\x86V[a\x01\x91V[4a\x01\x7FW` 6`\x03\x19\x01\x12a\x01\x7FW`\x045c\xFF\xFF\xFF\xFF`\xE0\x1B\x81\x16\x80\x91\x03a\x01\x7FW` \x90c\x02q\x18\x97`\xE5\x1B\x81\x14\x90\x81\x15a\x01nW[P`@Q\x90\x15\x15\x81R\xF3[c\x01\xFF\xC9\xA7`\xE0\x1B\x14\x90P_a\x01cV[_\x80\xFD[\x90\x81`@\x91\x03\x12a\x01\x7FW\x90V[4a\x01\x7FW`@6`\x03\x19\x01\x12a\x01\x7FW`$5`\x01`\x01`@\x1B\x03\x81\x11a\x01\x7FWa\x01\xC4a\0\x18\x916\x90`\x04\x01a\x01\x83V[`\x045a\nOV[`\x01`\x01`\xA0\x1B\x03\x81\x16\x03a\x01\x7FWV[cNH{q`\xE0\x1B_R`A`\x04R`$_\xFD[\x90`\x1F\x80\x19\x91\x01\x16\x81\x01\x90\x81\x10`\x01`\x01`@\x1B\x03\x82\x11\x17a\x02\x12W`@RV[a\x01\xDDV[`\x01`\x01`@\x1B\x03\x81\x11a\x02\x12W`\x1F\x01`\x1F\x19\x16` \x01\x90V[\x92\x91\x92a\x02>\x82a\x02\x17V[\x91a\x02L`@Q\x93\x84a\x01\xF1V[\x82\x94\x81\x84R\x81\x83\x01\x11a\x01\x7FW\x82\x81` \x93\x84_\x96\x017\x01\x01RV[\x90\x80`\x1F\x83\x01\x12\x15a\x01\x7FW\x81` a\x02\x83\x935\x91\x01a\x022V[\x90V[4a\x01\x7FW`\x806`\x03\x19\x01\x12a\x01\x7FWa\x02\xA2`\x045a\x01\xCCV[a\x02\xAD`$5a\x01\xCCV[`d5`\x01`\x01`@\x1B\x03\x81\x11a\x01\x7FWa\x02\xCC\x906\x90`\x04\x01a\x02hV[P`@Qc\n\x85\xBD\x01`\xE1\x1B\x81R` \x90\xF3[`@`\x03\x19\x82\x01\x12a\x01\x7FW`\x045\x91`\x01`\x01`@\x1B\x03\x83\x11a\x01\x7FW\x81`#\x84\x01\x12\x15a\x01\x7FW\x82`\x04\x015\x92`\x01`\x01`@\x1B\x03\x84\x11a\x01\x7FW\x82`$\x85\x83\x01\x01\x11a\x01\x7FW`$\x01\x92\x91`$5\x90`\x01`\x01`@\x1B\x03\x82\x11a\x01\x7FWa\x02\x83\x91`\x04\x01a\x01\x83V[4a\x01\x7FWa\x03Y6a\x02\xDFV[`\x02`\x01\x93\x92\x93T\x14a\x05AWa\x03\x7F\x90`\x02`\x01Ua\x03z\x81\x85\x85a\x0C\x0EV[a\x0B&V[`\x04\x83\x10a\x05$Wa\x03\x9Aa\x03\x94\x84\x84a\x0BkV[\x90a\x0B\x96V[a\x03\xA5\x84\x80\x85a\x0ByV[\x91`\x01`\x01`\xE0\x1B\x03\x19\x16c#z\x81o`\xE0\x1B\x81\x03a\x04\x95WPa\x03\xE9`\x01`\x01`@\x1B\x03\x84\x16`\xFF`\x01\x91\x80`\x08\x1C_R`\x02` R\x16\x1B`@_ T\x16\x15\x15\x90V[a\x04qW\x93a\x04\x1Ca\x04e\x92\x7F\xCA\xD1\xF3a\xC6\xE8Fd\xE8\x92#\x02\x91\xC8\xE8\xEB\x95Uh>\nj\\\xE8\xEA{ J\xC0\xAC6v\x96a\rMV[a\x04F`\x01`\x01`@\x1B\x03\x84\x16\x80`\x08\x1C_R`\x02` R`\x01`\xFF`@_ \x92\x16\x1B\x81T\x17\x90UV[a\x04Ya\x04T`\x05Ta\x0B\xCCV[`\x05UV[`@Q\x93\x84\x93\x84a\x0B\xEEV[\x03\x90\xA1a\0\x18`\x01\x80UV[PP`@Qc{\x97\xA6\xBB`\xE0\x1B\x81R\x92\x83\x92a\x04\x91\x92P`\x04\x84\x01a\x0BZV[\x03\x90\xFD[c\x102\x1E\x8B`\xE0\x1B\x03a\x05\x04Wa\x04\xCC`\x01`\x01`@\x1B\x03\x84\x16`\xFF`\x01\x91\x80`\x08\x1C_R`\x02` R\x16\x1B`@_ T\x16\x15\x15\x90V[a\x04qW\x93a\x04\xFFa\x04e\x92\x7F\xCA\xD1\xF3a\xC6\xE8Fd\xE8\x92#\x02\x91\xC8\xE8\xEB\x95Uh>\nj\\\xE8\xEA{ J\xC0\xAC6v\x96a\x0C\xE8V[a\x04\x1CV[PP`@QciB`\x0F`\xE1\x1B\x81R\x92\x83\x92a\x04\x91\x92P`\x04\x84\x01a\x0BZV[Pa\x04\x91`@Q\x92\x83\x92ciB`\x0F`\xE1\x1B\x84R`\x04\x84\x01a\x0BZV[c>\xE5\xAE\xB5`\xE0\x1B_R`\x04_\xFD[4a\x01\x7FW_6`\x03\x19\x01\x12a\x01\x7FW` `@Q\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R\xF3[4a\x01\x7FW_6`\x03\x19\x01\x12a\x01\x7FWa\x05\xA2a\r\xBDV[_\x80T`\x01`\x01`\xA0\x1B\x03\x19\x81\x16\x82U`\x01`\x01`\xA0\x1B\x03\x16\x7F\x8B\xE0\x07\x9CS\x16Y\x14\x13D\xCD\x1F\xD0\xA4\xF2\x84\x19I\x7F\x97\"\xA3\xDA\xAF\xE3\xB4\x18okdW\xE0\x82\x80\xA3\0[4a\x01\x7FW` 6`\x03\x19\x01\x12a\x01\x7FW` a\x06\x17`\x045`\xFF`\x01\x91\x80`\x08\x1C_R`\x02` R\x16\x1B`@_ T\x16\x15\x15\x90V[`@Q\x90\x15\x15\x81R\xF3[4a\x01\x7FW_6`\x03\x19\x01\x12a\x01\x7FW_T`@Q`\x01`\x01`\xA0\x1B\x03\x90\x91\x16\x81R` \x90\xF3[4a\x01\x7FW_6`\x03\x19\x01\x12a\x01\x7FW`\x03T`@Q`\x01`\x01`\xA0\x1B\x03\x90\x91\x16\x81R` \x90\xF3[4a\x01\x7FW_6`\x03\x19\x01\x12a\x01\x7FW` `@Q\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R\xF3[\x90\x80`\x1F\x83\x01\x12\x15a\x01\x7FW\x815\x91`\x01`\x01`@\x1B\x03\x83\x11a\x02\x12W\x82`\x05\x1B\x90`@Q\x93a\x06\xDD` \x84\x01\x86a\x01\xF1V[\x84R` \x80\x85\x01\x92\x82\x01\x01\x92\x83\x11a\x01\x7FW` \x01\x90[\x82\x82\x10a\x07\x01WPPP\x90V[\x815\x81R` \x91\x82\x01\x91\x01a\x06\xF4V[4a\x01\x7FW`\xA06`\x03\x19\x01\x12a\x01\x7FWa\x07-`\x045a\x01\xCCV[a\x078`$5a\x01\xCCV[`D5`\x01`\x01`@\x1B\x03\x81\x11a\x01\x7FWa\x07W\x906\x90`\x04\x01a\x06\xAAV[P`d5`\x01`\x01`@\x1B\x03\x81\x11a\x01\x7FWa\x07w\x906\x90`\x04\x01a\x06\xAAV[P`\x845`\x01`\x01`@\x1B\x03\x81\x11a\x01\x7FWa\x07\x97\x906\x90`\x04\x01a\x02hV[P`@Qc\xBC\x19|\x81`\xE0\x1B\x81R\x80` \x81\x01[\x03\x90\xF3[4a\x01\x7FW` 6`\x03\x19\x01\x12a\x01\x7FW\x7Fj\xD3\x18\x8B\xA8\xF40\xFB\xA0el\xB0\xA7\xE89\xAB \xD5Xk\xA1\x1A\x14w\xD1\x8Fp\x92\xF8\xBE\xCE`\x045a\x07\xED\x81a\x01\xCCV[a\x07\xF5a\r\xBDV[`\x03\x80T`\x01`\x01`\xA0\x1B\x03\x19\x16`\x01`\x01`\xA0\x1B\x03\x92\x90\x92\x16\x91\x82\x17\x90U`@Q\x90\x81R` \x90\xA1\0[4a\x01\x7FW_6`\x03\x19\x01\x12a\x01\x7FW` `\x05T`@Q\x90\x81R\xF3[4a\x01\x7FWa\0\x18a\x08N6a\x02\xDFV[\x91a\x0C\x0EV[` `@\x92\x81\x83R\x80Q\x91\x82\x91\x82\x82\x86\x01R\x01\x84\x84\x01^_\x82\x82\x01\x84\x01R`\x1F\x01`\x1F\x19\x16\x01\x01\x90V[4a\x01\x7FW_6`\x03\x19\x01\x12a\x01\x7FW`@Q_`\x04T\x80`\x01\x1C\x90`\x01\x81\x16\x90\x81\x15a\tcW[` \x83\x10\x82\x14a\tOW\x82\x85R` \x85\x01\x91\x90\x81\x15a\t6WP`\x01\x14a\x08\xE4W[a\x07\xAB\x84a\x08\xD8\x81\x86\x03\x82a\x01\xF1V[`@Q\x91\x82\x91\x82a\x08TV[`\x04_\x90\x81R\x92P\x90\x7F\x8A5\xAC\xFB\xC1_\xF8\x1A9\xAE}4O\xD7\t\xF2\x8E\x86\0\xB4\xAA\x8Ce\xC6\xB6K\xFE\x7F\xE3k\xD1\x9B[\x81\x84\x10a\t\"WPP\x01a\x08\xD8\x82a\x08\xC8V[\x80T\x84\x84\x01R` \x90\x93\x01\x92`\x01\x01a\t\x0FV[`\xFF\x19\x16\x82RP\x90\x15\x15`\x05\x1B\x01\x90Pa\x08\xD8\x82a\x08\xC8V[cNH{q`\xE0\x1B_R`\"`\x04R`$_\xFD[\x91`\x7F\x16\x91a\x08\xA6V[4a\x01\x7FW`\xA06`\x03\x19\x01\x12a\x01\x7FWa\t\x89`\x045a\x01\xCCV[a\t\x94`$5a\x01\xCCV[`\x845`\x01`\x01`@\x1B\x03\x81\x11a\x01\x7FWa\t\xB3\x906\x90`\x04\x01a\x02hV[P`@Qc\xF2:na`\xE0\x1B\x81R` \x90\xF3[4a\x01\x7FW` 6`\x03\x19\x01\x12a\x01\x7FW`\x045a\t\xE3\x81a\x01\xCCV[a\t\xEBa\r\xBDV[`\x01`\x01`\xA0\x1B\x03\x16\x80\x15a\n<W_\x80T`\x01`\x01`\xA0\x1B\x03\x19\x81\x16\x83\x17\x82U`\x01`\x01`\xA0\x1B\x03\x16\x90\x7F\x8B\xE0\x07\x9CS\x16Y\x14\x13D\xCD\x1F\xD0\xA4\xF2\x84\x19I\x7F\x97\"\xA3\xDA\xAF\xE3\xB4\x18okdW\xE0\x90\x80\xA3\0[c\x1EO\xBD\xF7`\xE0\x1B_R_`\x04R`$_\xFD[\x91` \x82\x01\x91`?a\na\x84\x83a\x0C,V[\x90P\x03a\x0B\x17W`\x01`\x01`@\x1B\x03a\n\x80a\n\x88\x94\x83\x96\x94\x96a\x0C,V[\x94\x90\x92a\x0B&V[\x16\x93_\x92[\x84\x84\x10\x15a\n\xDEWa\n\xC5`\x01\x91\x85`\x05\x1B\x85\x015\x90\x83\x89\x16\x15_\x14a\n\xCEW\x90a\n\xBE\x91_R` R`@_ \x90V[\x96`\x01\x1C\x90V[\x93\x01\x92\x94a\n\x8DV[a\n\xBE\x91_R` R`@_ \x90V[\x93P\x93\x90Pa\n\xEE\x91P\x15a\r\xE3V[a\n\xFEa\n\xFA\x82a\x0CaV[\x15\x90V[a\x0B\x05WPV[cD\xA1\x92\xFF`\xE0\x1B_R`\x04R`$_\xFD[c],^\x9B`\xE1\x1B_R`\x04_\xFD[5`\x01`\x01`@\x1B\x03\x81\x16\x81\x03a\x01\x7FW\x90V[\x90\x80` \x93\x92\x81\x84R\x84\x84\x017_\x82\x82\x01\x84\x01R`\x1F\x01`\x1F\x19\x16\x01\x01\x90V[\x91` a\x02\x83\x93\x81\x81R\x01\x91a\x0B:V[\x90`\x04\x11a\x01\x7FW\x90`\x04\x90V[\x90\x92\x91\x92\x83`\x04\x11a\x01\x7FW\x83\x11a\x01\x7FW`\x04\x01\x91`\x03\x19\x01\x90V[5`\x01`\x01`\xE0\x1B\x03\x19\x81\x16\x92\x91\x90`\x04\x82\x10a\x0B\xB1WPPV[`\x01`\x01`\xE0\x1B\x03\x19`\x04\x92\x90\x92\x03`\x03\x1B\x82\x90\x1B\x16\x16\x91PV[_\x19\x81\x14a\x0B\xDAW`\x01\x01\x90V[cNH{q`\xE0\x1B_R`\x11`\x04R`$_\xFD[`@\x90`\x01`\x01`@\x1B\x03a\x02\x83\x95\x93\x16\x81R\x81` \x82\x01R\x01\x91a\x0B:V[a\x0C\x1E\x90a\x0C*\x93\x926\x91a\x022V[` \x81Q\x91\x01 a\nOV[V[\x905\x90`\x1E\x19\x816\x03\x01\x82\x12\x15a\x01\x7FW\x01\x805\x90`\x01`\x01`@\x1B\x03\x82\x11a\x01\x7FW` \x01\x91\x81`\x05\x1B6\x03\x83\x13a\x01\x7FWV[`\x03T`@Qc9s!\x99`\xE2\x1B\x81R0`\x04\x82\x01R`$\x81\x01\x92\x90\x92R` \x90\x82\x90`D\x90\x82\x90`\x01`\x01`\xA0\x1B\x03\x16Z\xFA\x90\x81\x15a\x0C\xDDW_\x91a\x0C\xA5WP\x90V[\x90P` \x81=` \x11a\x0C\xD5W[\x81a\x0C\xC0` \x93\x83a\x01\xF1V[\x81\x01\x03\x12a\x01\x7FWQ\x80\x15\x15\x81\x03a\x01\x7FW\x90V[=\x91Pa\x0C\xB3V[`@Q=_\x82>=\x90\xFD[\x90\x81\x01\x90`@\x81\x83\x03\x12a\x01\x7FW\x805a\r\x01\x81a\x01\xCCV[` \x82\x015\x91`\x01`\x01`@\x1B\x03\x83\x11a\x01\x7FW_\x93\x84\x93a\r#\x92\x01a\x02hV[\x80Q\x91` \x90\x91\x01\x90`\x01`\x01`\xA0\x1B\x03\x16Z\xF4a\r?a\x0E.V[\x90\x15a\rHWPV[a\x0E\x94V[\x90\x81\x01``\x82\x82\x03\x12a\x01\x7FW\x815a\re\x81a\x01\xCCV[` \x83\x015\x92`@\x81\x015\x90`\x01`\x01`@\x1B\x03\x82\x11a\x01\x7FWa\r\x9E\x93\x85\x92a\r\x8F\x92\x01a\x02hV[\x91`\x01`\x01`\xA0\x1B\x03\x16a\x0E]V[\x91\x90\x15a\r\xA9WPPV[b\xFA\xE2\xD5`\xE2\x1B_R`\x04R`$R`D_\xFD[_T`\x01`\x01`\xA0\x1B\x03\x163\x03a\r\xD0WV[c\x11\x8C\xDA\xA7`\xE0\x1B_R3`\x04R`$_\xFD[\x15a\r\xEAWV[`d`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R` `$\x82\x01R\x7FLibMerkle32: index out of bounds`D\x82\x01R\xFD[=\x15a\x0EXW=\x90a\x0E?\x82a\x02\x17V[\x91a\x0EM`@Q\x93\x84a\x01\xF1V[\x82R=_` \x84\x01>V[``\x90V[\x90\x92\x91\x92G\x93\x84\x82\x11a\x0E\x8CW_\x92\x83\x92` \x83Q\x93\x01\x91Z\xF1a\x0E\x7Fa\x0E.V[\x90\x15a\rHWP`\x01\x91\x90V[PPP_\x91\x90V[\x80Q\x90\x81a\x0E\xA0W_\x80\xFD[` \x01\xFD\xFE\xA2dipfsX\"\x12 y%\x81\xCD\xB4\xC6\x19\xBA\xE2y\xF0\xC9.\x04z\xADa\xEBL\xF6\xDCo\xA5\x82w\xBA\xEE\xF4'\x18\xD5}dsolcC\0\x08\x1E\x003",
585 );
586 #[rustfmt::skip]
592 #[allow(clippy::all)]
593 pub static DEPLOYED_BYTECODE: alloy_sol_types::private::Bytes = alloy_sol_types::private::Bytes::from_static(
594 b"`\x80`@R`\x046\x10\x15a\0\x1AW[6\x15a\0\x18W_\x80\xFD[\0[_5`\xE0\x1C\x80c\x01\xFF\xC9\xA7\x14a\x01)W\x80c\x08\xEB\x89\xAB\x14a\x01$W\x80c\x15\x0Bz\x02\x14a\x01\x1FW\x80c3\x13{v\x14a\x01\x1AW\x80ca\xB1,f\x14a\x01\x15W\x80cqP\x18\xA6\x14a\x01\x10W\x80cq\x89\x1D\xB0\x14a\x01\x0BW\x80c\x8D\xA5\xCB[\x14a\x01\x06W\x80c\xA9M\xFCZ\x14a\x01\x01W\x80c\xB3\xA1\xAC\xD8\x14a\0\xFCW\x80c\xBC\x19|\x81\x14a\0\xF7W\x80c\xBF\x8A\xBF\xF8\x14a\0\xF2W\x80c\xE6O\xABM\x14a\0\xEDW\x80c\xE8\x8D9\xC0\x14a\0\xE8W\x80c\xF0$x\xDE\x14a\0\xE3W\x80c\xF2:na\x14a\0\xDEWc\xF2\xFD\xE3\x8B\x03a\0\x0EWa\t\xC6V[a\tmV[a\x08~V[a\x08=V[a\x08 V[a\x07\xAFV[a\x07\x11V[a\x06pV[a\x06HV[a\x06!V[a\x05\xE1V[a\x05\x8AV[a\x05PV[a\x03KV[a\x02\x86V[a\x01\x91V[4a\x01\x7FW` 6`\x03\x19\x01\x12a\x01\x7FW`\x045c\xFF\xFF\xFF\xFF`\xE0\x1B\x81\x16\x80\x91\x03a\x01\x7FW` \x90c\x02q\x18\x97`\xE5\x1B\x81\x14\x90\x81\x15a\x01nW[P`@Q\x90\x15\x15\x81R\xF3[c\x01\xFF\xC9\xA7`\xE0\x1B\x14\x90P_a\x01cV[_\x80\xFD[\x90\x81`@\x91\x03\x12a\x01\x7FW\x90V[4a\x01\x7FW`@6`\x03\x19\x01\x12a\x01\x7FW`$5`\x01`\x01`@\x1B\x03\x81\x11a\x01\x7FWa\x01\xC4a\0\x18\x916\x90`\x04\x01a\x01\x83V[`\x045a\nOV[`\x01`\x01`\xA0\x1B\x03\x81\x16\x03a\x01\x7FWV[cNH{q`\xE0\x1B_R`A`\x04R`$_\xFD[\x90`\x1F\x80\x19\x91\x01\x16\x81\x01\x90\x81\x10`\x01`\x01`@\x1B\x03\x82\x11\x17a\x02\x12W`@RV[a\x01\xDDV[`\x01`\x01`@\x1B\x03\x81\x11a\x02\x12W`\x1F\x01`\x1F\x19\x16` \x01\x90V[\x92\x91\x92a\x02>\x82a\x02\x17V[\x91a\x02L`@Q\x93\x84a\x01\xF1V[\x82\x94\x81\x84R\x81\x83\x01\x11a\x01\x7FW\x82\x81` \x93\x84_\x96\x017\x01\x01RV[\x90\x80`\x1F\x83\x01\x12\x15a\x01\x7FW\x81` a\x02\x83\x935\x91\x01a\x022V[\x90V[4a\x01\x7FW`\x806`\x03\x19\x01\x12a\x01\x7FWa\x02\xA2`\x045a\x01\xCCV[a\x02\xAD`$5a\x01\xCCV[`d5`\x01`\x01`@\x1B\x03\x81\x11a\x01\x7FWa\x02\xCC\x906\x90`\x04\x01a\x02hV[P`@Qc\n\x85\xBD\x01`\xE1\x1B\x81R` \x90\xF3[`@`\x03\x19\x82\x01\x12a\x01\x7FW`\x045\x91`\x01`\x01`@\x1B\x03\x83\x11a\x01\x7FW\x81`#\x84\x01\x12\x15a\x01\x7FW\x82`\x04\x015\x92`\x01`\x01`@\x1B\x03\x84\x11a\x01\x7FW\x82`$\x85\x83\x01\x01\x11a\x01\x7FW`$\x01\x92\x91`$5\x90`\x01`\x01`@\x1B\x03\x82\x11a\x01\x7FWa\x02\x83\x91`\x04\x01a\x01\x83V[4a\x01\x7FWa\x03Y6a\x02\xDFV[`\x02`\x01\x93\x92\x93T\x14a\x05AWa\x03\x7F\x90`\x02`\x01Ua\x03z\x81\x85\x85a\x0C\x0EV[a\x0B&V[`\x04\x83\x10a\x05$Wa\x03\x9Aa\x03\x94\x84\x84a\x0BkV[\x90a\x0B\x96V[a\x03\xA5\x84\x80\x85a\x0ByV[\x91`\x01`\x01`\xE0\x1B\x03\x19\x16c#z\x81o`\xE0\x1B\x81\x03a\x04\x95WPa\x03\xE9`\x01`\x01`@\x1B\x03\x84\x16`\xFF`\x01\x91\x80`\x08\x1C_R`\x02` R\x16\x1B`@_ T\x16\x15\x15\x90V[a\x04qW\x93a\x04\x1Ca\x04e\x92\x7F\xCA\xD1\xF3a\xC6\xE8Fd\xE8\x92#\x02\x91\xC8\xE8\xEB\x95Uh>\nj\\\xE8\xEA{ J\xC0\xAC6v\x96a\rMV[a\x04F`\x01`\x01`@\x1B\x03\x84\x16\x80`\x08\x1C_R`\x02` R`\x01`\xFF`@_ \x92\x16\x1B\x81T\x17\x90UV[a\x04Ya\x04T`\x05Ta\x0B\xCCV[`\x05UV[`@Q\x93\x84\x93\x84a\x0B\xEEV[\x03\x90\xA1a\0\x18`\x01\x80UV[PP`@Qc{\x97\xA6\xBB`\xE0\x1B\x81R\x92\x83\x92a\x04\x91\x92P`\x04\x84\x01a\x0BZV[\x03\x90\xFD[c\x102\x1E\x8B`\xE0\x1B\x03a\x05\x04Wa\x04\xCC`\x01`\x01`@\x1B\x03\x84\x16`\xFF`\x01\x91\x80`\x08\x1C_R`\x02` R\x16\x1B`@_ T\x16\x15\x15\x90V[a\x04qW\x93a\x04\xFFa\x04e\x92\x7F\xCA\xD1\xF3a\xC6\xE8Fd\xE8\x92#\x02\x91\xC8\xE8\xEB\x95Uh>\nj\\\xE8\xEA{ J\xC0\xAC6v\x96a\x0C\xE8V[a\x04\x1CV[PP`@QciB`\x0F`\xE1\x1B\x81R\x92\x83\x92a\x04\x91\x92P`\x04\x84\x01a\x0BZV[Pa\x04\x91`@Q\x92\x83\x92ciB`\x0F`\xE1\x1B\x84R`\x04\x84\x01a\x0BZV[c>\xE5\xAE\xB5`\xE0\x1B_R`\x04_\xFD[4a\x01\x7FW_6`\x03\x19\x01\x12a\x01\x7FW` `@Q\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R\xF3[4a\x01\x7FW_6`\x03\x19\x01\x12a\x01\x7FWa\x05\xA2a\r\xBDV[_\x80T`\x01`\x01`\xA0\x1B\x03\x19\x81\x16\x82U`\x01`\x01`\xA0\x1B\x03\x16\x7F\x8B\xE0\x07\x9CS\x16Y\x14\x13D\xCD\x1F\xD0\xA4\xF2\x84\x19I\x7F\x97\"\xA3\xDA\xAF\xE3\xB4\x18okdW\xE0\x82\x80\xA3\0[4a\x01\x7FW` 6`\x03\x19\x01\x12a\x01\x7FW` a\x06\x17`\x045`\xFF`\x01\x91\x80`\x08\x1C_R`\x02` R\x16\x1B`@_ T\x16\x15\x15\x90V[`@Q\x90\x15\x15\x81R\xF3[4a\x01\x7FW_6`\x03\x19\x01\x12a\x01\x7FW_T`@Q`\x01`\x01`\xA0\x1B\x03\x90\x91\x16\x81R` \x90\xF3[4a\x01\x7FW_6`\x03\x19\x01\x12a\x01\x7FW`\x03T`@Q`\x01`\x01`\xA0\x1B\x03\x90\x91\x16\x81R` \x90\xF3[4a\x01\x7FW_6`\x03\x19\x01\x12a\x01\x7FW` `@Q\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81R\xF3[\x90\x80`\x1F\x83\x01\x12\x15a\x01\x7FW\x815\x91`\x01`\x01`@\x1B\x03\x83\x11a\x02\x12W\x82`\x05\x1B\x90`@Q\x93a\x06\xDD` \x84\x01\x86a\x01\xF1V[\x84R` \x80\x85\x01\x92\x82\x01\x01\x92\x83\x11a\x01\x7FW` \x01\x90[\x82\x82\x10a\x07\x01WPPP\x90V[\x815\x81R` \x91\x82\x01\x91\x01a\x06\xF4V[4a\x01\x7FW`\xA06`\x03\x19\x01\x12a\x01\x7FWa\x07-`\x045a\x01\xCCV[a\x078`$5a\x01\xCCV[`D5`\x01`\x01`@\x1B\x03\x81\x11a\x01\x7FWa\x07W\x906\x90`\x04\x01a\x06\xAAV[P`d5`\x01`\x01`@\x1B\x03\x81\x11a\x01\x7FWa\x07w\x906\x90`\x04\x01a\x06\xAAV[P`\x845`\x01`\x01`@\x1B\x03\x81\x11a\x01\x7FWa\x07\x97\x906\x90`\x04\x01a\x02hV[P`@Qc\xBC\x19|\x81`\xE0\x1B\x81R\x80` \x81\x01[\x03\x90\xF3[4a\x01\x7FW` 6`\x03\x19\x01\x12a\x01\x7FW\x7Fj\xD3\x18\x8B\xA8\xF40\xFB\xA0el\xB0\xA7\xE89\xAB \xD5Xk\xA1\x1A\x14w\xD1\x8Fp\x92\xF8\xBE\xCE`\x045a\x07\xED\x81a\x01\xCCV[a\x07\xF5a\r\xBDV[`\x03\x80T`\x01`\x01`\xA0\x1B\x03\x19\x16`\x01`\x01`\xA0\x1B\x03\x92\x90\x92\x16\x91\x82\x17\x90U`@Q\x90\x81R` \x90\xA1\0[4a\x01\x7FW_6`\x03\x19\x01\x12a\x01\x7FW` `\x05T`@Q\x90\x81R\xF3[4a\x01\x7FWa\0\x18a\x08N6a\x02\xDFV[\x91a\x0C\x0EV[` `@\x92\x81\x83R\x80Q\x91\x82\x91\x82\x82\x86\x01R\x01\x84\x84\x01^_\x82\x82\x01\x84\x01R`\x1F\x01`\x1F\x19\x16\x01\x01\x90V[4a\x01\x7FW_6`\x03\x19\x01\x12a\x01\x7FW`@Q_`\x04T\x80`\x01\x1C\x90`\x01\x81\x16\x90\x81\x15a\tcW[` \x83\x10\x82\x14a\tOW\x82\x85R` \x85\x01\x91\x90\x81\x15a\t6WP`\x01\x14a\x08\xE4W[a\x07\xAB\x84a\x08\xD8\x81\x86\x03\x82a\x01\xF1V[`@Q\x91\x82\x91\x82a\x08TV[`\x04_\x90\x81R\x92P\x90\x7F\x8A5\xAC\xFB\xC1_\xF8\x1A9\xAE}4O\xD7\t\xF2\x8E\x86\0\xB4\xAA\x8Ce\xC6\xB6K\xFE\x7F\xE3k\xD1\x9B[\x81\x84\x10a\t\"WPP\x01a\x08\xD8\x82a\x08\xC8V[\x80T\x84\x84\x01R` \x90\x93\x01\x92`\x01\x01a\t\x0FV[`\xFF\x19\x16\x82RP\x90\x15\x15`\x05\x1B\x01\x90Pa\x08\xD8\x82a\x08\xC8V[cNH{q`\xE0\x1B_R`\"`\x04R`$_\xFD[\x91`\x7F\x16\x91a\x08\xA6V[4a\x01\x7FW`\xA06`\x03\x19\x01\x12a\x01\x7FWa\t\x89`\x045a\x01\xCCV[a\t\x94`$5a\x01\xCCV[`\x845`\x01`\x01`@\x1B\x03\x81\x11a\x01\x7FWa\t\xB3\x906\x90`\x04\x01a\x02hV[P`@Qc\xF2:na`\xE0\x1B\x81R` \x90\xF3[4a\x01\x7FW` 6`\x03\x19\x01\x12a\x01\x7FW`\x045a\t\xE3\x81a\x01\xCCV[a\t\xEBa\r\xBDV[`\x01`\x01`\xA0\x1B\x03\x16\x80\x15a\n<W_\x80T`\x01`\x01`\xA0\x1B\x03\x19\x81\x16\x83\x17\x82U`\x01`\x01`\xA0\x1B\x03\x16\x90\x7F\x8B\xE0\x07\x9CS\x16Y\x14\x13D\xCD\x1F\xD0\xA4\xF2\x84\x19I\x7F\x97\"\xA3\xDA\xAF\xE3\xB4\x18okdW\xE0\x90\x80\xA3\0[c\x1EO\xBD\xF7`\xE0\x1B_R_`\x04R`$_\xFD[\x91` \x82\x01\x91`?a\na\x84\x83a\x0C,V[\x90P\x03a\x0B\x17W`\x01`\x01`@\x1B\x03a\n\x80a\n\x88\x94\x83\x96\x94\x96a\x0C,V[\x94\x90\x92a\x0B&V[\x16\x93_\x92[\x84\x84\x10\x15a\n\xDEWa\n\xC5`\x01\x91\x85`\x05\x1B\x85\x015\x90\x83\x89\x16\x15_\x14a\n\xCEW\x90a\n\xBE\x91_R` R`@_ \x90V[\x96`\x01\x1C\x90V[\x93\x01\x92\x94a\n\x8DV[a\n\xBE\x91_R` R`@_ \x90V[\x93P\x93\x90Pa\n\xEE\x91P\x15a\r\xE3V[a\n\xFEa\n\xFA\x82a\x0CaV[\x15\x90V[a\x0B\x05WPV[cD\xA1\x92\xFF`\xE0\x1B_R`\x04R`$_\xFD[c],^\x9B`\xE1\x1B_R`\x04_\xFD[5`\x01`\x01`@\x1B\x03\x81\x16\x81\x03a\x01\x7FW\x90V[\x90\x80` \x93\x92\x81\x84R\x84\x84\x017_\x82\x82\x01\x84\x01R`\x1F\x01`\x1F\x19\x16\x01\x01\x90V[\x91` a\x02\x83\x93\x81\x81R\x01\x91a\x0B:V[\x90`\x04\x11a\x01\x7FW\x90`\x04\x90V[\x90\x92\x91\x92\x83`\x04\x11a\x01\x7FW\x83\x11a\x01\x7FW`\x04\x01\x91`\x03\x19\x01\x90V[5`\x01`\x01`\xE0\x1B\x03\x19\x81\x16\x92\x91\x90`\x04\x82\x10a\x0B\xB1WPPV[`\x01`\x01`\xE0\x1B\x03\x19`\x04\x92\x90\x92\x03`\x03\x1B\x82\x90\x1B\x16\x16\x91PV[_\x19\x81\x14a\x0B\xDAW`\x01\x01\x90V[cNH{q`\xE0\x1B_R`\x11`\x04R`$_\xFD[`@\x90`\x01`\x01`@\x1B\x03a\x02\x83\x95\x93\x16\x81R\x81` \x82\x01R\x01\x91a\x0B:V[a\x0C\x1E\x90a\x0C*\x93\x926\x91a\x022V[` \x81Q\x91\x01 a\nOV[V[\x905\x90`\x1E\x19\x816\x03\x01\x82\x12\x15a\x01\x7FW\x01\x805\x90`\x01`\x01`@\x1B\x03\x82\x11a\x01\x7FW` \x01\x91\x81`\x05\x1B6\x03\x83\x13a\x01\x7FWV[`\x03T`@Qc9s!\x99`\xE2\x1B\x81R0`\x04\x82\x01R`$\x81\x01\x92\x90\x92R` \x90\x82\x90`D\x90\x82\x90`\x01`\x01`\xA0\x1B\x03\x16Z\xFA\x90\x81\x15a\x0C\xDDW_\x91a\x0C\xA5WP\x90V[\x90P` \x81=` \x11a\x0C\xD5W[\x81a\x0C\xC0` \x93\x83a\x01\xF1V[\x81\x01\x03\x12a\x01\x7FWQ\x80\x15\x15\x81\x03a\x01\x7FW\x90V[=\x91Pa\x0C\xB3V[`@Q=_\x82>=\x90\xFD[\x90\x81\x01\x90`@\x81\x83\x03\x12a\x01\x7FW\x805a\r\x01\x81a\x01\xCCV[` \x82\x015\x91`\x01`\x01`@\x1B\x03\x83\x11a\x01\x7FW_\x93\x84\x93a\r#\x92\x01a\x02hV[\x80Q\x91` \x90\x91\x01\x90`\x01`\x01`\xA0\x1B\x03\x16Z\xF4a\r?a\x0E.V[\x90\x15a\rHWPV[a\x0E\x94V[\x90\x81\x01``\x82\x82\x03\x12a\x01\x7FW\x815a\re\x81a\x01\xCCV[` \x83\x015\x92`@\x81\x015\x90`\x01`\x01`@\x1B\x03\x82\x11a\x01\x7FWa\r\x9E\x93\x85\x92a\r\x8F\x92\x01a\x02hV[\x91`\x01`\x01`\xA0\x1B\x03\x16a\x0E]V[\x91\x90\x15a\r\xA9WPPV[b\xFA\xE2\xD5`\xE2\x1B_R`\x04R`$R`D_\xFD[_T`\x01`\x01`\xA0\x1B\x03\x163\x03a\r\xD0WV[c\x11\x8C\xDA\xA7`\xE0\x1B_R3`\x04R`$_\xFD[\x15a\r\xEAWV[`d`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R` `$\x82\x01R\x7FLibMerkle32: index out of bounds`D\x82\x01R\xFD[=\x15a\x0EXW=\x90a\x0E?\x82a\x02\x17V[\x91a\x0EM`@Q\x93\x84a\x01\xF1V[\x82R=_` \x84\x01>V[``\x90V[\x90\x92\x91\x92G\x93\x84\x82\x11a\x0E\x8CW_\x92\x83\x92` \x83Q\x93\x01\x91Z\xF1a\x0E\x7Fa\x0E.V[\x90\x15a\rHWP`\x01\x91\x90V[PPP_\x91\x90V[\x80Q\x90\x81a\x0E\xA0W_\x80\xFD[` \x01\xFD\xFE\xA2dipfsX\"\x12 y%\x81\xCD\xB4\xC6\x19\xBA\xE2y\xF0\xC9.\x04z\xADa\xEBL\xF6\xDCo\xA5\x82w\xBA\xEE\xF4'\x18\xD5}dsolcC\0\x08\x1E\x003",
595 );
596 #[derive(serde::Serialize, serde::Deserialize)]
597 #[derive(Default, Debug, PartialEq, Eq, Hash)]
598 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
602 #[derive(Clone)]
603 pub struct OutputValidityProof {
604 #[allow(missing_docs)]
605 pub outputIndex: u64,
606 #[allow(missing_docs)]
607 pub outputHashesSiblings: alloy::sol_types::private::Vec<
608 alloy::sol_types::private::FixedBytes<32>,
609 >,
610 }
611 #[allow(
612 non_camel_case_types,
613 non_snake_case,
614 clippy::pub_underscore_fields,
615 clippy::style
616 )]
617 const _: () = {
618 use alloy::sol_types as alloy_sol_types;
619 #[doc(hidden)]
620 #[allow(dead_code)]
621 type UnderlyingSolTuple<'a> = (
622 alloy::sol_types::sol_data::Uint<64>,
623 alloy::sol_types::sol_data::Array<alloy::sol_types::sol_data::FixedBytes<32>>,
624 );
625 #[doc(hidden)]
626 type UnderlyingRustTuple<'a> = (
627 u64,
628 alloy::sol_types::private::Vec<alloy::sol_types::private::FixedBytes<32>>,
629 );
630 #[cfg(test)]
631 #[allow(dead_code, unreachable_patterns)]
632 fn _type_assertion(
633 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
634 ) {
635 match _t {
636 alloy_sol_types::private::AssertTypeEq::<
637 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
638 >(_) => {}
639 }
640 }
641 #[automatically_derived]
642 #[doc(hidden)]
643 impl ::core::convert::From<OutputValidityProof> for UnderlyingRustTuple<'_> {
644 fn from(value: OutputValidityProof) -> Self {
645 (value.outputIndex, value.outputHashesSiblings)
646 }
647 }
648 #[automatically_derived]
649 #[doc(hidden)]
650 impl ::core::convert::From<UnderlyingRustTuple<'_>> for OutputValidityProof {
651 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
652 Self {
653 outputIndex: tuple.0,
654 outputHashesSiblings: tuple.1,
655 }
656 }
657 }
658 #[automatically_derived]
659 impl alloy_sol_types::SolValue for OutputValidityProof {
660 type SolType = Self;
661 }
662 #[automatically_derived]
663 impl alloy_sol_types::private::SolTypeValue<Self> for OutputValidityProof {
664 #[inline]
665 fn stv_to_tokens(&self) -> <Self as alloy_sol_types::SolType>::Token<'_> {
666 (
667 <alloy::sol_types::sol_data::Uint<
668 64,
669 > as alloy_sol_types::SolType>::tokenize(&self.outputIndex),
670 <alloy::sol_types::sol_data::Array<
671 alloy::sol_types::sol_data::FixedBytes<32>,
672 > as alloy_sol_types::SolType>::tokenize(&self.outputHashesSiblings),
673 )
674 }
675 #[inline]
676 fn stv_abi_encoded_size(&self) -> usize {
677 if let Some(size) = <Self as alloy_sol_types::SolType>::ENCODED_SIZE {
678 return size;
679 }
680 let tuple = <UnderlyingRustTuple<
681 '_,
682 > as ::core::convert::From<Self>>::from(self.clone());
683 <UnderlyingSolTuple<
684 '_,
685 > as alloy_sol_types::SolType>::abi_encoded_size(&tuple)
686 }
687 #[inline]
688 fn stv_eip712_data_word(&self) -> alloy_sol_types::Word {
689 <Self as alloy_sol_types::SolStruct>::eip712_hash_struct(self)
690 }
691 #[inline]
692 fn stv_abi_encode_packed_to(
693 &self,
694 out: &mut alloy_sol_types::private::Vec<u8>,
695 ) {
696 let tuple = <UnderlyingRustTuple<
697 '_,
698 > as ::core::convert::From<Self>>::from(self.clone());
699 <UnderlyingSolTuple<
700 '_,
701 > as alloy_sol_types::SolType>::abi_encode_packed_to(&tuple, out)
702 }
703 #[inline]
704 fn stv_abi_packed_encoded_size(&self) -> usize {
705 if let Some(size) = <Self as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE {
706 return size;
707 }
708 let tuple = <UnderlyingRustTuple<
709 '_,
710 > as ::core::convert::From<Self>>::from(self.clone());
711 <UnderlyingSolTuple<
712 '_,
713 > as alloy_sol_types::SolType>::abi_packed_encoded_size(&tuple)
714 }
715 }
716 #[automatically_derived]
717 impl alloy_sol_types::SolType for OutputValidityProof {
718 type RustType = Self;
719 type Token<'a> = <UnderlyingSolTuple<
720 'a,
721 > as alloy_sol_types::SolType>::Token<'a>;
722 const SOL_NAME: &'static str = <Self as alloy_sol_types::SolStruct>::NAME;
723 const ENCODED_SIZE: Option<usize> = <UnderlyingSolTuple<
724 '_,
725 > as alloy_sol_types::SolType>::ENCODED_SIZE;
726 const PACKED_ENCODED_SIZE: Option<usize> = <UnderlyingSolTuple<
727 '_,
728 > as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE;
729 #[inline]
730 fn valid_token(token: &Self::Token<'_>) -> bool {
731 <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::valid_token(token)
732 }
733 #[inline]
734 fn detokenize(token: Self::Token<'_>) -> Self::RustType {
735 let tuple = <UnderlyingSolTuple<
736 '_,
737 > as alloy_sol_types::SolType>::detokenize(token);
738 <Self as ::core::convert::From<UnderlyingRustTuple<'_>>>::from(tuple)
739 }
740 }
741 #[automatically_derived]
742 impl alloy_sol_types::SolStruct for OutputValidityProof {
743 const NAME: &'static str = "OutputValidityProof";
744 #[inline]
745 fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> {
746 alloy_sol_types::private::Cow::Borrowed(
747 "OutputValidityProof(uint64 outputIndex,bytes32[] outputHashesSiblings)",
748 )
749 }
750 #[inline]
751 fn eip712_components() -> alloy_sol_types::private::Vec<
752 alloy_sol_types::private::Cow<'static, str>,
753 > {
754 alloy_sol_types::private::Vec::new()
755 }
756 #[inline]
757 fn eip712_encode_type() -> alloy_sol_types::private::Cow<'static, str> {
758 <Self as alloy_sol_types::SolStruct>::eip712_root_type()
759 }
760 #[inline]
761 fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec<u8> {
762 [
763 <alloy::sol_types::sol_data::Uint<
764 64,
765 > as alloy_sol_types::SolType>::eip712_data_word(&self.outputIndex)
766 .0,
767 <alloy::sol_types::sol_data::Array<
768 alloy::sol_types::sol_data::FixedBytes<32>,
769 > as alloy_sol_types::SolType>::eip712_data_word(
770 &self.outputHashesSiblings,
771 )
772 .0,
773 ]
774 .concat()
775 }
776 }
777 #[automatically_derived]
778 impl alloy_sol_types::EventTopic for OutputValidityProof {
779 #[inline]
780 fn topic_preimage_length(rust: &Self::RustType) -> usize {
781 0usize
782 + <alloy::sol_types::sol_data::Uint<
783 64,
784 > as alloy_sol_types::EventTopic>::topic_preimage_length(
785 &rust.outputIndex,
786 )
787 + <alloy::sol_types::sol_data::Array<
788 alloy::sol_types::sol_data::FixedBytes<32>,
789 > as alloy_sol_types::EventTopic>::topic_preimage_length(
790 &rust.outputHashesSiblings,
791 )
792 }
793 #[inline]
794 fn encode_topic_preimage(
795 rust: &Self::RustType,
796 out: &mut alloy_sol_types::private::Vec<u8>,
797 ) {
798 out.reserve(
799 <Self as alloy_sol_types::EventTopic>::topic_preimage_length(rust),
800 );
801 <alloy::sol_types::sol_data::Uint<
802 64,
803 > as alloy_sol_types::EventTopic>::encode_topic_preimage(
804 &rust.outputIndex,
805 out,
806 );
807 <alloy::sol_types::sol_data::Array<
808 alloy::sol_types::sol_data::FixedBytes<32>,
809 > as alloy_sol_types::EventTopic>::encode_topic_preimage(
810 &rust.outputHashesSiblings,
811 out,
812 );
813 }
814 #[inline]
815 fn encode_topic(
816 rust: &Self::RustType,
817 ) -> alloy_sol_types::abi::token::WordToken {
818 let mut out = alloy_sol_types::private::Vec::new();
819 <Self as alloy_sol_types::EventTopic>::encode_topic_preimage(
820 rust,
821 &mut out,
822 );
823 alloy_sol_types::abi::token::WordToken(
824 alloy_sol_types::private::keccak256(out),
825 )
826 }
827 }
828 };
829 #[derive(serde::Serialize, serde::Deserialize)]
830 #[derive(Default, Debug, PartialEq, Eq, Hash)]
831 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
836 #[derive(Clone)]
837 pub struct InsufficientFunds {
838 #[allow(missing_docs)]
839 pub value: alloy::sol_types::private::primitives::aliases::U256,
840 #[allow(missing_docs)]
841 pub balance: alloy::sol_types::private::primitives::aliases::U256,
842 }
843 #[allow(
844 non_camel_case_types,
845 non_snake_case,
846 clippy::pub_underscore_fields,
847 clippy::style
848 )]
849 const _: () = {
850 use alloy::sol_types as alloy_sol_types;
851 #[doc(hidden)]
852 #[allow(dead_code)]
853 type UnderlyingSolTuple<'a> = (
854 alloy::sol_types::sol_data::Uint<256>,
855 alloy::sol_types::sol_data::Uint<256>,
856 );
857 #[doc(hidden)]
858 type UnderlyingRustTuple<'a> = (
859 alloy::sol_types::private::primitives::aliases::U256,
860 alloy::sol_types::private::primitives::aliases::U256,
861 );
862 #[cfg(test)]
863 #[allow(dead_code, unreachable_patterns)]
864 fn _type_assertion(
865 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
866 ) {
867 match _t {
868 alloy_sol_types::private::AssertTypeEq::<
869 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
870 >(_) => {}
871 }
872 }
873 #[automatically_derived]
874 #[doc(hidden)]
875 impl ::core::convert::From<InsufficientFunds> for UnderlyingRustTuple<'_> {
876 fn from(value: InsufficientFunds) -> Self {
877 (value.value, value.balance)
878 }
879 }
880 #[automatically_derived]
881 #[doc(hidden)]
882 impl ::core::convert::From<UnderlyingRustTuple<'_>> for InsufficientFunds {
883 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
884 Self {
885 value: tuple.0,
886 balance: tuple.1,
887 }
888 }
889 }
890 #[automatically_derived]
891 impl alloy_sol_types::SolError for InsufficientFunds {
892 type Parameters<'a> = UnderlyingSolTuple<'a>;
893 type Token<'a> = <Self::Parameters<
894 'a,
895 > as alloy_sol_types::SolType>::Token<'a>;
896 const SIGNATURE: &'static str = "InsufficientFunds(uint256,uint256)";
897 const SELECTOR: [u8; 4] = [3u8, 235u8, 139u8, 84u8];
898 #[inline]
899 fn new<'a>(
900 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
901 ) -> Self {
902 tuple.into()
903 }
904 #[inline]
905 fn tokenize(&self) -> Self::Token<'_> {
906 (
907 <alloy::sol_types::sol_data::Uint<
908 256,
909 > as alloy_sol_types::SolType>::tokenize(&self.value),
910 <alloy::sol_types::sol_data::Uint<
911 256,
912 > as alloy_sol_types::SolType>::tokenize(&self.balance),
913 )
914 }
915 #[inline]
916 fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
917 <Self::Parameters<
918 '_,
919 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
920 .map(Self::new)
921 }
922 }
923 };
924 #[derive(serde::Serialize, serde::Deserialize)]
925 #[derive(Default, Debug, PartialEq, Eq, Hash)]
926 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
931 #[derive(Clone)]
932 pub struct InvalidOutputHashesSiblingsArrayLength;
933 #[allow(
934 non_camel_case_types,
935 non_snake_case,
936 clippy::pub_underscore_fields,
937 clippy::style
938 )]
939 const _: () = {
940 use alloy::sol_types as alloy_sol_types;
941 #[doc(hidden)]
942 #[allow(dead_code)]
943 type UnderlyingSolTuple<'a> = ();
944 #[doc(hidden)]
945 type UnderlyingRustTuple<'a> = ();
946 #[cfg(test)]
947 #[allow(dead_code, unreachable_patterns)]
948 fn _type_assertion(
949 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
950 ) {
951 match _t {
952 alloy_sol_types::private::AssertTypeEq::<
953 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
954 >(_) => {}
955 }
956 }
957 #[automatically_derived]
958 #[doc(hidden)]
959 impl ::core::convert::From<InvalidOutputHashesSiblingsArrayLength>
960 for UnderlyingRustTuple<'_> {
961 fn from(value: InvalidOutputHashesSiblingsArrayLength) -> Self {
962 ()
963 }
964 }
965 #[automatically_derived]
966 #[doc(hidden)]
967 impl ::core::convert::From<UnderlyingRustTuple<'_>>
968 for InvalidOutputHashesSiblingsArrayLength {
969 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
970 Self
971 }
972 }
973 #[automatically_derived]
974 impl alloy_sol_types::SolError for InvalidOutputHashesSiblingsArrayLength {
975 type Parameters<'a> = UnderlyingSolTuple<'a>;
976 type Token<'a> = <Self::Parameters<
977 'a,
978 > as alloy_sol_types::SolType>::Token<'a>;
979 const SIGNATURE: &'static str = "InvalidOutputHashesSiblingsArrayLength()";
980 const SELECTOR: [u8; 4] = [186u8, 88u8, 189u8, 54u8];
981 #[inline]
982 fn new<'a>(
983 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
984 ) -> Self {
985 tuple.into()
986 }
987 #[inline]
988 fn tokenize(&self) -> Self::Token<'_> {
989 ()
990 }
991 #[inline]
992 fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
993 <Self::Parameters<
994 '_,
995 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
996 .map(Self::new)
997 }
998 }
999 };
1000 #[derive(serde::Serialize, serde::Deserialize)]
1001 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1002 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1007 #[derive(Clone)]
1008 pub struct InvalidOutputsMerkleRoot {
1009 #[allow(missing_docs)]
1010 pub outputsMerkleRoot: alloy::sol_types::private::FixedBytes<32>,
1011 }
1012 #[allow(
1013 non_camel_case_types,
1014 non_snake_case,
1015 clippy::pub_underscore_fields,
1016 clippy::style
1017 )]
1018 const _: () = {
1019 use alloy::sol_types as alloy_sol_types;
1020 #[doc(hidden)]
1021 #[allow(dead_code)]
1022 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,);
1023 #[doc(hidden)]
1024 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::FixedBytes<32>,);
1025 #[cfg(test)]
1026 #[allow(dead_code, unreachable_patterns)]
1027 fn _type_assertion(
1028 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1029 ) {
1030 match _t {
1031 alloy_sol_types::private::AssertTypeEq::<
1032 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1033 >(_) => {}
1034 }
1035 }
1036 #[automatically_derived]
1037 #[doc(hidden)]
1038 impl ::core::convert::From<InvalidOutputsMerkleRoot>
1039 for UnderlyingRustTuple<'_> {
1040 fn from(value: InvalidOutputsMerkleRoot) -> Self {
1041 (value.outputsMerkleRoot,)
1042 }
1043 }
1044 #[automatically_derived]
1045 #[doc(hidden)]
1046 impl ::core::convert::From<UnderlyingRustTuple<'_>>
1047 for InvalidOutputsMerkleRoot {
1048 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1049 Self { outputsMerkleRoot: tuple.0 }
1050 }
1051 }
1052 #[automatically_derived]
1053 impl alloy_sol_types::SolError for InvalidOutputsMerkleRoot {
1054 type Parameters<'a> = UnderlyingSolTuple<'a>;
1055 type Token<'a> = <Self::Parameters<
1056 'a,
1057 > as alloy_sol_types::SolType>::Token<'a>;
1058 const SIGNATURE: &'static str = "InvalidOutputsMerkleRoot(bytes32)";
1059 const SELECTOR: [u8; 4] = [68u8, 161u8, 146u8, 255u8];
1060 #[inline]
1061 fn new<'a>(
1062 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
1063 ) -> Self {
1064 tuple.into()
1065 }
1066 #[inline]
1067 fn tokenize(&self) -> Self::Token<'_> {
1068 (
1069 <alloy::sol_types::sol_data::FixedBytes<
1070 32,
1071 > as alloy_sol_types::SolType>::tokenize(&self.outputsMerkleRoot),
1072 )
1073 }
1074 #[inline]
1075 fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
1076 <Self::Parameters<
1077 '_,
1078 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
1079 .map(Self::new)
1080 }
1081 }
1082 };
1083 #[derive(serde::Serialize, serde::Deserialize)]
1084 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1085 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1090 #[derive(Clone)]
1091 pub struct OutputNotExecutable {
1092 #[allow(missing_docs)]
1093 pub output: alloy::sol_types::private::Bytes,
1094 }
1095 #[allow(
1096 non_camel_case_types,
1097 non_snake_case,
1098 clippy::pub_underscore_fields,
1099 clippy::style
1100 )]
1101 const _: () = {
1102 use alloy::sol_types as alloy_sol_types;
1103 #[doc(hidden)]
1104 #[allow(dead_code)]
1105 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Bytes,);
1106 #[doc(hidden)]
1107 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Bytes,);
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<OutputNotExecutable> for UnderlyingRustTuple<'_> {
1122 fn from(value: OutputNotExecutable) -> Self {
1123 (value.output,)
1124 }
1125 }
1126 #[automatically_derived]
1127 #[doc(hidden)]
1128 impl ::core::convert::From<UnderlyingRustTuple<'_>> for OutputNotExecutable {
1129 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1130 Self { output: tuple.0 }
1131 }
1132 }
1133 #[automatically_derived]
1134 impl alloy_sol_types::SolError for OutputNotExecutable {
1135 type Parameters<'a> = UnderlyingSolTuple<'a>;
1136 type Token<'a> = <Self::Parameters<
1137 'a,
1138 > as alloy_sol_types::SolType>::Token<'a>;
1139 const SIGNATURE: &'static str = "OutputNotExecutable(bytes)";
1140 const SELECTOR: [u8; 4] = [210u8, 132u8, 192u8, 30u8];
1141 #[inline]
1142 fn new<'a>(
1143 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
1144 ) -> Self {
1145 tuple.into()
1146 }
1147 #[inline]
1148 fn tokenize(&self) -> Self::Token<'_> {
1149 (
1150 <alloy::sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
1151 &self.output,
1152 ),
1153 )
1154 }
1155 #[inline]
1156 fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
1157 <Self::Parameters<
1158 '_,
1159 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
1160 .map(Self::new)
1161 }
1162 }
1163 };
1164 #[derive(serde::Serialize, serde::Deserialize)]
1165 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1166 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1171 #[derive(Clone)]
1172 pub struct OutputNotReexecutable {
1173 #[allow(missing_docs)]
1174 pub output: alloy::sol_types::private::Bytes,
1175 }
1176 #[allow(
1177 non_camel_case_types,
1178 non_snake_case,
1179 clippy::pub_underscore_fields,
1180 clippy::style
1181 )]
1182 const _: () = {
1183 use alloy::sol_types as alloy_sol_types;
1184 #[doc(hidden)]
1185 #[allow(dead_code)]
1186 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Bytes,);
1187 #[doc(hidden)]
1188 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Bytes,);
1189 #[cfg(test)]
1190 #[allow(dead_code, unreachable_patterns)]
1191 fn _type_assertion(
1192 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1193 ) {
1194 match _t {
1195 alloy_sol_types::private::AssertTypeEq::<
1196 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1197 >(_) => {}
1198 }
1199 }
1200 #[automatically_derived]
1201 #[doc(hidden)]
1202 impl ::core::convert::From<OutputNotReexecutable> for UnderlyingRustTuple<'_> {
1203 fn from(value: OutputNotReexecutable) -> Self {
1204 (value.output,)
1205 }
1206 }
1207 #[automatically_derived]
1208 #[doc(hidden)]
1209 impl ::core::convert::From<UnderlyingRustTuple<'_>> for OutputNotReexecutable {
1210 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1211 Self { output: tuple.0 }
1212 }
1213 }
1214 #[automatically_derived]
1215 impl alloy_sol_types::SolError for OutputNotReexecutable {
1216 type Parameters<'a> = UnderlyingSolTuple<'a>;
1217 type Token<'a> = <Self::Parameters<
1218 'a,
1219 > as alloy_sol_types::SolType>::Token<'a>;
1220 const SIGNATURE: &'static str = "OutputNotReexecutable(bytes)";
1221 const SELECTOR: [u8; 4] = [123u8, 151u8, 166u8, 187u8];
1222 #[inline]
1223 fn new<'a>(
1224 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
1225 ) -> Self {
1226 tuple.into()
1227 }
1228 #[inline]
1229 fn tokenize(&self) -> Self::Token<'_> {
1230 (
1231 <alloy::sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
1232 &self.output,
1233 ),
1234 )
1235 }
1236 #[inline]
1237 fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
1238 <Self::Parameters<
1239 '_,
1240 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
1241 .map(Self::new)
1242 }
1243 }
1244 };
1245 #[derive(serde::Serialize, serde::Deserialize)]
1246 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1247 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1252 #[derive(Clone)]
1253 pub struct OwnableInvalidOwner {
1254 #[allow(missing_docs)]
1255 pub owner: alloy::sol_types::private::Address,
1256 }
1257 #[allow(
1258 non_camel_case_types,
1259 non_snake_case,
1260 clippy::pub_underscore_fields,
1261 clippy::style
1262 )]
1263 const _: () = {
1264 use alloy::sol_types as alloy_sol_types;
1265 #[doc(hidden)]
1266 #[allow(dead_code)]
1267 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
1268 #[doc(hidden)]
1269 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
1270 #[cfg(test)]
1271 #[allow(dead_code, unreachable_patterns)]
1272 fn _type_assertion(
1273 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1274 ) {
1275 match _t {
1276 alloy_sol_types::private::AssertTypeEq::<
1277 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1278 >(_) => {}
1279 }
1280 }
1281 #[automatically_derived]
1282 #[doc(hidden)]
1283 impl ::core::convert::From<OwnableInvalidOwner> for UnderlyingRustTuple<'_> {
1284 fn from(value: OwnableInvalidOwner) -> Self {
1285 (value.owner,)
1286 }
1287 }
1288 #[automatically_derived]
1289 #[doc(hidden)]
1290 impl ::core::convert::From<UnderlyingRustTuple<'_>> for OwnableInvalidOwner {
1291 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1292 Self { owner: tuple.0 }
1293 }
1294 }
1295 #[automatically_derived]
1296 impl alloy_sol_types::SolError for OwnableInvalidOwner {
1297 type Parameters<'a> = UnderlyingSolTuple<'a>;
1298 type Token<'a> = <Self::Parameters<
1299 'a,
1300 > as alloy_sol_types::SolType>::Token<'a>;
1301 const SIGNATURE: &'static str = "OwnableInvalidOwner(address)";
1302 const SELECTOR: [u8; 4] = [30u8, 79u8, 189u8, 247u8];
1303 #[inline]
1304 fn new<'a>(
1305 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
1306 ) -> Self {
1307 tuple.into()
1308 }
1309 #[inline]
1310 fn tokenize(&self) -> Self::Token<'_> {
1311 (
1312 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
1313 &self.owner,
1314 ),
1315 )
1316 }
1317 #[inline]
1318 fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
1319 <Self::Parameters<
1320 '_,
1321 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
1322 .map(Self::new)
1323 }
1324 }
1325 };
1326 #[derive(serde::Serialize, serde::Deserialize)]
1327 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1328 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1333 #[derive(Clone)]
1334 pub struct OwnableUnauthorizedAccount {
1335 #[allow(missing_docs)]
1336 pub account: alloy::sol_types::private::Address,
1337 }
1338 #[allow(
1339 non_camel_case_types,
1340 non_snake_case,
1341 clippy::pub_underscore_fields,
1342 clippy::style
1343 )]
1344 const _: () = {
1345 use alloy::sol_types as alloy_sol_types;
1346 #[doc(hidden)]
1347 #[allow(dead_code)]
1348 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
1349 #[doc(hidden)]
1350 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
1351 #[cfg(test)]
1352 #[allow(dead_code, unreachable_patterns)]
1353 fn _type_assertion(
1354 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1355 ) {
1356 match _t {
1357 alloy_sol_types::private::AssertTypeEq::<
1358 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1359 >(_) => {}
1360 }
1361 }
1362 #[automatically_derived]
1363 #[doc(hidden)]
1364 impl ::core::convert::From<OwnableUnauthorizedAccount>
1365 for UnderlyingRustTuple<'_> {
1366 fn from(value: OwnableUnauthorizedAccount) -> Self {
1367 (value.account,)
1368 }
1369 }
1370 #[automatically_derived]
1371 #[doc(hidden)]
1372 impl ::core::convert::From<UnderlyingRustTuple<'_>>
1373 for OwnableUnauthorizedAccount {
1374 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1375 Self { account: tuple.0 }
1376 }
1377 }
1378 #[automatically_derived]
1379 impl alloy_sol_types::SolError for OwnableUnauthorizedAccount {
1380 type Parameters<'a> = UnderlyingSolTuple<'a>;
1381 type Token<'a> = <Self::Parameters<
1382 'a,
1383 > as alloy_sol_types::SolType>::Token<'a>;
1384 const SIGNATURE: &'static str = "OwnableUnauthorizedAccount(address)";
1385 const SELECTOR: [u8; 4] = [17u8, 140u8, 218u8, 167u8];
1386 #[inline]
1387 fn new<'a>(
1388 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
1389 ) -> Self {
1390 tuple.into()
1391 }
1392 #[inline]
1393 fn tokenize(&self) -> Self::Token<'_> {
1394 (
1395 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
1396 &self.account,
1397 ),
1398 )
1399 }
1400 #[inline]
1401 fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
1402 <Self::Parameters<
1403 '_,
1404 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
1405 .map(Self::new)
1406 }
1407 }
1408 };
1409 #[derive(serde::Serialize, serde::Deserialize)]
1410 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1411 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1416 #[derive(Clone)]
1417 pub struct ReentrancyGuardReentrantCall;
1418 #[allow(
1419 non_camel_case_types,
1420 non_snake_case,
1421 clippy::pub_underscore_fields,
1422 clippy::style
1423 )]
1424 const _: () = {
1425 use alloy::sol_types as alloy_sol_types;
1426 #[doc(hidden)]
1427 #[allow(dead_code)]
1428 type UnderlyingSolTuple<'a> = ();
1429 #[doc(hidden)]
1430 type UnderlyingRustTuple<'a> = ();
1431 #[cfg(test)]
1432 #[allow(dead_code, unreachable_patterns)]
1433 fn _type_assertion(
1434 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1435 ) {
1436 match _t {
1437 alloy_sol_types::private::AssertTypeEq::<
1438 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1439 >(_) => {}
1440 }
1441 }
1442 #[automatically_derived]
1443 #[doc(hidden)]
1444 impl ::core::convert::From<ReentrancyGuardReentrantCall>
1445 for UnderlyingRustTuple<'_> {
1446 fn from(value: ReentrancyGuardReentrantCall) -> Self {
1447 ()
1448 }
1449 }
1450 #[automatically_derived]
1451 #[doc(hidden)]
1452 impl ::core::convert::From<UnderlyingRustTuple<'_>>
1453 for ReentrancyGuardReentrantCall {
1454 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1455 Self
1456 }
1457 }
1458 #[automatically_derived]
1459 impl alloy_sol_types::SolError for ReentrancyGuardReentrantCall {
1460 type Parameters<'a> = UnderlyingSolTuple<'a>;
1461 type Token<'a> = <Self::Parameters<
1462 'a,
1463 > as alloy_sol_types::SolType>::Token<'a>;
1464 const SIGNATURE: &'static str = "ReentrancyGuardReentrantCall()";
1465 const SELECTOR: [u8; 4] = [62u8, 229u8, 174u8, 181u8];
1466 #[inline]
1467 fn new<'a>(
1468 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
1469 ) -> Self {
1470 tuple.into()
1471 }
1472 #[inline]
1473 fn tokenize(&self) -> Self::Token<'_> {
1474 ()
1475 }
1476 #[inline]
1477 fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
1478 <Self::Parameters<
1479 '_,
1480 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
1481 .map(Self::new)
1482 }
1483 }
1484 };
1485 #[derive(serde::Serialize, serde::Deserialize)]
1486 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1487 #[allow(
1492 non_camel_case_types,
1493 non_snake_case,
1494 clippy::pub_underscore_fields,
1495 clippy::style
1496 )]
1497 #[derive(Clone)]
1498 pub struct OutputExecuted {
1499 #[allow(missing_docs)]
1500 pub outputIndex: u64,
1501 #[allow(missing_docs)]
1502 pub output: alloy::sol_types::private::Bytes,
1503 }
1504 #[allow(
1505 non_camel_case_types,
1506 non_snake_case,
1507 clippy::pub_underscore_fields,
1508 clippy::style
1509 )]
1510 const _: () = {
1511 use alloy::sol_types as alloy_sol_types;
1512 #[automatically_derived]
1513 impl alloy_sol_types::SolEvent for OutputExecuted {
1514 type DataTuple<'a> = (
1515 alloy::sol_types::sol_data::Uint<64>,
1516 alloy::sol_types::sol_data::Bytes,
1517 );
1518 type DataToken<'a> = <Self::DataTuple<
1519 'a,
1520 > as alloy_sol_types::SolType>::Token<'a>;
1521 type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,);
1522 const SIGNATURE: &'static str = "OutputExecuted(uint64,bytes)";
1523 const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([
1524 202u8, 209u8, 243u8, 97u8, 198u8, 232u8, 70u8, 100u8, 232u8, 146u8, 35u8,
1525 2u8, 145u8, 200u8, 232u8, 235u8, 149u8, 85u8, 104u8, 62u8, 10u8, 106u8,
1526 92u8, 232u8, 234u8, 123u8, 32u8, 74u8, 192u8, 172u8, 54u8, 118u8,
1527 ]);
1528 const ANONYMOUS: bool = false;
1529 #[allow(unused_variables)]
1530 #[inline]
1531 fn new(
1532 topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
1533 data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
1534 ) -> Self {
1535 Self {
1536 outputIndex: data.0,
1537 output: data.1,
1538 }
1539 }
1540 #[inline]
1541 fn check_signature(
1542 topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
1543 ) -> alloy_sol_types::Result<()> {
1544 if topics.0 != Self::SIGNATURE_HASH {
1545 return Err(
1546 alloy_sol_types::Error::invalid_event_signature_hash(
1547 Self::SIGNATURE,
1548 topics.0,
1549 Self::SIGNATURE_HASH,
1550 ),
1551 );
1552 }
1553 Ok(())
1554 }
1555 #[inline]
1556 fn tokenize_body(&self) -> Self::DataToken<'_> {
1557 (
1558 <alloy::sol_types::sol_data::Uint<
1559 64,
1560 > as alloy_sol_types::SolType>::tokenize(&self.outputIndex),
1561 <alloy::sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
1562 &self.output,
1563 ),
1564 )
1565 }
1566 #[inline]
1567 fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
1568 (Self::SIGNATURE_HASH.into(),)
1569 }
1570 #[inline]
1571 fn encode_topics_raw(
1572 &self,
1573 out: &mut [alloy_sol_types::abi::token::WordToken],
1574 ) -> alloy_sol_types::Result<()> {
1575 if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
1576 return Err(alloy_sol_types::Error::Overrun);
1577 }
1578 out[0usize] = alloy_sol_types::abi::token::WordToken(
1579 Self::SIGNATURE_HASH,
1580 );
1581 Ok(())
1582 }
1583 }
1584 #[automatically_derived]
1585 impl alloy_sol_types::private::IntoLogData for OutputExecuted {
1586 fn to_log_data(&self) -> alloy_sol_types::private::LogData {
1587 From::from(self)
1588 }
1589 fn into_log_data(self) -> alloy_sol_types::private::LogData {
1590 From::from(&self)
1591 }
1592 }
1593 #[automatically_derived]
1594 impl From<&OutputExecuted> for alloy_sol_types::private::LogData {
1595 #[inline]
1596 fn from(this: &OutputExecuted) -> alloy_sol_types::private::LogData {
1597 alloy_sol_types::SolEvent::encode_log_data(this)
1598 }
1599 }
1600 };
1601 #[derive(serde::Serialize, serde::Deserialize)]
1602 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1603 #[allow(
1608 non_camel_case_types,
1609 non_snake_case,
1610 clippy::pub_underscore_fields,
1611 clippy::style
1612 )]
1613 #[derive(Clone)]
1614 pub struct OutputsMerkleRootValidatorChanged {
1615 #[allow(missing_docs)]
1616 pub newOutputsMerkleRootValidator: alloy::sol_types::private::Address,
1617 }
1618 #[allow(
1619 non_camel_case_types,
1620 non_snake_case,
1621 clippy::pub_underscore_fields,
1622 clippy::style
1623 )]
1624 const _: () = {
1625 use alloy::sol_types as alloy_sol_types;
1626 #[automatically_derived]
1627 impl alloy_sol_types::SolEvent for OutputsMerkleRootValidatorChanged {
1628 type DataTuple<'a> = (alloy::sol_types::sol_data::Address,);
1629 type DataToken<'a> = <Self::DataTuple<
1630 'a,
1631 > as alloy_sol_types::SolType>::Token<'a>;
1632 type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,);
1633 const SIGNATURE: &'static str = "OutputsMerkleRootValidatorChanged(address)";
1634 const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([
1635 106u8, 211u8, 24u8, 139u8, 168u8, 244u8, 48u8, 251u8, 160u8, 101u8,
1636 108u8, 176u8, 167u8, 232u8, 57u8, 171u8, 32u8, 32u8, 213u8, 88u8, 107u8,
1637 161u8, 26u8, 20u8, 119u8, 209u8, 143u8, 112u8, 146u8, 248u8, 190u8, 206u8,
1638 ]);
1639 const ANONYMOUS: bool = false;
1640 #[allow(unused_variables)]
1641 #[inline]
1642 fn new(
1643 topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
1644 data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
1645 ) -> Self {
1646 Self {
1647 newOutputsMerkleRootValidator: data.0,
1648 }
1649 }
1650 #[inline]
1651 fn check_signature(
1652 topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
1653 ) -> alloy_sol_types::Result<()> {
1654 if topics.0 != Self::SIGNATURE_HASH {
1655 return Err(
1656 alloy_sol_types::Error::invalid_event_signature_hash(
1657 Self::SIGNATURE,
1658 topics.0,
1659 Self::SIGNATURE_HASH,
1660 ),
1661 );
1662 }
1663 Ok(())
1664 }
1665 #[inline]
1666 fn tokenize_body(&self) -> Self::DataToken<'_> {
1667 (
1668 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
1669 &self.newOutputsMerkleRootValidator,
1670 ),
1671 )
1672 }
1673 #[inline]
1674 fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
1675 (Self::SIGNATURE_HASH.into(),)
1676 }
1677 #[inline]
1678 fn encode_topics_raw(
1679 &self,
1680 out: &mut [alloy_sol_types::abi::token::WordToken],
1681 ) -> alloy_sol_types::Result<()> {
1682 if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
1683 return Err(alloy_sol_types::Error::Overrun);
1684 }
1685 out[0usize] = alloy_sol_types::abi::token::WordToken(
1686 Self::SIGNATURE_HASH,
1687 );
1688 Ok(())
1689 }
1690 }
1691 #[automatically_derived]
1692 impl alloy_sol_types::private::IntoLogData
1693 for OutputsMerkleRootValidatorChanged {
1694 fn to_log_data(&self) -> alloy_sol_types::private::LogData {
1695 From::from(self)
1696 }
1697 fn into_log_data(self) -> alloy_sol_types::private::LogData {
1698 From::from(&self)
1699 }
1700 }
1701 #[automatically_derived]
1702 impl From<&OutputsMerkleRootValidatorChanged>
1703 for alloy_sol_types::private::LogData {
1704 #[inline]
1705 fn from(
1706 this: &OutputsMerkleRootValidatorChanged,
1707 ) -> alloy_sol_types::private::LogData {
1708 alloy_sol_types::SolEvent::encode_log_data(this)
1709 }
1710 }
1711 };
1712 #[derive(serde::Serialize, serde::Deserialize)]
1713 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1714 #[allow(
1719 non_camel_case_types,
1720 non_snake_case,
1721 clippy::pub_underscore_fields,
1722 clippy::style
1723 )]
1724 #[derive(Clone)]
1725 pub struct OwnershipTransferred {
1726 #[allow(missing_docs)]
1727 pub previousOwner: alloy::sol_types::private::Address,
1728 #[allow(missing_docs)]
1729 pub newOwner: alloy::sol_types::private::Address,
1730 }
1731 #[allow(
1732 non_camel_case_types,
1733 non_snake_case,
1734 clippy::pub_underscore_fields,
1735 clippy::style
1736 )]
1737 const _: () = {
1738 use alloy::sol_types as alloy_sol_types;
1739 #[automatically_derived]
1740 impl alloy_sol_types::SolEvent for OwnershipTransferred {
1741 type DataTuple<'a> = ();
1742 type DataToken<'a> = <Self::DataTuple<
1743 'a,
1744 > as alloy_sol_types::SolType>::Token<'a>;
1745 type TopicList = (
1746 alloy_sol_types::sol_data::FixedBytes<32>,
1747 alloy::sol_types::sol_data::Address,
1748 alloy::sol_types::sol_data::Address,
1749 );
1750 const SIGNATURE: &'static str = "OwnershipTransferred(address,address)";
1751 const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([
1752 139u8, 224u8, 7u8, 156u8, 83u8, 22u8, 89u8, 20u8, 19u8, 68u8, 205u8,
1753 31u8, 208u8, 164u8, 242u8, 132u8, 25u8, 73u8, 127u8, 151u8, 34u8, 163u8,
1754 218u8, 175u8, 227u8, 180u8, 24u8, 111u8, 107u8, 100u8, 87u8, 224u8,
1755 ]);
1756 const ANONYMOUS: bool = false;
1757 #[allow(unused_variables)]
1758 #[inline]
1759 fn new(
1760 topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
1761 data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
1762 ) -> Self {
1763 Self {
1764 previousOwner: topics.1,
1765 newOwner: topics.2,
1766 }
1767 }
1768 #[inline]
1769 fn check_signature(
1770 topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
1771 ) -> alloy_sol_types::Result<()> {
1772 if topics.0 != Self::SIGNATURE_HASH {
1773 return Err(
1774 alloy_sol_types::Error::invalid_event_signature_hash(
1775 Self::SIGNATURE,
1776 topics.0,
1777 Self::SIGNATURE_HASH,
1778 ),
1779 );
1780 }
1781 Ok(())
1782 }
1783 #[inline]
1784 fn tokenize_body(&self) -> Self::DataToken<'_> {
1785 ()
1786 }
1787 #[inline]
1788 fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
1789 (
1790 Self::SIGNATURE_HASH.into(),
1791 self.previousOwner.clone(),
1792 self.newOwner.clone(),
1793 )
1794 }
1795 #[inline]
1796 fn encode_topics_raw(
1797 &self,
1798 out: &mut [alloy_sol_types::abi::token::WordToken],
1799 ) -> alloy_sol_types::Result<()> {
1800 if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
1801 return Err(alloy_sol_types::Error::Overrun);
1802 }
1803 out[0usize] = alloy_sol_types::abi::token::WordToken(
1804 Self::SIGNATURE_HASH,
1805 );
1806 out[1usize] = <alloy::sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
1807 &self.previousOwner,
1808 );
1809 out[2usize] = <alloy::sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
1810 &self.newOwner,
1811 );
1812 Ok(())
1813 }
1814 }
1815 #[automatically_derived]
1816 impl alloy_sol_types::private::IntoLogData for OwnershipTransferred {
1817 fn to_log_data(&self) -> alloy_sol_types::private::LogData {
1818 From::from(self)
1819 }
1820 fn into_log_data(self) -> alloy_sol_types::private::LogData {
1821 From::from(&self)
1822 }
1823 }
1824 #[automatically_derived]
1825 impl From<&OwnershipTransferred> for alloy_sol_types::private::LogData {
1826 #[inline]
1827 fn from(this: &OwnershipTransferred) -> alloy_sol_types::private::LogData {
1828 alloy_sol_types::SolEvent::encode_log_data(this)
1829 }
1830 }
1831 };
1832 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1837 #[derive(Clone)]
1838 pub struct constructorCall {
1839 #[allow(missing_docs)]
1840 pub outputsMerkleRootValidator: alloy::sol_types::private::Address,
1841 #[allow(missing_docs)]
1842 pub initialOwner: alloy::sol_types::private::Address,
1843 #[allow(missing_docs)]
1844 pub templateHash: alloy::sol_types::private::FixedBytes<32>,
1845 #[allow(missing_docs)]
1846 pub dataAvailability: alloy::sol_types::private::Bytes,
1847 }
1848 const _: () = {
1849 use alloy::sol_types as alloy_sol_types;
1850 {
1851 #[doc(hidden)]
1852 #[allow(dead_code)]
1853 type UnderlyingSolTuple<'a> = (
1854 alloy::sol_types::sol_data::Address,
1855 alloy::sol_types::sol_data::Address,
1856 alloy::sol_types::sol_data::FixedBytes<32>,
1857 alloy::sol_types::sol_data::Bytes,
1858 );
1859 #[doc(hidden)]
1860 type UnderlyingRustTuple<'a> = (
1861 alloy::sol_types::private::Address,
1862 alloy::sol_types::private::Address,
1863 alloy::sol_types::private::FixedBytes<32>,
1864 alloy::sol_types::private::Bytes,
1865 );
1866 #[cfg(test)]
1867 #[allow(dead_code, unreachable_patterns)]
1868 fn _type_assertion(
1869 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1870 ) {
1871 match _t {
1872 alloy_sol_types::private::AssertTypeEq::<
1873 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1874 >(_) => {}
1875 }
1876 }
1877 #[automatically_derived]
1878 #[doc(hidden)]
1879 impl ::core::convert::From<constructorCall> for UnderlyingRustTuple<'_> {
1880 fn from(value: constructorCall) -> Self {
1881 (
1882 value.outputsMerkleRootValidator,
1883 value.initialOwner,
1884 value.templateHash,
1885 value.dataAvailability,
1886 )
1887 }
1888 }
1889 #[automatically_derived]
1890 #[doc(hidden)]
1891 impl ::core::convert::From<UnderlyingRustTuple<'_>> for constructorCall {
1892 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1893 Self {
1894 outputsMerkleRootValidator: tuple.0,
1895 initialOwner: tuple.1,
1896 templateHash: tuple.2,
1897 dataAvailability: tuple.3,
1898 }
1899 }
1900 }
1901 }
1902 #[automatically_derived]
1903 impl alloy_sol_types::SolConstructor for constructorCall {
1904 type Parameters<'a> = (
1905 alloy::sol_types::sol_data::Address,
1906 alloy::sol_types::sol_data::Address,
1907 alloy::sol_types::sol_data::FixedBytes<32>,
1908 alloy::sol_types::sol_data::Bytes,
1909 );
1910 type Token<'a> = <Self::Parameters<
1911 'a,
1912 > as alloy_sol_types::SolType>::Token<'a>;
1913 #[inline]
1914 fn new<'a>(
1915 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
1916 ) -> Self {
1917 tuple.into()
1918 }
1919 #[inline]
1920 fn tokenize(&self) -> Self::Token<'_> {
1921 (
1922 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
1923 &self.outputsMerkleRootValidator,
1924 ),
1925 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
1926 &self.initialOwner,
1927 ),
1928 <alloy::sol_types::sol_data::FixedBytes<
1929 32,
1930 > as alloy_sol_types::SolType>::tokenize(&self.templateHash),
1931 <alloy::sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
1932 &self.dataAvailability,
1933 ),
1934 )
1935 }
1936 }
1937 };
1938 #[derive(serde::Serialize, serde::Deserialize)]
1939 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1940 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1945 #[derive(Clone)]
1946 pub struct executeOutputCall {
1947 #[allow(missing_docs)]
1948 pub output: alloy::sol_types::private::Bytes,
1949 #[allow(missing_docs)]
1950 pub proof: <OutputValidityProof as alloy::sol_types::SolType>::RustType,
1951 }
1952 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1954 #[derive(Clone)]
1955 pub struct executeOutputReturn {}
1956 #[allow(
1957 non_camel_case_types,
1958 non_snake_case,
1959 clippy::pub_underscore_fields,
1960 clippy::style
1961 )]
1962 const _: () = {
1963 use alloy::sol_types as alloy_sol_types;
1964 {
1965 #[doc(hidden)]
1966 #[allow(dead_code)]
1967 type UnderlyingSolTuple<'a> = (
1968 alloy::sol_types::sol_data::Bytes,
1969 OutputValidityProof,
1970 );
1971 #[doc(hidden)]
1972 type UnderlyingRustTuple<'a> = (
1973 alloy::sol_types::private::Bytes,
1974 <OutputValidityProof as alloy::sol_types::SolType>::RustType,
1975 );
1976 #[cfg(test)]
1977 #[allow(dead_code, unreachable_patterns)]
1978 fn _type_assertion(
1979 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1980 ) {
1981 match _t {
1982 alloy_sol_types::private::AssertTypeEq::<
1983 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1984 >(_) => {}
1985 }
1986 }
1987 #[automatically_derived]
1988 #[doc(hidden)]
1989 impl ::core::convert::From<executeOutputCall> for UnderlyingRustTuple<'_> {
1990 fn from(value: executeOutputCall) -> Self {
1991 (value.output, value.proof)
1992 }
1993 }
1994 #[automatically_derived]
1995 #[doc(hidden)]
1996 impl ::core::convert::From<UnderlyingRustTuple<'_>> for executeOutputCall {
1997 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1998 Self {
1999 output: tuple.0,
2000 proof: tuple.1,
2001 }
2002 }
2003 }
2004 }
2005 {
2006 #[doc(hidden)]
2007 #[allow(dead_code)]
2008 type UnderlyingSolTuple<'a> = ();
2009 #[doc(hidden)]
2010 type UnderlyingRustTuple<'a> = ();
2011 #[cfg(test)]
2012 #[allow(dead_code, unreachable_patterns)]
2013 fn _type_assertion(
2014 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
2015 ) {
2016 match _t {
2017 alloy_sol_types::private::AssertTypeEq::<
2018 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2019 >(_) => {}
2020 }
2021 }
2022 #[automatically_derived]
2023 #[doc(hidden)]
2024 impl ::core::convert::From<executeOutputReturn> for UnderlyingRustTuple<'_> {
2025 fn from(value: executeOutputReturn) -> Self {
2026 ()
2027 }
2028 }
2029 #[automatically_derived]
2030 #[doc(hidden)]
2031 impl ::core::convert::From<UnderlyingRustTuple<'_>> for executeOutputReturn {
2032 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2033 Self {}
2034 }
2035 }
2036 }
2037 impl executeOutputReturn {
2038 fn _tokenize(
2039 &self,
2040 ) -> <executeOutputCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
2041 ()
2042 }
2043 }
2044 #[automatically_derived]
2045 impl alloy_sol_types::SolCall for executeOutputCall {
2046 type Parameters<'a> = (
2047 alloy::sol_types::sol_data::Bytes,
2048 OutputValidityProof,
2049 );
2050 type Token<'a> = <Self::Parameters<
2051 'a,
2052 > as alloy_sol_types::SolType>::Token<'a>;
2053 type Return = executeOutputReturn;
2054 type ReturnTuple<'a> = ();
2055 type ReturnToken<'a> = <Self::ReturnTuple<
2056 'a,
2057 > as alloy_sol_types::SolType>::Token<'a>;
2058 const SIGNATURE: &'static str = "executeOutput(bytes,(uint64,bytes32[]))";
2059 const SELECTOR: [u8; 4] = [51u8, 19u8, 123u8, 118u8];
2060 #[inline]
2061 fn new<'a>(
2062 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
2063 ) -> Self {
2064 tuple.into()
2065 }
2066 #[inline]
2067 fn tokenize(&self) -> Self::Token<'_> {
2068 (
2069 <alloy::sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
2070 &self.output,
2071 ),
2072 <OutputValidityProof as alloy_sol_types::SolType>::tokenize(
2073 &self.proof,
2074 ),
2075 )
2076 }
2077 #[inline]
2078 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
2079 executeOutputReturn::_tokenize(ret)
2080 }
2081 #[inline]
2082 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
2083 <Self::ReturnTuple<
2084 '_,
2085 > as alloy_sol_types::SolType>::abi_decode_sequence(data)
2086 .map(Into::into)
2087 }
2088 #[inline]
2089 fn abi_decode_returns_validate(
2090 data: &[u8],
2091 ) -> alloy_sol_types::Result<Self::Return> {
2092 <Self::ReturnTuple<
2093 '_,
2094 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
2095 .map(Into::into)
2096 }
2097 }
2098 };
2099 #[derive(serde::Serialize, serde::Deserialize)]
2100 #[derive(Default, Debug, PartialEq, Eq, Hash)]
2101 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2106 #[derive(Clone)]
2107 pub struct getDataAvailabilityCall;
2108 #[derive(serde::Serialize, serde::Deserialize)]
2109 #[derive(Default, Debug, PartialEq, Eq, Hash)]
2110 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2112 #[derive(Clone)]
2113 pub struct getDataAvailabilityReturn {
2114 #[allow(missing_docs)]
2115 pub _0: alloy::sol_types::private::Bytes,
2116 }
2117 #[allow(
2118 non_camel_case_types,
2119 non_snake_case,
2120 clippy::pub_underscore_fields,
2121 clippy::style
2122 )]
2123 const _: () = {
2124 use alloy::sol_types as alloy_sol_types;
2125 {
2126 #[doc(hidden)]
2127 #[allow(dead_code)]
2128 type UnderlyingSolTuple<'a> = ();
2129 #[doc(hidden)]
2130 type UnderlyingRustTuple<'a> = ();
2131 #[cfg(test)]
2132 #[allow(dead_code, unreachable_patterns)]
2133 fn _type_assertion(
2134 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
2135 ) {
2136 match _t {
2137 alloy_sol_types::private::AssertTypeEq::<
2138 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2139 >(_) => {}
2140 }
2141 }
2142 #[automatically_derived]
2143 #[doc(hidden)]
2144 impl ::core::convert::From<getDataAvailabilityCall>
2145 for UnderlyingRustTuple<'_> {
2146 fn from(value: getDataAvailabilityCall) -> Self {
2147 ()
2148 }
2149 }
2150 #[automatically_derived]
2151 #[doc(hidden)]
2152 impl ::core::convert::From<UnderlyingRustTuple<'_>>
2153 for getDataAvailabilityCall {
2154 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2155 Self
2156 }
2157 }
2158 }
2159 {
2160 #[doc(hidden)]
2161 #[allow(dead_code)]
2162 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Bytes,);
2163 #[doc(hidden)]
2164 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Bytes,);
2165 #[cfg(test)]
2166 #[allow(dead_code, unreachable_patterns)]
2167 fn _type_assertion(
2168 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
2169 ) {
2170 match _t {
2171 alloy_sol_types::private::AssertTypeEq::<
2172 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2173 >(_) => {}
2174 }
2175 }
2176 #[automatically_derived]
2177 #[doc(hidden)]
2178 impl ::core::convert::From<getDataAvailabilityReturn>
2179 for UnderlyingRustTuple<'_> {
2180 fn from(value: getDataAvailabilityReturn) -> Self {
2181 (value._0,)
2182 }
2183 }
2184 #[automatically_derived]
2185 #[doc(hidden)]
2186 impl ::core::convert::From<UnderlyingRustTuple<'_>>
2187 for getDataAvailabilityReturn {
2188 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2189 Self { _0: tuple.0 }
2190 }
2191 }
2192 }
2193 #[automatically_derived]
2194 impl alloy_sol_types::SolCall for getDataAvailabilityCall {
2195 type Parameters<'a> = ();
2196 type Token<'a> = <Self::Parameters<
2197 'a,
2198 > as alloy_sol_types::SolType>::Token<'a>;
2199 type Return = alloy::sol_types::private::Bytes;
2200 type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bytes,);
2201 type ReturnToken<'a> = <Self::ReturnTuple<
2202 'a,
2203 > as alloy_sol_types::SolType>::Token<'a>;
2204 const SIGNATURE: &'static str = "getDataAvailability()";
2205 const SELECTOR: [u8; 4] = [240u8, 36u8, 120u8, 222u8];
2206 #[inline]
2207 fn new<'a>(
2208 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
2209 ) -> Self {
2210 tuple.into()
2211 }
2212 #[inline]
2213 fn tokenize(&self) -> Self::Token<'_> {
2214 ()
2215 }
2216 #[inline]
2217 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
2218 (
2219 <alloy::sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
2220 ret,
2221 ),
2222 )
2223 }
2224 #[inline]
2225 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
2226 <Self::ReturnTuple<
2227 '_,
2228 > as alloy_sol_types::SolType>::abi_decode_sequence(data)
2229 .map(|r| {
2230 let r: getDataAvailabilityReturn = r.into();
2231 r._0
2232 })
2233 }
2234 #[inline]
2235 fn abi_decode_returns_validate(
2236 data: &[u8],
2237 ) -> alloy_sol_types::Result<Self::Return> {
2238 <Self::ReturnTuple<
2239 '_,
2240 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
2241 .map(|r| {
2242 let r: getDataAvailabilityReturn = r.into();
2243 r._0
2244 })
2245 }
2246 }
2247 };
2248 #[derive(serde::Serialize, serde::Deserialize)]
2249 #[derive(Default, Debug, PartialEq, Eq, Hash)]
2250 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2255 #[derive(Clone)]
2256 pub struct getDeploymentBlockNumberCall;
2257 #[derive(serde::Serialize, serde::Deserialize)]
2258 #[derive(Default, Debug, PartialEq, Eq, Hash)]
2259 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2261 #[derive(Clone)]
2262 pub struct getDeploymentBlockNumberReturn {
2263 #[allow(missing_docs)]
2264 pub _0: alloy::sol_types::private::primitives::aliases::U256,
2265 }
2266 #[allow(
2267 non_camel_case_types,
2268 non_snake_case,
2269 clippy::pub_underscore_fields,
2270 clippy::style
2271 )]
2272 const _: () = {
2273 use alloy::sol_types as alloy_sol_types;
2274 {
2275 #[doc(hidden)]
2276 #[allow(dead_code)]
2277 type UnderlyingSolTuple<'a> = ();
2278 #[doc(hidden)]
2279 type UnderlyingRustTuple<'a> = ();
2280 #[cfg(test)]
2281 #[allow(dead_code, unreachable_patterns)]
2282 fn _type_assertion(
2283 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
2284 ) {
2285 match _t {
2286 alloy_sol_types::private::AssertTypeEq::<
2287 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2288 >(_) => {}
2289 }
2290 }
2291 #[automatically_derived]
2292 #[doc(hidden)]
2293 impl ::core::convert::From<getDeploymentBlockNumberCall>
2294 for UnderlyingRustTuple<'_> {
2295 fn from(value: getDeploymentBlockNumberCall) -> Self {
2296 ()
2297 }
2298 }
2299 #[automatically_derived]
2300 #[doc(hidden)]
2301 impl ::core::convert::From<UnderlyingRustTuple<'_>>
2302 for getDeploymentBlockNumberCall {
2303 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2304 Self
2305 }
2306 }
2307 }
2308 {
2309 #[doc(hidden)]
2310 #[allow(dead_code)]
2311 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
2312 #[doc(hidden)]
2313 type UnderlyingRustTuple<'a> = (
2314 alloy::sol_types::private::primitives::aliases::U256,
2315 );
2316 #[cfg(test)]
2317 #[allow(dead_code, unreachable_patterns)]
2318 fn _type_assertion(
2319 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
2320 ) {
2321 match _t {
2322 alloy_sol_types::private::AssertTypeEq::<
2323 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2324 >(_) => {}
2325 }
2326 }
2327 #[automatically_derived]
2328 #[doc(hidden)]
2329 impl ::core::convert::From<getDeploymentBlockNumberReturn>
2330 for UnderlyingRustTuple<'_> {
2331 fn from(value: getDeploymentBlockNumberReturn) -> Self {
2332 (value._0,)
2333 }
2334 }
2335 #[automatically_derived]
2336 #[doc(hidden)]
2337 impl ::core::convert::From<UnderlyingRustTuple<'_>>
2338 for getDeploymentBlockNumberReturn {
2339 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2340 Self { _0: tuple.0 }
2341 }
2342 }
2343 }
2344 #[automatically_derived]
2345 impl alloy_sol_types::SolCall for getDeploymentBlockNumberCall {
2346 type Parameters<'a> = ();
2347 type Token<'a> = <Self::Parameters<
2348 'a,
2349 > as alloy_sol_types::SolType>::Token<'a>;
2350 type Return = alloy::sol_types::private::primitives::aliases::U256;
2351 type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
2352 type ReturnToken<'a> = <Self::ReturnTuple<
2353 'a,
2354 > as alloy_sol_types::SolType>::Token<'a>;
2355 const SIGNATURE: &'static str = "getDeploymentBlockNumber()";
2356 const SELECTOR: [u8; 4] = [179u8, 161u8, 172u8, 216u8];
2357 #[inline]
2358 fn new<'a>(
2359 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
2360 ) -> Self {
2361 tuple.into()
2362 }
2363 #[inline]
2364 fn tokenize(&self) -> Self::Token<'_> {
2365 ()
2366 }
2367 #[inline]
2368 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
2369 (
2370 <alloy::sol_types::sol_data::Uint<
2371 256,
2372 > as alloy_sol_types::SolType>::tokenize(ret),
2373 )
2374 }
2375 #[inline]
2376 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
2377 <Self::ReturnTuple<
2378 '_,
2379 > as alloy_sol_types::SolType>::abi_decode_sequence(data)
2380 .map(|r| {
2381 let r: getDeploymentBlockNumberReturn = r.into();
2382 r._0
2383 })
2384 }
2385 #[inline]
2386 fn abi_decode_returns_validate(
2387 data: &[u8],
2388 ) -> alloy_sol_types::Result<Self::Return> {
2389 <Self::ReturnTuple<
2390 '_,
2391 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
2392 .map(|r| {
2393 let r: getDeploymentBlockNumberReturn = r.into();
2394 r._0
2395 })
2396 }
2397 }
2398 };
2399 #[derive(serde::Serialize, serde::Deserialize)]
2400 #[derive(Default, Debug, PartialEq, Eq, Hash)]
2401 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2406 #[derive(Clone)]
2407 pub struct getNumberOfExecutedOutputsCall;
2408 #[derive(serde::Serialize, serde::Deserialize)]
2409 #[derive(Default, Debug, PartialEq, Eq, Hash)]
2410 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2412 #[derive(Clone)]
2413 pub struct getNumberOfExecutedOutputsReturn {
2414 #[allow(missing_docs)]
2415 pub _0: alloy::sol_types::private::primitives::aliases::U256,
2416 }
2417 #[allow(
2418 non_camel_case_types,
2419 non_snake_case,
2420 clippy::pub_underscore_fields,
2421 clippy::style
2422 )]
2423 const _: () = {
2424 use alloy::sol_types as alloy_sol_types;
2425 {
2426 #[doc(hidden)]
2427 #[allow(dead_code)]
2428 type UnderlyingSolTuple<'a> = ();
2429 #[doc(hidden)]
2430 type UnderlyingRustTuple<'a> = ();
2431 #[cfg(test)]
2432 #[allow(dead_code, unreachable_patterns)]
2433 fn _type_assertion(
2434 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
2435 ) {
2436 match _t {
2437 alloy_sol_types::private::AssertTypeEq::<
2438 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2439 >(_) => {}
2440 }
2441 }
2442 #[automatically_derived]
2443 #[doc(hidden)]
2444 impl ::core::convert::From<getNumberOfExecutedOutputsCall>
2445 for UnderlyingRustTuple<'_> {
2446 fn from(value: getNumberOfExecutedOutputsCall) -> Self {
2447 ()
2448 }
2449 }
2450 #[automatically_derived]
2451 #[doc(hidden)]
2452 impl ::core::convert::From<UnderlyingRustTuple<'_>>
2453 for getNumberOfExecutedOutputsCall {
2454 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2455 Self
2456 }
2457 }
2458 }
2459 {
2460 #[doc(hidden)]
2461 #[allow(dead_code)]
2462 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
2463 #[doc(hidden)]
2464 type UnderlyingRustTuple<'a> = (
2465 alloy::sol_types::private::primitives::aliases::U256,
2466 );
2467 #[cfg(test)]
2468 #[allow(dead_code, unreachable_patterns)]
2469 fn _type_assertion(
2470 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
2471 ) {
2472 match _t {
2473 alloy_sol_types::private::AssertTypeEq::<
2474 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2475 >(_) => {}
2476 }
2477 }
2478 #[automatically_derived]
2479 #[doc(hidden)]
2480 impl ::core::convert::From<getNumberOfExecutedOutputsReturn>
2481 for UnderlyingRustTuple<'_> {
2482 fn from(value: getNumberOfExecutedOutputsReturn) -> Self {
2483 (value._0,)
2484 }
2485 }
2486 #[automatically_derived]
2487 #[doc(hidden)]
2488 impl ::core::convert::From<UnderlyingRustTuple<'_>>
2489 for getNumberOfExecutedOutputsReturn {
2490 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2491 Self { _0: tuple.0 }
2492 }
2493 }
2494 }
2495 #[automatically_derived]
2496 impl alloy_sol_types::SolCall for getNumberOfExecutedOutputsCall {
2497 type Parameters<'a> = ();
2498 type Token<'a> = <Self::Parameters<
2499 'a,
2500 > as alloy_sol_types::SolType>::Token<'a>;
2501 type Return = alloy::sol_types::private::primitives::aliases::U256;
2502 type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
2503 type ReturnToken<'a> = <Self::ReturnTuple<
2504 'a,
2505 > as alloy_sol_types::SolType>::Token<'a>;
2506 const SIGNATURE: &'static str = "getNumberOfExecutedOutputs()";
2507 const SELECTOR: [u8; 4] = [230u8, 79u8, 171u8, 77u8];
2508 #[inline]
2509 fn new<'a>(
2510 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
2511 ) -> Self {
2512 tuple.into()
2513 }
2514 #[inline]
2515 fn tokenize(&self) -> Self::Token<'_> {
2516 ()
2517 }
2518 #[inline]
2519 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
2520 (
2521 <alloy::sol_types::sol_data::Uint<
2522 256,
2523 > as alloy_sol_types::SolType>::tokenize(ret),
2524 )
2525 }
2526 #[inline]
2527 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
2528 <Self::ReturnTuple<
2529 '_,
2530 > as alloy_sol_types::SolType>::abi_decode_sequence(data)
2531 .map(|r| {
2532 let r: getNumberOfExecutedOutputsReturn = r.into();
2533 r._0
2534 })
2535 }
2536 #[inline]
2537 fn abi_decode_returns_validate(
2538 data: &[u8],
2539 ) -> alloy_sol_types::Result<Self::Return> {
2540 <Self::ReturnTuple<
2541 '_,
2542 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
2543 .map(|r| {
2544 let r: getNumberOfExecutedOutputsReturn = r.into();
2545 r._0
2546 })
2547 }
2548 }
2549 };
2550 #[derive(serde::Serialize, serde::Deserialize)]
2551 #[derive(Default, Debug, PartialEq, Eq, Hash)]
2552 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2557 #[derive(Clone)]
2558 pub struct getOutputsMerkleRootValidatorCall;
2559 #[derive(serde::Serialize, serde::Deserialize)]
2560 #[derive(Default, Debug, PartialEq, Eq, Hash)]
2561 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2563 #[derive(Clone)]
2564 pub struct getOutputsMerkleRootValidatorReturn {
2565 #[allow(missing_docs)]
2566 pub _0: alloy::sol_types::private::Address,
2567 }
2568 #[allow(
2569 non_camel_case_types,
2570 non_snake_case,
2571 clippy::pub_underscore_fields,
2572 clippy::style
2573 )]
2574 const _: () = {
2575 use alloy::sol_types as alloy_sol_types;
2576 {
2577 #[doc(hidden)]
2578 #[allow(dead_code)]
2579 type UnderlyingSolTuple<'a> = ();
2580 #[doc(hidden)]
2581 type UnderlyingRustTuple<'a> = ();
2582 #[cfg(test)]
2583 #[allow(dead_code, unreachable_patterns)]
2584 fn _type_assertion(
2585 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
2586 ) {
2587 match _t {
2588 alloy_sol_types::private::AssertTypeEq::<
2589 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2590 >(_) => {}
2591 }
2592 }
2593 #[automatically_derived]
2594 #[doc(hidden)]
2595 impl ::core::convert::From<getOutputsMerkleRootValidatorCall>
2596 for UnderlyingRustTuple<'_> {
2597 fn from(value: getOutputsMerkleRootValidatorCall) -> Self {
2598 ()
2599 }
2600 }
2601 #[automatically_derived]
2602 #[doc(hidden)]
2603 impl ::core::convert::From<UnderlyingRustTuple<'_>>
2604 for getOutputsMerkleRootValidatorCall {
2605 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2606 Self
2607 }
2608 }
2609 }
2610 {
2611 #[doc(hidden)]
2612 #[allow(dead_code)]
2613 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
2614 #[doc(hidden)]
2615 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
2616 #[cfg(test)]
2617 #[allow(dead_code, unreachable_patterns)]
2618 fn _type_assertion(
2619 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
2620 ) {
2621 match _t {
2622 alloy_sol_types::private::AssertTypeEq::<
2623 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2624 >(_) => {}
2625 }
2626 }
2627 #[automatically_derived]
2628 #[doc(hidden)]
2629 impl ::core::convert::From<getOutputsMerkleRootValidatorReturn>
2630 for UnderlyingRustTuple<'_> {
2631 fn from(value: getOutputsMerkleRootValidatorReturn) -> Self {
2632 (value._0,)
2633 }
2634 }
2635 #[automatically_derived]
2636 #[doc(hidden)]
2637 impl ::core::convert::From<UnderlyingRustTuple<'_>>
2638 for getOutputsMerkleRootValidatorReturn {
2639 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2640 Self { _0: tuple.0 }
2641 }
2642 }
2643 }
2644 #[automatically_derived]
2645 impl alloy_sol_types::SolCall for getOutputsMerkleRootValidatorCall {
2646 type Parameters<'a> = ();
2647 type Token<'a> = <Self::Parameters<
2648 'a,
2649 > as alloy_sol_types::SolType>::Token<'a>;
2650 type Return = alloy::sol_types::private::Address;
2651 type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,);
2652 type ReturnToken<'a> = <Self::ReturnTuple<
2653 'a,
2654 > as alloy_sol_types::SolType>::Token<'a>;
2655 const SIGNATURE: &'static str = "getOutputsMerkleRootValidator()";
2656 const SELECTOR: [u8; 4] = [169u8, 77u8, 252u8, 90u8];
2657 #[inline]
2658 fn new<'a>(
2659 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
2660 ) -> Self {
2661 tuple.into()
2662 }
2663 #[inline]
2664 fn tokenize(&self) -> Self::Token<'_> {
2665 ()
2666 }
2667 #[inline]
2668 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
2669 (
2670 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
2671 ret,
2672 ),
2673 )
2674 }
2675 #[inline]
2676 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
2677 <Self::ReturnTuple<
2678 '_,
2679 > as alloy_sol_types::SolType>::abi_decode_sequence(data)
2680 .map(|r| {
2681 let r: getOutputsMerkleRootValidatorReturn = r.into();
2682 r._0
2683 })
2684 }
2685 #[inline]
2686 fn abi_decode_returns_validate(
2687 data: &[u8],
2688 ) -> alloy_sol_types::Result<Self::Return> {
2689 <Self::ReturnTuple<
2690 '_,
2691 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
2692 .map(|r| {
2693 let r: getOutputsMerkleRootValidatorReturn = r.into();
2694 r._0
2695 })
2696 }
2697 }
2698 };
2699 #[derive(serde::Serialize, serde::Deserialize)]
2700 #[derive(Default, Debug, PartialEq, Eq, Hash)]
2701 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2706 #[derive(Clone)]
2707 pub struct getTemplateHashCall;
2708 #[derive(serde::Serialize, serde::Deserialize)]
2709 #[derive(Default, Debug, PartialEq, Eq, Hash)]
2710 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2712 #[derive(Clone)]
2713 pub struct getTemplateHashReturn {
2714 #[allow(missing_docs)]
2715 pub _0: alloy::sol_types::private::FixedBytes<32>,
2716 }
2717 #[allow(
2718 non_camel_case_types,
2719 non_snake_case,
2720 clippy::pub_underscore_fields,
2721 clippy::style
2722 )]
2723 const _: () = {
2724 use alloy::sol_types as alloy_sol_types;
2725 {
2726 #[doc(hidden)]
2727 #[allow(dead_code)]
2728 type UnderlyingSolTuple<'a> = ();
2729 #[doc(hidden)]
2730 type UnderlyingRustTuple<'a> = ();
2731 #[cfg(test)]
2732 #[allow(dead_code, unreachable_patterns)]
2733 fn _type_assertion(
2734 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
2735 ) {
2736 match _t {
2737 alloy_sol_types::private::AssertTypeEq::<
2738 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2739 >(_) => {}
2740 }
2741 }
2742 #[automatically_derived]
2743 #[doc(hidden)]
2744 impl ::core::convert::From<getTemplateHashCall> for UnderlyingRustTuple<'_> {
2745 fn from(value: getTemplateHashCall) -> Self {
2746 ()
2747 }
2748 }
2749 #[automatically_derived]
2750 #[doc(hidden)]
2751 impl ::core::convert::From<UnderlyingRustTuple<'_>> for getTemplateHashCall {
2752 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2753 Self
2754 }
2755 }
2756 }
2757 {
2758 #[doc(hidden)]
2759 #[allow(dead_code)]
2760 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,);
2761 #[doc(hidden)]
2762 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::FixedBytes<32>,);
2763 #[cfg(test)]
2764 #[allow(dead_code, unreachable_patterns)]
2765 fn _type_assertion(
2766 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
2767 ) {
2768 match _t {
2769 alloy_sol_types::private::AssertTypeEq::<
2770 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2771 >(_) => {}
2772 }
2773 }
2774 #[automatically_derived]
2775 #[doc(hidden)]
2776 impl ::core::convert::From<getTemplateHashReturn>
2777 for UnderlyingRustTuple<'_> {
2778 fn from(value: getTemplateHashReturn) -> Self {
2779 (value._0,)
2780 }
2781 }
2782 #[automatically_derived]
2783 #[doc(hidden)]
2784 impl ::core::convert::From<UnderlyingRustTuple<'_>>
2785 for getTemplateHashReturn {
2786 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2787 Self { _0: tuple.0 }
2788 }
2789 }
2790 }
2791 #[automatically_derived]
2792 impl alloy_sol_types::SolCall for getTemplateHashCall {
2793 type Parameters<'a> = ();
2794 type Token<'a> = <Self::Parameters<
2795 'a,
2796 > as alloy_sol_types::SolType>::Token<'a>;
2797 type Return = alloy::sol_types::private::FixedBytes<32>;
2798 type ReturnTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,);
2799 type ReturnToken<'a> = <Self::ReturnTuple<
2800 'a,
2801 > as alloy_sol_types::SolType>::Token<'a>;
2802 const SIGNATURE: &'static str = "getTemplateHash()";
2803 const SELECTOR: [u8; 4] = [97u8, 177u8, 44u8, 102u8];
2804 #[inline]
2805 fn new<'a>(
2806 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
2807 ) -> Self {
2808 tuple.into()
2809 }
2810 #[inline]
2811 fn tokenize(&self) -> Self::Token<'_> {
2812 ()
2813 }
2814 #[inline]
2815 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
2816 (
2817 <alloy::sol_types::sol_data::FixedBytes<
2818 32,
2819 > as alloy_sol_types::SolType>::tokenize(ret),
2820 )
2821 }
2822 #[inline]
2823 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
2824 <Self::ReturnTuple<
2825 '_,
2826 > as alloy_sol_types::SolType>::abi_decode_sequence(data)
2827 .map(|r| {
2828 let r: getTemplateHashReturn = r.into();
2829 r._0
2830 })
2831 }
2832 #[inline]
2833 fn abi_decode_returns_validate(
2834 data: &[u8],
2835 ) -> alloy_sol_types::Result<Self::Return> {
2836 <Self::ReturnTuple<
2837 '_,
2838 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
2839 .map(|r| {
2840 let r: getTemplateHashReturn = r.into();
2841 r._0
2842 })
2843 }
2844 }
2845 };
2846 #[derive(serde::Serialize, serde::Deserialize)]
2847 #[derive(Default, Debug, PartialEq, Eq, Hash)]
2848 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2853 #[derive(Clone)]
2854 pub struct migrateToOutputsMerkleRootValidatorCall {
2855 #[allow(missing_docs)]
2856 pub newOutputsMerkleRootValidator: alloy::sol_types::private::Address,
2857 }
2858 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2860 #[derive(Clone)]
2861 pub struct migrateToOutputsMerkleRootValidatorReturn {}
2862 #[allow(
2863 non_camel_case_types,
2864 non_snake_case,
2865 clippy::pub_underscore_fields,
2866 clippy::style
2867 )]
2868 const _: () = {
2869 use alloy::sol_types as alloy_sol_types;
2870 {
2871 #[doc(hidden)]
2872 #[allow(dead_code)]
2873 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
2874 #[doc(hidden)]
2875 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
2876 #[cfg(test)]
2877 #[allow(dead_code, unreachable_patterns)]
2878 fn _type_assertion(
2879 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
2880 ) {
2881 match _t {
2882 alloy_sol_types::private::AssertTypeEq::<
2883 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2884 >(_) => {}
2885 }
2886 }
2887 #[automatically_derived]
2888 #[doc(hidden)]
2889 impl ::core::convert::From<migrateToOutputsMerkleRootValidatorCall>
2890 for UnderlyingRustTuple<'_> {
2891 fn from(value: migrateToOutputsMerkleRootValidatorCall) -> Self {
2892 (value.newOutputsMerkleRootValidator,)
2893 }
2894 }
2895 #[automatically_derived]
2896 #[doc(hidden)]
2897 impl ::core::convert::From<UnderlyingRustTuple<'_>>
2898 for migrateToOutputsMerkleRootValidatorCall {
2899 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2900 Self {
2901 newOutputsMerkleRootValidator: tuple.0,
2902 }
2903 }
2904 }
2905 }
2906 {
2907 #[doc(hidden)]
2908 #[allow(dead_code)]
2909 type UnderlyingSolTuple<'a> = ();
2910 #[doc(hidden)]
2911 type UnderlyingRustTuple<'a> = ();
2912 #[cfg(test)]
2913 #[allow(dead_code, unreachable_patterns)]
2914 fn _type_assertion(
2915 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
2916 ) {
2917 match _t {
2918 alloy_sol_types::private::AssertTypeEq::<
2919 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2920 >(_) => {}
2921 }
2922 }
2923 #[automatically_derived]
2924 #[doc(hidden)]
2925 impl ::core::convert::From<migrateToOutputsMerkleRootValidatorReturn>
2926 for UnderlyingRustTuple<'_> {
2927 fn from(value: migrateToOutputsMerkleRootValidatorReturn) -> Self {
2928 ()
2929 }
2930 }
2931 #[automatically_derived]
2932 #[doc(hidden)]
2933 impl ::core::convert::From<UnderlyingRustTuple<'_>>
2934 for migrateToOutputsMerkleRootValidatorReturn {
2935 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2936 Self {}
2937 }
2938 }
2939 }
2940 impl migrateToOutputsMerkleRootValidatorReturn {
2941 fn _tokenize(
2942 &self,
2943 ) -> <migrateToOutputsMerkleRootValidatorCall as alloy_sol_types::SolCall>::ReturnToken<
2944 '_,
2945 > {
2946 ()
2947 }
2948 }
2949 #[automatically_derived]
2950 impl alloy_sol_types::SolCall for migrateToOutputsMerkleRootValidatorCall {
2951 type Parameters<'a> = (alloy::sol_types::sol_data::Address,);
2952 type Token<'a> = <Self::Parameters<
2953 'a,
2954 > as alloy_sol_types::SolType>::Token<'a>;
2955 type Return = migrateToOutputsMerkleRootValidatorReturn;
2956 type ReturnTuple<'a> = ();
2957 type ReturnToken<'a> = <Self::ReturnTuple<
2958 'a,
2959 > as alloy_sol_types::SolType>::Token<'a>;
2960 const SIGNATURE: &'static str = "migrateToOutputsMerkleRootValidator(address)";
2961 const SELECTOR: [u8; 4] = [191u8, 138u8, 191u8, 248u8];
2962 #[inline]
2963 fn new<'a>(
2964 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
2965 ) -> Self {
2966 tuple.into()
2967 }
2968 #[inline]
2969 fn tokenize(&self) -> Self::Token<'_> {
2970 (
2971 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
2972 &self.newOutputsMerkleRootValidator,
2973 ),
2974 )
2975 }
2976 #[inline]
2977 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
2978 migrateToOutputsMerkleRootValidatorReturn::_tokenize(ret)
2979 }
2980 #[inline]
2981 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
2982 <Self::ReturnTuple<
2983 '_,
2984 > as alloy_sol_types::SolType>::abi_decode_sequence(data)
2985 .map(Into::into)
2986 }
2987 #[inline]
2988 fn abi_decode_returns_validate(
2989 data: &[u8],
2990 ) -> alloy_sol_types::Result<Self::Return> {
2991 <Self::ReturnTuple<
2992 '_,
2993 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
2994 .map(Into::into)
2995 }
2996 }
2997 };
2998 #[derive(serde::Serialize, serde::Deserialize)]
2999 #[derive(Default, Debug, PartialEq, Eq, Hash)]
3000 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3005 #[derive(Clone)]
3006 pub struct onERC1155BatchReceivedCall {
3007 #[allow(missing_docs)]
3008 pub _0: alloy::sol_types::private::Address,
3009 #[allow(missing_docs)]
3010 pub _1: alloy::sol_types::private::Address,
3011 #[allow(missing_docs)]
3012 pub _2: alloy::sol_types::private::Vec<
3013 alloy::sol_types::private::primitives::aliases::U256,
3014 >,
3015 #[allow(missing_docs)]
3016 pub _3: alloy::sol_types::private::Vec<
3017 alloy::sol_types::private::primitives::aliases::U256,
3018 >,
3019 #[allow(missing_docs)]
3020 pub _4: alloy::sol_types::private::Bytes,
3021 }
3022 #[derive(serde::Serialize, serde::Deserialize)]
3023 #[derive(Default, Debug, PartialEq, Eq, Hash)]
3024 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3026 #[derive(Clone)]
3027 pub struct onERC1155BatchReceivedReturn {
3028 #[allow(missing_docs)]
3029 pub _0: alloy::sol_types::private::FixedBytes<4>,
3030 }
3031 #[allow(
3032 non_camel_case_types,
3033 non_snake_case,
3034 clippy::pub_underscore_fields,
3035 clippy::style
3036 )]
3037 const _: () = {
3038 use alloy::sol_types as alloy_sol_types;
3039 {
3040 #[doc(hidden)]
3041 #[allow(dead_code)]
3042 type UnderlyingSolTuple<'a> = (
3043 alloy::sol_types::sol_data::Address,
3044 alloy::sol_types::sol_data::Address,
3045 alloy::sol_types::sol_data::Array<alloy::sol_types::sol_data::Uint<256>>,
3046 alloy::sol_types::sol_data::Array<alloy::sol_types::sol_data::Uint<256>>,
3047 alloy::sol_types::sol_data::Bytes,
3048 );
3049 #[doc(hidden)]
3050 type UnderlyingRustTuple<'a> = (
3051 alloy::sol_types::private::Address,
3052 alloy::sol_types::private::Address,
3053 alloy::sol_types::private::Vec<
3054 alloy::sol_types::private::primitives::aliases::U256,
3055 >,
3056 alloy::sol_types::private::Vec<
3057 alloy::sol_types::private::primitives::aliases::U256,
3058 >,
3059 alloy::sol_types::private::Bytes,
3060 );
3061 #[cfg(test)]
3062 #[allow(dead_code, unreachable_patterns)]
3063 fn _type_assertion(
3064 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
3065 ) {
3066 match _t {
3067 alloy_sol_types::private::AssertTypeEq::<
3068 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3069 >(_) => {}
3070 }
3071 }
3072 #[automatically_derived]
3073 #[doc(hidden)]
3074 impl ::core::convert::From<onERC1155BatchReceivedCall>
3075 for UnderlyingRustTuple<'_> {
3076 fn from(value: onERC1155BatchReceivedCall) -> Self {
3077 (value._0, value._1, value._2, value._3, value._4)
3078 }
3079 }
3080 #[automatically_derived]
3081 #[doc(hidden)]
3082 impl ::core::convert::From<UnderlyingRustTuple<'_>>
3083 for onERC1155BatchReceivedCall {
3084 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3085 Self {
3086 _0: tuple.0,
3087 _1: tuple.1,
3088 _2: tuple.2,
3089 _3: tuple.3,
3090 _4: tuple.4,
3091 }
3092 }
3093 }
3094 }
3095 {
3096 #[doc(hidden)]
3097 #[allow(dead_code)]
3098 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<4>,);
3099 #[doc(hidden)]
3100 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::FixedBytes<4>,);
3101 #[cfg(test)]
3102 #[allow(dead_code, unreachable_patterns)]
3103 fn _type_assertion(
3104 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
3105 ) {
3106 match _t {
3107 alloy_sol_types::private::AssertTypeEq::<
3108 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3109 >(_) => {}
3110 }
3111 }
3112 #[automatically_derived]
3113 #[doc(hidden)]
3114 impl ::core::convert::From<onERC1155BatchReceivedReturn>
3115 for UnderlyingRustTuple<'_> {
3116 fn from(value: onERC1155BatchReceivedReturn) -> Self {
3117 (value._0,)
3118 }
3119 }
3120 #[automatically_derived]
3121 #[doc(hidden)]
3122 impl ::core::convert::From<UnderlyingRustTuple<'_>>
3123 for onERC1155BatchReceivedReturn {
3124 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3125 Self { _0: tuple.0 }
3126 }
3127 }
3128 }
3129 #[automatically_derived]
3130 impl alloy_sol_types::SolCall for onERC1155BatchReceivedCall {
3131 type Parameters<'a> = (
3132 alloy::sol_types::sol_data::Address,
3133 alloy::sol_types::sol_data::Address,
3134 alloy::sol_types::sol_data::Array<alloy::sol_types::sol_data::Uint<256>>,
3135 alloy::sol_types::sol_data::Array<alloy::sol_types::sol_data::Uint<256>>,
3136 alloy::sol_types::sol_data::Bytes,
3137 );
3138 type Token<'a> = <Self::Parameters<
3139 'a,
3140 > as alloy_sol_types::SolType>::Token<'a>;
3141 type Return = alloy::sol_types::private::FixedBytes<4>;
3142 type ReturnTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<4>,);
3143 type ReturnToken<'a> = <Self::ReturnTuple<
3144 'a,
3145 > as alloy_sol_types::SolType>::Token<'a>;
3146 const SIGNATURE: &'static str = "onERC1155BatchReceived(address,address,uint256[],uint256[],bytes)";
3147 const SELECTOR: [u8; 4] = [188u8, 25u8, 124u8, 129u8];
3148 #[inline]
3149 fn new<'a>(
3150 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
3151 ) -> Self {
3152 tuple.into()
3153 }
3154 #[inline]
3155 fn tokenize(&self) -> Self::Token<'_> {
3156 (
3157 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
3158 &self._0,
3159 ),
3160 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
3161 &self._1,
3162 ),
3163 <alloy::sol_types::sol_data::Array<
3164 alloy::sol_types::sol_data::Uint<256>,
3165 > as alloy_sol_types::SolType>::tokenize(&self._2),
3166 <alloy::sol_types::sol_data::Array<
3167 alloy::sol_types::sol_data::Uint<256>,
3168 > as alloy_sol_types::SolType>::tokenize(&self._3),
3169 <alloy::sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
3170 &self._4,
3171 ),
3172 )
3173 }
3174 #[inline]
3175 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
3176 (
3177 <alloy::sol_types::sol_data::FixedBytes<
3178 4,
3179 > as alloy_sol_types::SolType>::tokenize(ret),
3180 )
3181 }
3182 #[inline]
3183 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
3184 <Self::ReturnTuple<
3185 '_,
3186 > as alloy_sol_types::SolType>::abi_decode_sequence(data)
3187 .map(|r| {
3188 let r: onERC1155BatchReceivedReturn = r.into();
3189 r._0
3190 })
3191 }
3192 #[inline]
3193 fn abi_decode_returns_validate(
3194 data: &[u8],
3195 ) -> alloy_sol_types::Result<Self::Return> {
3196 <Self::ReturnTuple<
3197 '_,
3198 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
3199 .map(|r| {
3200 let r: onERC1155BatchReceivedReturn = r.into();
3201 r._0
3202 })
3203 }
3204 }
3205 };
3206 #[derive(serde::Serialize, serde::Deserialize)]
3207 #[derive(Default, Debug, PartialEq, Eq, Hash)]
3208 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3213 #[derive(Clone)]
3214 pub struct onERC1155ReceivedCall {
3215 #[allow(missing_docs)]
3216 pub _0: alloy::sol_types::private::Address,
3217 #[allow(missing_docs)]
3218 pub _1: alloy::sol_types::private::Address,
3219 #[allow(missing_docs)]
3220 pub _2: alloy::sol_types::private::primitives::aliases::U256,
3221 #[allow(missing_docs)]
3222 pub _3: alloy::sol_types::private::primitives::aliases::U256,
3223 #[allow(missing_docs)]
3224 pub _4: alloy::sol_types::private::Bytes,
3225 }
3226 #[derive(serde::Serialize, serde::Deserialize)]
3227 #[derive(Default, Debug, PartialEq, Eq, Hash)]
3228 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3230 #[derive(Clone)]
3231 pub struct onERC1155ReceivedReturn {
3232 #[allow(missing_docs)]
3233 pub _0: alloy::sol_types::private::FixedBytes<4>,
3234 }
3235 #[allow(
3236 non_camel_case_types,
3237 non_snake_case,
3238 clippy::pub_underscore_fields,
3239 clippy::style
3240 )]
3241 const _: () = {
3242 use alloy::sol_types as alloy_sol_types;
3243 {
3244 #[doc(hidden)]
3245 #[allow(dead_code)]
3246 type UnderlyingSolTuple<'a> = (
3247 alloy::sol_types::sol_data::Address,
3248 alloy::sol_types::sol_data::Address,
3249 alloy::sol_types::sol_data::Uint<256>,
3250 alloy::sol_types::sol_data::Uint<256>,
3251 alloy::sol_types::sol_data::Bytes,
3252 );
3253 #[doc(hidden)]
3254 type UnderlyingRustTuple<'a> = (
3255 alloy::sol_types::private::Address,
3256 alloy::sol_types::private::Address,
3257 alloy::sol_types::private::primitives::aliases::U256,
3258 alloy::sol_types::private::primitives::aliases::U256,
3259 alloy::sol_types::private::Bytes,
3260 );
3261 #[cfg(test)]
3262 #[allow(dead_code, unreachable_patterns)]
3263 fn _type_assertion(
3264 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
3265 ) {
3266 match _t {
3267 alloy_sol_types::private::AssertTypeEq::<
3268 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3269 >(_) => {}
3270 }
3271 }
3272 #[automatically_derived]
3273 #[doc(hidden)]
3274 impl ::core::convert::From<onERC1155ReceivedCall>
3275 for UnderlyingRustTuple<'_> {
3276 fn from(value: onERC1155ReceivedCall) -> Self {
3277 (value._0, value._1, value._2, value._3, value._4)
3278 }
3279 }
3280 #[automatically_derived]
3281 #[doc(hidden)]
3282 impl ::core::convert::From<UnderlyingRustTuple<'_>>
3283 for onERC1155ReceivedCall {
3284 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3285 Self {
3286 _0: tuple.0,
3287 _1: tuple.1,
3288 _2: tuple.2,
3289 _3: tuple.3,
3290 _4: tuple.4,
3291 }
3292 }
3293 }
3294 }
3295 {
3296 #[doc(hidden)]
3297 #[allow(dead_code)]
3298 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<4>,);
3299 #[doc(hidden)]
3300 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::FixedBytes<4>,);
3301 #[cfg(test)]
3302 #[allow(dead_code, unreachable_patterns)]
3303 fn _type_assertion(
3304 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
3305 ) {
3306 match _t {
3307 alloy_sol_types::private::AssertTypeEq::<
3308 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3309 >(_) => {}
3310 }
3311 }
3312 #[automatically_derived]
3313 #[doc(hidden)]
3314 impl ::core::convert::From<onERC1155ReceivedReturn>
3315 for UnderlyingRustTuple<'_> {
3316 fn from(value: onERC1155ReceivedReturn) -> Self {
3317 (value._0,)
3318 }
3319 }
3320 #[automatically_derived]
3321 #[doc(hidden)]
3322 impl ::core::convert::From<UnderlyingRustTuple<'_>>
3323 for onERC1155ReceivedReturn {
3324 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3325 Self { _0: tuple.0 }
3326 }
3327 }
3328 }
3329 #[automatically_derived]
3330 impl alloy_sol_types::SolCall for onERC1155ReceivedCall {
3331 type Parameters<'a> = (
3332 alloy::sol_types::sol_data::Address,
3333 alloy::sol_types::sol_data::Address,
3334 alloy::sol_types::sol_data::Uint<256>,
3335 alloy::sol_types::sol_data::Uint<256>,
3336 alloy::sol_types::sol_data::Bytes,
3337 );
3338 type Token<'a> = <Self::Parameters<
3339 'a,
3340 > as alloy_sol_types::SolType>::Token<'a>;
3341 type Return = alloy::sol_types::private::FixedBytes<4>;
3342 type ReturnTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<4>,);
3343 type ReturnToken<'a> = <Self::ReturnTuple<
3344 'a,
3345 > as alloy_sol_types::SolType>::Token<'a>;
3346 const SIGNATURE: &'static str = "onERC1155Received(address,address,uint256,uint256,bytes)";
3347 const SELECTOR: [u8; 4] = [242u8, 58u8, 110u8, 97u8];
3348 #[inline]
3349 fn new<'a>(
3350 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
3351 ) -> Self {
3352 tuple.into()
3353 }
3354 #[inline]
3355 fn tokenize(&self) -> Self::Token<'_> {
3356 (
3357 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
3358 &self._0,
3359 ),
3360 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
3361 &self._1,
3362 ),
3363 <alloy::sol_types::sol_data::Uint<
3364 256,
3365 > as alloy_sol_types::SolType>::tokenize(&self._2),
3366 <alloy::sol_types::sol_data::Uint<
3367 256,
3368 > as alloy_sol_types::SolType>::tokenize(&self._3),
3369 <alloy::sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
3370 &self._4,
3371 ),
3372 )
3373 }
3374 #[inline]
3375 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
3376 (
3377 <alloy::sol_types::sol_data::FixedBytes<
3378 4,
3379 > as alloy_sol_types::SolType>::tokenize(ret),
3380 )
3381 }
3382 #[inline]
3383 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
3384 <Self::ReturnTuple<
3385 '_,
3386 > as alloy_sol_types::SolType>::abi_decode_sequence(data)
3387 .map(|r| {
3388 let r: onERC1155ReceivedReturn = r.into();
3389 r._0
3390 })
3391 }
3392 #[inline]
3393 fn abi_decode_returns_validate(
3394 data: &[u8],
3395 ) -> alloy_sol_types::Result<Self::Return> {
3396 <Self::ReturnTuple<
3397 '_,
3398 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
3399 .map(|r| {
3400 let r: onERC1155ReceivedReturn = r.into();
3401 r._0
3402 })
3403 }
3404 }
3405 };
3406 #[derive(serde::Serialize, serde::Deserialize)]
3407 #[derive(Default, Debug, PartialEq, Eq, Hash)]
3408 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3413 #[derive(Clone)]
3414 pub struct onERC721ReceivedCall {
3415 #[allow(missing_docs)]
3416 pub _0: alloy::sol_types::private::Address,
3417 #[allow(missing_docs)]
3418 pub _1: alloy::sol_types::private::Address,
3419 #[allow(missing_docs)]
3420 pub _2: alloy::sol_types::private::primitives::aliases::U256,
3421 #[allow(missing_docs)]
3422 pub _3: alloy::sol_types::private::Bytes,
3423 }
3424 #[derive(serde::Serialize, serde::Deserialize)]
3425 #[derive(Default, Debug, PartialEq, Eq, Hash)]
3426 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3428 #[derive(Clone)]
3429 pub struct onERC721ReceivedReturn {
3430 #[allow(missing_docs)]
3431 pub _0: alloy::sol_types::private::FixedBytes<4>,
3432 }
3433 #[allow(
3434 non_camel_case_types,
3435 non_snake_case,
3436 clippy::pub_underscore_fields,
3437 clippy::style
3438 )]
3439 const _: () = {
3440 use alloy::sol_types as alloy_sol_types;
3441 {
3442 #[doc(hidden)]
3443 #[allow(dead_code)]
3444 type UnderlyingSolTuple<'a> = (
3445 alloy::sol_types::sol_data::Address,
3446 alloy::sol_types::sol_data::Address,
3447 alloy::sol_types::sol_data::Uint<256>,
3448 alloy::sol_types::sol_data::Bytes,
3449 );
3450 #[doc(hidden)]
3451 type UnderlyingRustTuple<'a> = (
3452 alloy::sol_types::private::Address,
3453 alloy::sol_types::private::Address,
3454 alloy::sol_types::private::primitives::aliases::U256,
3455 alloy::sol_types::private::Bytes,
3456 );
3457 #[cfg(test)]
3458 #[allow(dead_code, unreachable_patterns)]
3459 fn _type_assertion(
3460 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
3461 ) {
3462 match _t {
3463 alloy_sol_types::private::AssertTypeEq::<
3464 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3465 >(_) => {}
3466 }
3467 }
3468 #[automatically_derived]
3469 #[doc(hidden)]
3470 impl ::core::convert::From<onERC721ReceivedCall>
3471 for UnderlyingRustTuple<'_> {
3472 fn from(value: onERC721ReceivedCall) -> Self {
3473 (value._0, value._1, value._2, value._3)
3474 }
3475 }
3476 #[automatically_derived]
3477 #[doc(hidden)]
3478 impl ::core::convert::From<UnderlyingRustTuple<'_>>
3479 for onERC721ReceivedCall {
3480 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3481 Self {
3482 _0: tuple.0,
3483 _1: tuple.1,
3484 _2: tuple.2,
3485 _3: tuple.3,
3486 }
3487 }
3488 }
3489 }
3490 {
3491 #[doc(hidden)]
3492 #[allow(dead_code)]
3493 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<4>,);
3494 #[doc(hidden)]
3495 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::FixedBytes<4>,);
3496 #[cfg(test)]
3497 #[allow(dead_code, unreachable_patterns)]
3498 fn _type_assertion(
3499 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
3500 ) {
3501 match _t {
3502 alloy_sol_types::private::AssertTypeEq::<
3503 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3504 >(_) => {}
3505 }
3506 }
3507 #[automatically_derived]
3508 #[doc(hidden)]
3509 impl ::core::convert::From<onERC721ReceivedReturn>
3510 for UnderlyingRustTuple<'_> {
3511 fn from(value: onERC721ReceivedReturn) -> Self {
3512 (value._0,)
3513 }
3514 }
3515 #[automatically_derived]
3516 #[doc(hidden)]
3517 impl ::core::convert::From<UnderlyingRustTuple<'_>>
3518 for onERC721ReceivedReturn {
3519 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3520 Self { _0: tuple.0 }
3521 }
3522 }
3523 }
3524 #[automatically_derived]
3525 impl alloy_sol_types::SolCall for onERC721ReceivedCall {
3526 type Parameters<'a> = (
3527 alloy::sol_types::sol_data::Address,
3528 alloy::sol_types::sol_data::Address,
3529 alloy::sol_types::sol_data::Uint<256>,
3530 alloy::sol_types::sol_data::Bytes,
3531 );
3532 type Token<'a> = <Self::Parameters<
3533 'a,
3534 > as alloy_sol_types::SolType>::Token<'a>;
3535 type Return = alloy::sol_types::private::FixedBytes<4>;
3536 type ReturnTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<4>,);
3537 type ReturnToken<'a> = <Self::ReturnTuple<
3538 'a,
3539 > as alloy_sol_types::SolType>::Token<'a>;
3540 const SIGNATURE: &'static str = "onERC721Received(address,address,uint256,bytes)";
3541 const SELECTOR: [u8; 4] = [21u8, 11u8, 122u8, 2u8];
3542 #[inline]
3543 fn new<'a>(
3544 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
3545 ) -> Self {
3546 tuple.into()
3547 }
3548 #[inline]
3549 fn tokenize(&self) -> Self::Token<'_> {
3550 (
3551 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
3552 &self._0,
3553 ),
3554 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
3555 &self._1,
3556 ),
3557 <alloy::sol_types::sol_data::Uint<
3558 256,
3559 > as alloy_sol_types::SolType>::tokenize(&self._2),
3560 <alloy::sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
3561 &self._3,
3562 ),
3563 )
3564 }
3565 #[inline]
3566 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
3567 (
3568 <alloy::sol_types::sol_data::FixedBytes<
3569 4,
3570 > as alloy_sol_types::SolType>::tokenize(ret),
3571 )
3572 }
3573 #[inline]
3574 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
3575 <Self::ReturnTuple<
3576 '_,
3577 > as alloy_sol_types::SolType>::abi_decode_sequence(data)
3578 .map(|r| {
3579 let r: onERC721ReceivedReturn = r.into();
3580 r._0
3581 })
3582 }
3583 #[inline]
3584 fn abi_decode_returns_validate(
3585 data: &[u8],
3586 ) -> alloy_sol_types::Result<Self::Return> {
3587 <Self::ReturnTuple<
3588 '_,
3589 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
3590 .map(|r| {
3591 let r: onERC721ReceivedReturn = r.into();
3592 r._0
3593 })
3594 }
3595 }
3596 };
3597 #[derive(serde::Serialize, serde::Deserialize)]
3598 #[derive(Default, Debug, PartialEq, Eq, Hash)]
3599 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3604 #[derive(Clone)]
3605 pub struct ownerCall;
3606 #[derive(serde::Serialize, serde::Deserialize)]
3607 #[derive(Default, Debug, PartialEq, Eq, Hash)]
3608 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3610 #[derive(Clone)]
3611 pub struct ownerReturn {
3612 #[allow(missing_docs)]
3613 pub _0: alloy::sol_types::private::Address,
3614 }
3615 #[allow(
3616 non_camel_case_types,
3617 non_snake_case,
3618 clippy::pub_underscore_fields,
3619 clippy::style
3620 )]
3621 const _: () = {
3622 use alloy::sol_types as alloy_sol_types;
3623 {
3624 #[doc(hidden)]
3625 #[allow(dead_code)]
3626 type UnderlyingSolTuple<'a> = ();
3627 #[doc(hidden)]
3628 type UnderlyingRustTuple<'a> = ();
3629 #[cfg(test)]
3630 #[allow(dead_code, unreachable_patterns)]
3631 fn _type_assertion(
3632 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
3633 ) {
3634 match _t {
3635 alloy_sol_types::private::AssertTypeEq::<
3636 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3637 >(_) => {}
3638 }
3639 }
3640 #[automatically_derived]
3641 #[doc(hidden)]
3642 impl ::core::convert::From<ownerCall> for UnderlyingRustTuple<'_> {
3643 fn from(value: ownerCall) -> Self {
3644 ()
3645 }
3646 }
3647 #[automatically_derived]
3648 #[doc(hidden)]
3649 impl ::core::convert::From<UnderlyingRustTuple<'_>> for ownerCall {
3650 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3651 Self
3652 }
3653 }
3654 }
3655 {
3656 #[doc(hidden)]
3657 #[allow(dead_code)]
3658 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
3659 #[doc(hidden)]
3660 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
3661 #[cfg(test)]
3662 #[allow(dead_code, unreachable_patterns)]
3663 fn _type_assertion(
3664 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
3665 ) {
3666 match _t {
3667 alloy_sol_types::private::AssertTypeEq::<
3668 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3669 >(_) => {}
3670 }
3671 }
3672 #[automatically_derived]
3673 #[doc(hidden)]
3674 impl ::core::convert::From<ownerReturn> for UnderlyingRustTuple<'_> {
3675 fn from(value: ownerReturn) -> Self {
3676 (value._0,)
3677 }
3678 }
3679 #[automatically_derived]
3680 #[doc(hidden)]
3681 impl ::core::convert::From<UnderlyingRustTuple<'_>> for ownerReturn {
3682 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3683 Self { _0: tuple.0 }
3684 }
3685 }
3686 }
3687 #[automatically_derived]
3688 impl alloy_sol_types::SolCall for ownerCall {
3689 type Parameters<'a> = ();
3690 type Token<'a> = <Self::Parameters<
3691 'a,
3692 > as alloy_sol_types::SolType>::Token<'a>;
3693 type Return = alloy::sol_types::private::Address;
3694 type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,);
3695 type ReturnToken<'a> = <Self::ReturnTuple<
3696 'a,
3697 > as alloy_sol_types::SolType>::Token<'a>;
3698 const SIGNATURE: &'static str = "owner()";
3699 const SELECTOR: [u8; 4] = [141u8, 165u8, 203u8, 91u8];
3700 #[inline]
3701 fn new<'a>(
3702 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
3703 ) -> Self {
3704 tuple.into()
3705 }
3706 #[inline]
3707 fn tokenize(&self) -> Self::Token<'_> {
3708 ()
3709 }
3710 #[inline]
3711 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
3712 (
3713 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
3714 ret,
3715 ),
3716 )
3717 }
3718 #[inline]
3719 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
3720 <Self::ReturnTuple<
3721 '_,
3722 > as alloy_sol_types::SolType>::abi_decode_sequence(data)
3723 .map(|r| {
3724 let r: ownerReturn = r.into();
3725 r._0
3726 })
3727 }
3728 #[inline]
3729 fn abi_decode_returns_validate(
3730 data: &[u8],
3731 ) -> alloy_sol_types::Result<Self::Return> {
3732 <Self::ReturnTuple<
3733 '_,
3734 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
3735 .map(|r| {
3736 let r: ownerReturn = r.into();
3737 r._0
3738 })
3739 }
3740 }
3741 };
3742 #[derive(serde::Serialize, serde::Deserialize)]
3743 #[derive(Default, Debug, PartialEq, Eq, Hash)]
3744 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3749 #[derive(Clone)]
3750 pub struct renounceOwnershipCall;
3751 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3753 #[derive(Clone)]
3754 pub struct renounceOwnershipReturn {}
3755 #[allow(
3756 non_camel_case_types,
3757 non_snake_case,
3758 clippy::pub_underscore_fields,
3759 clippy::style
3760 )]
3761 const _: () = {
3762 use alloy::sol_types as alloy_sol_types;
3763 {
3764 #[doc(hidden)]
3765 #[allow(dead_code)]
3766 type UnderlyingSolTuple<'a> = ();
3767 #[doc(hidden)]
3768 type UnderlyingRustTuple<'a> = ();
3769 #[cfg(test)]
3770 #[allow(dead_code, unreachable_patterns)]
3771 fn _type_assertion(
3772 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
3773 ) {
3774 match _t {
3775 alloy_sol_types::private::AssertTypeEq::<
3776 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3777 >(_) => {}
3778 }
3779 }
3780 #[automatically_derived]
3781 #[doc(hidden)]
3782 impl ::core::convert::From<renounceOwnershipCall>
3783 for UnderlyingRustTuple<'_> {
3784 fn from(value: renounceOwnershipCall) -> Self {
3785 ()
3786 }
3787 }
3788 #[automatically_derived]
3789 #[doc(hidden)]
3790 impl ::core::convert::From<UnderlyingRustTuple<'_>>
3791 for renounceOwnershipCall {
3792 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3793 Self
3794 }
3795 }
3796 }
3797 {
3798 #[doc(hidden)]
3799 #[allow(dead_code)]
3800 type UnderlyingSolTuple<'a> = ();
3801 #[doc(hidden)]
3802 type UnderlyingRustTuple<'a> = ();
3803 #[cfg(test)]
3804 #[allow(dead_code, unreachable_patterns)]
3805 fn _type_assertion(
3806 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
3807 ) {
3808 match _t {
3809 alloy_sol_types::private::AssertTypeEq::<
3810 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3811 >(_) => {}
3812 }
3813 }
3814 #[automatically_derived]
3815 #[doc(hidden)]
3816 impl ::core::convert::From<renounceOwnershipReturn>
3817 for UnderlyingRustTuple<'_> {
3818 fn from(value: renounceOwnershipReturn) -> Self {
3819 ()
3820 }
3821 }
3822 #[automatically_derived]
3823 #[doc(hidden)]
3824 impl ::core::convert::From<UnderlyingRustTuple<'_>>
3825 for renounceOwnershipReturn {
3826 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3827 Self {}
3828 }
3829 }
3830 }
3831 impl renounceOwnershipReturn {
3832 fn _tokenize(
3833 &self,
3834 ) -> <renounceOwnershipCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
3835 ()
3836 }
3837 }
3838 #[automatically_derived]
3839 impl alloy_sol_types::SolCall for renounceOwnershipCall {
3840 type Parameters<'a> = ();
3841 type Token<'a> = <Self::Parameters<
3842 'a,
3843 > as alloy_sol_types::SolType>::Token<'a>;
3844 type Return = renounceOwnershipReturn;
3845 type ReturnTuple<'a> = ();
3846 type ReturnToken<'a> = <Self::ReturnTuple<
3847 'a,
3848 > as alloy_sol_types::SolType>::Token<'a>;
3849 const SIGNATURE: &'static str = "renounceOwnership()";
3850 const SELECTOR: [u8; 4] = [113u8, 80u8, 24u8, 166u8];
3851 #[inline]
3852 fn new<'a>(
3853 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
3854 ) -> Self {
3855 tuple.into()
3856 }
3857 #[inline]
3858 fn tokenize(&self) -> Self::Token<'_> {
3859 ()
3860 }
3861 #[inline]
3862 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
3863 renounceOwnershipReturn::_tokenize(ret)
3864 }
3865 #[inline]
3866 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
3867 <Self::ReturnTuple<
3868 '_,
3869 > as alloy_sol_types::SolType>::abi_decode_sequence(data)
3870 .map(Into::into)
3871 }
3872 #[inline]
3873 fn abi_decode_returns_validate(
3874 data: &[u8],
3875 ) -> alloy_sol_types::Result<Self::Return> {
3876 <Self::ReturnTuple<
3877 '_,
3878 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
3879 .map(Into::into)
3880 }
3881 }
3882 };
3883 #[derive(serde::Serialize, serde::Deserialize)]
3884 #[derive(Default, Debug, PartialEq, Eq, Hash)]
3885 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3890 #[derive(Clone)]
3891 pub struct supportsInterfaceCall {
3892 #[allow(missing_docs)]
3893 pub interfaceId: alloy::sol_types::private::FixedBytes<4>,
3894 }
3895 #[derive(serde::Serialize, serde::Deserialize)]
3896 #[derive(Default, Debug, PartialEq, Eq, Hash)]
3897 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3899 #[derive(Clone)]
3900 pub struct supportsInterfaceReturn {
3901 #[allow(missing_docs)]
3902 pub _0: bool,
3903 }
3904 #[allow(
3905 non_camel_case_types,
3906 non_snake_case,
3907 clippy::pub_underscore_fields,
3908 clippy::style
3909 )]
3910 const _: () = {
3911 use alloy::sol_types as alloy_sol_types;
3912 {
3913 #[doc(hidden)]
3914 #[allow(dead_code)]
3915 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<4>,);
3916 #[doc(hidden)]
3917 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::FixedBytes<4>,);
3918 #[cfg(test)]
3919 #[allow(dead_code, unreachable_patterns)]
3920 fn _type_assertion(
3921 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
3922 ) {
3923 match _t {
3924 alloy_sol_types::private::AssertTypeEq::<
3925 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3926 >(_) => {}
3927 }
3928 }
3929 #[automatically_derived]
3930 #[doc(hidden)]
3931 impl ::core::convert::From<supportsInterfaceCall>
3932 for UnderlyingRustTuple<'_> {
3933 fn from(value: supportsInterfaceCall) -> Self {
3934 (value.interfaceId,)
3935 }
3936 }
3937 #[automatically_derived]
3938 #[doc(hidden)]
3939 impl ::core::convert::From<UnderlyingRustTuple<'_>>
3940 for supportsInterfaceCall {
3941 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3942 Self { interfaceId: tuple.0 }
3943 }
3944 }
3945 }
3946 {
3947 #[doc(hidden)]
3948 #[allow(dead_code)]
3949 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Bool,);
3950 #[doc(hidden)]
3951 type UnderlyingRustTuple<'a> = (bool,);
3952 #[cfg(test)]
3953 #[allow(dead_code, unreachable_patterns)]
3954 fn _type_assertion(
3955 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
3956 ) {
3957 match _t {
3958 alloy_sol_types::private::AssertTypeEq::<
3959 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3960 >(_) => {}
3961 }
3962 }
3963 #[automatically_derived]
3964 #[doc(hidden)]
3965 impl ::core::convert::From<supportsInterfaceReturn>
3966 for UnderlyingRustTuple<'_> {
3967 fn from(value: supportsInterfaceReturn) -> Self {
3968 (value._0,)
3969 }
3970 }
3971 #[automatically_derived]
3972 #[doc(hidden)]
3973 impl ::core::convert::From<UnderlyingRustTuple<'_>>
3974 for supportsInterfaceReturn {
3975 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3976 Self { _0: tuple.0 }
3977 }
3978 }
3979 }
3980 #[automatically_derived]
3981 impl alloy_sol_types::SolCall for supportsInterfaceCall {
3982 type Parameters<'a> = (alloy::sol_types::sol_data::FixedBytes<4>,);
3983 type Token<'a> = <Self::Parameters<
3984 'a,
3985 > as alloy_sol_types::SolType>::Token<'a>;
3986 type Return = bool;
3987 type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,);
3988 type ReturnToken<'a> = <Self::ReturnTuple<
3989 'a,
3990 > as alloy_sol_types::SolType>::Token<'a>;
3991 const SIGNATURE: &'static str = "supportsInterface(bytes4)";
3992 const SELECTOR: [u8; 4] = [1u8, 255u8, 201u8, 167u8];
3993 #[inline]
3994 fn new<'a>(
3995 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
3996 ) -> Self {
3997 tuple.into()
3998 }
3999 #[inline]
4000 fn tokenize(&self) -> Self::Token<'_> {
4001 (
4002 <alloy::sol_types::sol_data::FixedBytes<
4003 4,
4004 > as alloy_sol_types::SolType>::tokenize(&self.interfaceId),
4005 )
4006 }
4007 #[inline]
4008 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
4009 (
4010 <alloy::sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(
4011 ret,
4012 ),
4013 )
4014 }
4015 #[inline]
4016 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
4017 <Self::ReturnTuple<
4018 '_,
4019 > as alloy_sol_types::SolType>::abi_decode_sequence(data)
4020 .map(|r| {
4021 let r: supportsInterfaceReturn = r.into();
4022 r._0
4023 })
4024 }
4025 #[inline]
4026 fn abi_decode_returns_validate(
4027 data: &[u8],
4028 ) -> alloy_sol_types::Result<Self::Return> {
4029 <Self::ReturnTuple<
4030 '_,
4031 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
4032 .map(|r| {
4033 let r: supportsInterfaceReturn = r.into();
4034 r._0
4035 })
4036 }
4037 }
4038 };
4039 #[derive(serde::Serialize, serde::Deserialize)]
4040 #[derive(Default, Debug, PartialEq, Eq, Hash)]
4041 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
4046 #[derive(Clone)]
4047 pub struct transferOwnershipCall {
4048 #[allow(missing_docs)]
4049 pub newOwner: alloy::sol_types::private::Address,
4050 }
4051 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
4053 #[derive(Clone)]
4054 pub struct transferOwnershipReturn {}
4055 #[allow(
4056 non_camel_case_types,
4057 non_snake_case,
4058 clippy::pub_underscore_fields,
4059 clippy::style
4060 )]
4061 const _: () = {
4062 use alloy::sol_types as alloy_sol_types;
4063 {
4064 #[doc(hidden)]
4065 #[allow(dead_code)]
4066 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
4067 #[doc(hidden)]
4068 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
4069 #[cfg(test)]
4070 #[allow(dead_code, unreachable_patterns)]
4071 fn _type_assertion(
4072 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
4073 ) {
4074 match _t {
4075 alloy_sol_types::private::AssertTypeEq::<
4076 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
4077 >(_) => {}
4078 }
4079 }
4080 #[automatically_derived]
4081 #[doc(hidden)]
4082 impl ::core::convert::From<transferOwnershipCall>
4083 for UnderlyingRustTuple<'_> {
4084 fn from(value: transferOwnershipCall) -> Self {
4085 (value.newOwner,)
4086 }
4087 }
4088 #[automatically_derived]
4089 #[doc(hidden)]
4090 impl ::core::convert::From<UnderlyingRustTuple<'_>>
4091 for transferOwnershipCall {
4092 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
4093 Self { newOwner: tuple.0 }
4094 }
4095 }
4096 }
4097 {
4098 #[doc(hidden)]
4099 #[allow(dead_code)]
4100 type UnderlyingSolTuple<'a> = ();
4101 #[doc(hidden)]
4102 type UnderlyingRustTuple<'a> = ();
4103 #[cfg(test)]
4104 #[allow(dead_code, unreachable_patterns)]
4105 fn _type_assertion(
4106 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
4107 ) {
4108 match _t {
4109 alloy_sol_types::private::AssertTypeEq::<
4110 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
4111 >(_) => {}
4112 }
4113 }
4114 #[automatically_derived]
4115 #[doc(hidden)]
4116 impl ::core::convert::From<transferOwnershipReturn>
4117 for UnderlyingRustTuple<'_> {
4118 fn from(value: transferOwnershipReturn) -> Self {
4119 ()
4120 }
4121 }
4122 #[automatically_derived]
4123 #[doc(hidden)]
4124 impl ::core::convert::From<UnderlyingRustTuple<'_>>
4125 for transferOwnershipReturn {
4126 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
4127 Self {}
4128 }
4129 }
4130 }
4131 impl transferOwnershipReturn {
4132 fn _tokenize(
4133 &self,
4134 ) -> <transferOwnershipCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
4135 ()
4136 }
4137 }
4138 #[automatically_derived]
4139 impl alloy_sol_types::SolCall for transferOwnershipCall {
4140 type Parameters<'a> = (alloy::sol_types::sol_data::Address,);
4141 type Token<'a> = <Self::Parameters<
4142 'a,
4143 > as alloy_sol_types::SolType>::Token<'a>;
4144 type Return = transferOwnershipReturn;
4145 type ReturnTuple<'a> = ();
4146 type ReturnToken<'a> = <Self::ReturnTuple<
4147 'a,
4148 > as alloy_sol_types::SolType>::Token<'a>;
4149 const SIGNATURE: &'static str = "transferOwnership(address)";
4150 const SELECTOR: [u8; 4] = [242u8, 253u8, 227u8, 139u8];
4151 #[inline]
4152 fn new<'a>(
4153 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
4154 ) -> Self {
4155 tuple.into()
4156 }
4157 #[inline]
4158 fn tokenize(&self) -> Self::Token<'_> {
4159 (
4160 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
4161 &self.newOwner,
4162 ),
4163 )
4164 }
4165 #[inline]
4166 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
4167 transferOwnershipReturn::_tokenize(ret)
4168 }
4169 #[inline]
4170 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
4171 <Self::ReturnTuple<
4172 '_,
4173 > as alloy_sol_types::SolType>::abi_decode_sequence(data)
4174 .map(Into::into)
4175 }
4176 #[inline]
4177 fn abi_decode_returns_validate(
4178 data: &[u8],
4179 ) -> alloy_sol_types::Result<Self::Return> {
4180 <Self::ReturnTuple<
4181 '_,
4182 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
4183 .map(Into::into)
4184 }
4185 }
4186 };
4187 #[derive(serde::Serialize, serde::Deserialize)]
4188 #[derive(Default, Debug, PartialEq, Eq, Hash)]
4189 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
4194 #[derive(Clone)]
4195 pub struct validateOutputCall {
4196 #[allow(missing_docs)]
4197 pub output: alloy::sol_types::private::Bytes,
4198 #[allow(missing_docs)]
4199 pub proof: <OutputValidityProof as alloy::sol_types::SolType>::RustType,
4200 }
4201 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
4203 #[derive(Clone)]
4204 pub struct validateOutputReturn {}
4205 #[allow(
4206 non_camel_case_types,
4207 non_snake_case,
4208 clippy::pub_underscore_fields,
4209 clippy::style
4210 )]
4211 const _: () = {
4212 use alloy::sol_types as alloy_sol_types;
4213 {
4214 #[doc(hidden)]
4215 #[allow(dead_code)]
4216 type UnderlyingSolTuple<'a> = (
4217 alloy::sol_types::sol_data::Bytes,
4218 OutputValidityProof,
4219 );
4220 #[doc(hidden)]
4221 type UnderlyingRustTuple<'a> = (
4222 alloy::sol_types::private::Bytes,
4223 <OutputValidityProof as alloy::sol_types::SolType>::RustType,
4224 );
4225 #[cfg(test)]
4226 #[allow(dead_code, unreachable_patterns)]
4227 fn _type_assertion(
4228 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
4229 ) {
4230 match _t {
4231 alloy_sol_types::private::AssertTypeEq::<
4232 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
4233 >(_) => {}
4234 }
4235 }
4236 #[automatically_derived]
4237 #[doc(hidden)]
4238 impl ::core::convert::From<validateOutputCall> for UnderlyingRustTuple<'_> {
4239 fn from(value: validateOutputCall) -> Self {
4240 (value.output, value.proof)
4241 }
4242 }
4243 #[automatically_derived]
4244 #[doc(hidden)]
4245 impl ::core::convert::From<UnderlyingRustTuple<'_>> for validateOutputCall {
4246 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
4247 Self {
4248 output: tuple.0,
4249 proof: tuple.1,
4250 }
4251 }
4252 }
4253 }
4254 {
4255 #[doc(hidden)]
4256 #[allow(dead_code)]
4257 type UnderlyingSolTuple<'a> = ();
4258 #[doc(hidden)]
4259 type UnderlyingRustTuple<'a> = ();
4260 #[cfg(test)]
4261 #[allow(dead_code, unreachable_patterns)]
4262 fn _type_assertion(
4263 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
4264 ) {
4265 match _t {
4266 alloy_sol_types::private::AssertTypeEq::<
4267 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
4268 >(_) => {}
4269 }
4270 }
4271 #[automatically_derived]
4272 #[doc(hidden)]
4273 impl ::core::convert::From<validateOutputReturn>
4274 for UnderlyingRustTuple<'_> {
4275 fn from(value: validateOutputReturn) -> Self {
4276 ()
4277 }
4278 }
4279 #[automatically_derived]
4280 #[doc(hidden)]
4281 impl ::core::convert::From<UnderlyingRustTuple<'_>>
4282 for validateOutputReturn {
4283 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
4284 Self {}
4285 }
4286 }
4287 }
4288 impl validateOutputReturn {
4289 fn _tokenize(
4290 &self,
4291 ) -> <validateOutputCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
4292 ()
4293 }
4294 }
4295 #[automatically_derived]
4296 impl alloy_sol_types::SolCall for validateOutputCall {
4297 type Parameters<'a> = (
4298 alloy::sol_types::sol_data::Bytes,
4299 OutputValidityProof,
4300 );
4301 type Token<'a> = <Self::Parameters<
4302 'a,
4303 > as alloy_sol_types::SolType>::Token<'a>;
4304 type Return = validateOutputReturn;
4305 type ReturnTuple<'a> = ();
4306 type ReturnToken<'a> = <Self::ReturnTuple<
4307 'a,
4308 > as alloy_sol_types::SolType>::Token<'a>;
4309 const SIGNATURE: &'static str = "validateOutput(bytes,(uint64,bytes32[]))";
4310 const SELECTOR: [u8; 4] = [232u8, 141u8, 57u8, 192u8];
4311 #[inline]
4312 fn new<'a>(
4313 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
4314 ) -> Self {
4315 tuple.into()
4316 }
4317 #[inline]
4318 fn tokenize(&self) -> Self::Token<'_> {
4319 (
4320 <alloy::sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
4321 &self.output,
4322 ),
4323 <OutputValidityProof as alloy_sol_types::SolType>::tokenize(
4324 &self.proof,
4325 ),
4326 )
4327 }
4328 #[inline]
4329 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
4330 validateOutputReturn::_tokenize(ret)
4331 }
4332 #[inline]
4333 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
4334 <Self::ReturnTuple<
4335 '_,
4336 > as alloy_sol_types::SolType>::abi_decode_sequence(data)
4337 .map(Into::into)
4338 }
4339 #[inline]
4340 fn abi_decode_returns_validate(
4341 data: &[u8],
4342 ) -> alloy_sol_types::Result<Self::Return> {
4343 <Self::ReturnTuple<
4344 '_,
4345 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
4346 .map(Into::into)
4347 }
4348 }
4349 };
4350 #[derive(serde::Serialize, serde::Deserialize)]
4351 #[derive(Default, Debug, PartialEq, Eq, Hash)]
4352 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
4357 #[derive(Clone)]
4358 pub struct validateOutputHashCall {
4359 #[allow(missing_docs)]
4360 pub outputHash: alloy::sol_types::private::FixedBytes<32>,
4361 #[allow(missing_docs)]
4362 pub proof: <OutputValidityProof as alloy::sol_types::SolType>::RustType,
4363 }
4364 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
4366 #[derive(Clone)]
4367 pub struct validateOutputHashReturn {}
4368 #[allow(
4369 non_camel_case_types,
4370 non_snake_case,
4371 clippy::pub_underscore_fields,
4372 clippy::style
4373 )]
4374 const _: () = {
4375 use alloy::sol_types as alloy_sol_types;
4376 {
4377 #[doc(hidden)]
4378 #[allow(dead_code)]
4379 type UnderlyingSolTuple<'a> = (
4380 alloy::sol_types::sol_data::FixedBytes<32>,
4381 OutputValidityProof,
4382 );
4383 #[doc(hidden)]
4384 type UnderlyingRustTuple<'a> = (
4385 alloy::sol_types::private::FixedBytes<32>,
4386 <OutputValidityProof as alloy::sol_types::SolType>::RustType,
4387 );
4388 #[cfg(test)]
4389 #[allow(dead_code, unreachable_patterns)]
4390 fn _type_assertion(
4391 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
4392 ) {
4393 match _t {
4394 alloy_sol_types::private::AssertTypeEq::<
4395 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
4396 >(_) => {}
4397 }
4398 }
4399 #[automatically_derived]
4400 #[doc(hidden)]
4401 impl ::core::convert::From<validateOutputHashCall>
4402 for UnderlyingRustTuple<'_> {
4403 fn from(value: validateOutputHashCall) -> Self {
4404 (value.outputHash, value.proof)
4405 }
4406 }
4407 #[automatically_derived]
4408 #[doc(hidden)]
4409 impl ::core::convert::From<UnderlyingRustTuple<'_>>
4410 for validateOutputHashCall {
4411 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
4412 Self {
4413 outputHash: tuple.0,
4414 proof: tuple.1,
4415 }
4416 }
4417 }
4418 }
4419 {
4420 #[doc(hidden)]
4421 #[allow(dead_code)]
4422 type UnderlyingSolTuple<'a> = ();
4423 #[doc(hidden)]
4424 type UnderlyingRustTuple<'a> = ();
4425 #[cfg(test)]
4426 #[allow(dead_code, unreachable_patterns)]
4427 fn _type_assertion(
4428 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
4429 ) {
4430 match _t {
4431 alloy_sol_types::private::AssertTypeEq::<
4432 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
4433 >(_) => {}
4434 }
4435 }
4436 #[automatically_derived]
4437 #[doc(hidden)]
4438 impl ::core::convert::From<validateOutputHashReturn>
4439 for UnderlyingRustTuple<'_> {
4440 fn from(value: validateOutputHashReturn) -> Self {
4441 ()
4442 }
4443 }
4444 #[automatically_derived]
4445 #[doc(hidden)]
4446 impl ::core::convert::From<UnderlyingRustTuple<'_>>
4447 for validateOutputHashReturn {
4448 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
4449 Self {}
4450 }
4451 }
4452 }
4453 impl validateOutputHashReturn {
4454 fn _tokenize(
4455 &self,
4456 ) -> <validateOutputHashCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
4457 ()
4458 }
4459 }
4460 #[automatically_derived]
4461 impl alloy_sol_types::SolCall for validateOutputHashCall {
4462 type Parameters<'a> = (
4463 alloy::sol_types::sol_data::FixedBytes<32>,
4464 OutputValidityProof,
4465 );
4466 type Token<'a> = <Self::Parameters<
4467 'a,
4468 > as alloy_sol_types::SolType>::Token<'a>;
4469 type Return = validateOutputHashReturn;
4470 type ReturnTuple<'a> = ();
4471 type ReturnToken<'a> = <Self::ReturnTuple<
4472 'a,
4473 > as alloy_sol_types::SolType>::Token<'a>;
4474 const SIGNATURE: &'static str = "validateOutputHash(bytes32,(uint64,bytes32[]))";
4475 const SELECTOR: [u8; 4] = [8u8, 235u8, 137u8, 171u8];
4476 #[inline]
4477 fn new<'a>(
4478 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
4479 ) -> Self {
4480 tuple.into()
4481 }
4482 #[inline]
4483 fn tokenize(&self) -> Self::Token<'_> {
4484 (
4485 <alloy::sol_types::sol_data::FixedBytes<
4486 32,
4487 > as alloy_sol_types::SolType>::tokenize(&self.outputHash),
4488 <OutputValidityProof as alloy_sol_types::SolType>::tokenize(
4489 &self.proof,
4490 ),
4491 )
4492 }
4493 #[inline]
4494 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
4495 validateOutputHashReturn::_tokenize(ret)
4496 }
4497 #[inline]
4498 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
4499 <Self::ReturnTuple<
4500 '_,
4501 > as alloy_sol_types::SolType>::abi_decode_sequence(data)
4502 .map(Into::into)
4503 }
4504 #[inline]
4505 fn abi_decode_returns_validate(
4506 data: &[u8],
4507 ) -> alloy_sol_types::Result<Self::Return> {
4508 <Self::ReturnTuple<
4509 '_,
4510 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
4511 .map(Into::into)
4512 }
4513 }
4514 };
4515 #[derive(serde::Serialize, serde::Deserialize)]
4516 #[derive(Default, Debug, PartialEq, Eq, Hash)]
4517 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
4522 #[derive(Clone)]
4523 pub struct wasOutputExecutedCall {
4524 #[allow(missing_docs)]
4525 pub outputIndex: alloy::sol_types::private::primitives::aliases::U256,
4526 }
4527 #[derive(serde::Serialize, serde::Deserialize)]
4528 #[derive(Default, Debug, PartialEq, Eq, Hash)]
4529 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
4531 #[derive(Clone)]
4532 pub struct wasOutputExecutedReturn {
4533 #[allow(missing_docs)]
4534 pub _0: bool,
4535 }
4536 #[allow(
4537 non_camel_case_types,
4538 non_snake_case,
4539 clippy::pub_underscore_fields,
4540 clippy::style
4541 )]
4542 const _: () = {
4543 use alloy::sol_types as alloy_sol_types;
4544 {
4545 #[doc(hidden)]
4546 #[allow(dead_code)]
4547 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
4548 #[doc(hidden)]
4549 type UnderlyingRustTuple<'a> = (
4550 alloy::sol_types::private::primitives::aliases::U256,
4551 );
4552 #[cfg(test)]
4553 #[allow(dead_code, unreachable_patterns)]
4554 fn _type_assertion(
4555 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
4556 ) {
4557 match _t {
4558 alloy_sol_types::private::AssertTypeEq::<
4559 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
4560 >(_) => {}
4561 }
4562 }
4563 #[automatically_derived]
4564 #[doc(hidden)]
4565 impl ::core::convert::From<wasOutputExecutedCall>
4566 for UnderlyingRustTuple<'_> {
4567 fn from(value: wasOutputExecutedCall) -> Self {
4568 (value.outputIndex,)
4569 }
4570 }
4571 #[automatically_derived]
4572 #[doc(hidden)]
4573 impl ::core::convert::From<UnderlyingRustTuple<'_>>
4574 for wasOutputExecutedCall {
4575 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
4576 Self { outputIndex: tuple.0 }
4577 }
4578 }
4579 }
4580 {
4581 #[doc(hidden)]
4582 #[allow(dead_code)]
4583 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Bool,);
4584 #[doc(hidden)]
4585 type UnderlyingRustTuple<'a> = (bool,);
4586 #[cfg(test)]
4587 #[allow(dead_code, unreachable_patterns)]
4588 fn _type_assertion(
4589 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
4590 ) {
4591 match _t {
4592 alloy_sol_types::private::AssertTypeEq::<
4593 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
4594 >(_) => {}
4595 }
4596 }
4597 #[automatically_derived]
4598 #[doc(hidden)]
4599 impl ::core::convert::From<wasOutputExecutedReturn>
4600 for UnderlyingRustTuple<'_> {
4601 fn from(value: wasOutputExecutedReturn) -> Self {
4602 (value._0,)
4603 }
4604 }
4605 #[automatically_derived]
4606 #[doc(hidden)]
4607 impl ::core::convert::From<UnderlyingRustTuple<'_>>
4608 for wasOutputExecutedReturn {
4609 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
4610 Self { _0: tuple.0 }
4611 }
4612 }
4613 }
4614 #[automatically_derived]
4615 impl alloy_sol_types::SolCall for wasOutputExecutedCall {
4616 type Parameters<'a> = (alloy::sol_types::sol_data::Uint<256>,);
4617 type Token<'a> = <Self::Parameters<
4618 'a,
4619 > as alloy_sol_types::SolType>::Token<'a>;
4620 type Return = bool;
4621 type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,);
4622 type ReturnToken<'a> = <Self::ReturnTuple<
4623 'a,
4624 > as alloy_sol_types::SolType>::Token<'a>;
4625 const SIGNATURE: &'static str = "wasOutputExecuted(uint256)";
4626 const SELECTOR: [u8; 4] = [113u8, 137u8, 29u8, 176u8];
4627 #[inline]
4628 fn new<'a>(
4629 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
4630 ) -> Self {
4631 tuple.into()
4632 }
4633 #[inline]
4634 fn tokenize(&self) -> Self::Token<'_> {
4635 (
4636 <alloy::sol_types::sol_data::Uint<
4637 256,
4638 > as alloy_sol_types::SolType>::tokenize(&self.outputIndex),
4639 )
4640 }
4641 #[inline]
4642 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
4643 (
4644 <alloy::sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(
4645 ret,
4646 ),
4647 )
4648 }
4649 #[inline]
4650 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
4651 <Self::ReturnTuple<
4652 '_,
4653 > as alloy_sol_types::SolType>::abi_decode_sequence(data)
4654 .map(|r| {
4655 let r: wasOutputExecutedReturn = r.into();
4656 r._0
4657 })
4658 }
4659 #[inline]
4660 fn abi_decode_returns_validate(
4661 data: &[u8],
4662 ) -> alloy_sol_types::Result<Self::Return> {
4663 <Self::ReturnTuple<
4664 '_,
4665 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
4666 .map(|r| {
4667 let r: wasOutputExecutedReturn = r.into();
4668 r._0
4669 })
4670 }
4671 }
4672 };
4673 #[derive(Clone)]
4675 #[derive(serde::Serialize, serde::Deserialize)]
4676 #[derive()]
4677 pub enum ApplicationCalls {
4678 #[allow(missing_docs)]
4679 executeOutput(executeOutputCall),
4680 #[allow(missing_docs)]
4681 getDataAvailability(getDataAvailabilityCall),
4682 #[allow(missing_docs)]
4683 getDeploymentBlockNumber(getDeploymentBlockNumberCall),
4684 #[allow(missing_docs)]
4685 getNumberOfExecutedOutputs(getNumberOfExecutedOutputsCall),
4686 #[allow(missing_docs)]
4687 getOutputsMerkleRootValidator(getOutputsMerkleRootValidatorCall),
4688 #[allow(missing_docs)]
4689 getTemplateHash(getTemplateHashCall),
4690 #[allow(missing_docs)]
4691 migrateToOutputsMerkleRootValidator(migrateToOutputsMerkleRootValidatorCall),
4692 #[allow(missing_docs)]
4693 onERC1155BatchReceived(onERC1155BatchReceivedCall),
4694 #[allow(missing_docs)]
4695 onERC1155Received(onERC1155ReceivedCall),
4696 #[allow(missing_docs)]
4697 onERC721Received(onERC721ReceivedCall),
4698 #[allow(missing_docs)]
4699 owner(ownerCall),
4700 #[allow(missing_docs)]
4701 renounceOwnership(renounceOwnershipCall),
4702 #[allow(missing_docs)]
4703 supportsInterface(supportsInterfaceCall),
4704 #[allow(missing_docs)]
4705 transferOwnership(transferOwnershipCall),
4706 #[allow(missing_docs)]
4707 validateOutput(validateOutputCall),
4708 #[allow(missing_docs)]
4709 validateOutputHash(validateOutputHashCall),
4710 #[allow(missing_docs)]
4711 wasOutputExecuted(wasOutputExecutedCall),
4712 }
4713 impl ApplicationCalls {
4714 pub const SELECTORS: &'static [[u8; 4usize]] = &[
4721 [1u8, 255u8, 201u8, 167u8],
4722 [8u8, 235u8, 137u8, 171u8],
4723 [21u8, 11u8, 122u8, 2u8],
4724 [51u8, 19u8, 123u8, 118u8],
4725 [97u8, 177u8, 44u8, 102u8],
4726 [113u8, 80u8, 24u8, 166u8],
4727 [113u8, 137u8, 29u8, 176u8],
4728 [141u8, 165u8, 203u8, 91u8],
4729 [169u8, 77u8, 252u8, 90u8],
4730 [179u8, 161u8, 172u8, 216u8],
4731 [188u8, 25u8, 124u8, 129u8],
4732 [191u8, 138u8, 191u8, 248u8],
4733 [230u8, 79u8, 171u8, 77u8],
4734 [232u8, 141u8, 57u8, 192u8],
4735 [240u8, 36u8, 120u8, 222u8],
4736 [242u8, 58u8, 110u8, 97u8],
4737 [242u8, 253u8, 227u8, 139u8],
4738 ];
4739 pub const VARIANT_NAMES: &'static [&'static str] = &[
4741 ::core::stringify!(supportsInterface),
4742 ::core::stringify!(validateOutputHash),
4743 ::core::stringify!(onERC721Received),
4744 ::core::stringify!(executeOutput),
4745 ::core::stringify!(getTemplateHash),
4746 ::core::stringify!(renounceOwnership),
4747 ::core::stringify!(wasOutputExecuted),
4748 ::core::stringify!(owner),
4749 ::core::stringify!(getOutputsMerkleRootValidator),
4750 ::core::stringify!(getDeploymentBlockNumber),
4751 ::core::stringify!(onERC1155BatchReceived),
4752 ::core::stringify!(migrateToOutputsMerkleRootValidator),
4753 ::core::stringify!(getNumberOfExecutedOutputs),
4754 ::core::stringify!(validateOutput),
4755 ::core::stringify!(getDataAvailability),
4756 ::core::stringify!(onERC1155Received),
4757 ::core::stringify!(transferOwnership),
4758 ];
4759 pub const SIGNATURES: &'static [&'static str] = &[
4761 <supportsInterfaceCall as alloy_sol_types::SolCall>::SIGNATURE,
4762 <validateOutputHashCall as alloy_sol_types::SolCall>::SIGNATURE,
4763 <onERC721ReceivedCall as alloy_sol_types::SolCall>::SIGNATURE,
4764 <executeOutputCall as alloy_sol_types::SolCall>::SIGNATURE,
4765 <getTemplateHashCall as alloy_sol_types::SolCall>::SIGNATURE,
4766 <renounceOwnershipCall as alloy_sol_types::SolCall>::SIGNATURE,
4767 <wasOutputExecutedCall as alloy_sol_types::SolCall>::SIGNATURE,
4768 <ownerCall as alloy_sol_types::SolCall>::SIGNATURE,
4769 <getOutputsMerkleRootValidatorCall as alloy_sol_types::SolCall>::SIGNATURE,
4770 <getDeploymentBlockNumberCall as alloy_sol_types::SolCall>::SIGNATURE,
4771 <onERC1155BatchReceivedCall as alloy_sol_types::SolCall>::SIGNATURE,
4772 <migrateToOutputsMerkleRootValidatorCall as alloy_sol_types::SolCall>::SIGNATURE,
4773 <getNumberOfExecutedOutputsCall as alloy_sol_types::SolCall>::SIGNATURE,
4774 <validateOutputCall as alloy_sol_types::SolCall>::SIGNATURE,
4775 <getDataAvailabilityCall as alloy_sol_types::SolCall>::SIGNATURE,
4776 <onERC1155ReceivedCall as alloy_sol_types::SolCall>::SIGNATURE,
4777 <transferOwnershipCall as alloy_sol_types::SolCall>::SIGNATURE,
4778 ];
4779 #[inline]
4781 pub fn signature_by_selector(
4782 selector: [u8; 4usize],
4783 ) -> ::core::option::Option<&'static str> {
4784 match Self::SELECTORS.binary_search(&selector) {
4785 ::core::result::Result::Ok(idx) => {
4786 ::core::option::Option::Some(Self::SIGNATURES[idx])
4787 }
4788 ::core::result::Result::Err(_) => ::core::option::Option::None,
4789 }
4790 }
4791 #[inline]
4793 pub fn name_by_selector(
4794 selector: [u8; 4usize],
4795 ) -> ::core::option::Option<&'static str> {
4796 let sig = Self::signature_by_selector(selector)?;
4797 sig.split_once('(').map(|(name, _)| name)
4798 }
4799 }
4800 #[automatically_derived]
4801 impl alloy_sol_types::SolInterface for ApplicationCalls {
4802 const NAME: &'static str = "ApplicationCalls";
4803 const MIN_DATA_LENGTH: usize = 0usize;
4804 const COUNT: usize = 17usize;
4805 #[inline]
4806 fn selector(&self) -> [u8; 4] {
4807 match self {
4808 Self::executeOutput(_) => {
4809 <executeOutputCall as alloy_sol_types::SolCall>::SELECTOR
4810 }
4811 Self::getDataAvailability(_) => {
4812 <getDataAvailabilityCall as alloy_sol_types::SolCall>::SELECTOR
4813 }
4814 Self::getDeploymentBlockNumber(_) => {
4815 <getDeploymentBlockNumberCall as alloy_sol_types::SolCall>::SELECTOR
4816 }
4817 Self::getNumberOfExecutedOutputs(_) => {
4818 <getNumberOfExecutedOutputsCall as alloy_sol_types::SolCall>::SELECTOR
4819 }
4820 Self::getOutputsMerkleRootValidator(_) => {
4821 <getOutputsMerkleRootValidatorCall as alloy_sol_types::SolCall>::SELECTOR
4822 }
4823 Self::getTemplateHash(_) => {
4824 <getTemplateHashCall as alloy_sol_types::SolCall>::SELECTOR
4825 }
4826 Self::migrateToOutputsMerkleRootValidator(_) => {
4827 <migrateToOutputsMerkleRootValidatorCall as alloy_sol_types::SolCall>::SELECTOR
4828 }
4829 Self::onERC1155BatchReceived(_) => {
4830 <onERC1155BatchReceivedCall as alloy_sol_types::SolCall>::SELECTOR
4831 }
4832 Self::onERC1155Received(_) => {
4833 <onERC1155ReceivedCall as alloy_sol_types::SolCall>::SELECTOR
4834 }
4835 Self::onERC721Received(_) => {
4836 <onERC721ReceivedCall as alloy_sol_types::SolCall>::SELECTOR
4837 }
4838 Self::owner(_) => <ownerCall as alloy_sol_types::SolCall>::SELECTOR,
4839 Self::renounceOwnership(_) => {
4840 <renounceOwnershipCall as alloy_sol_types::SolCall>::SELECTOR
4841 }
4842 Self::supportsInterface(_) => {
4843 <supportsInterfaceCall as alloy_sol_types::SolCall>::SELECTOR
4844 }
4845 Self::transferOwnership(_) => {
4846 <transferOwnershipCall as alloy_sol_types::SolCall>::SELECTOR
4847 }
4848 Self::validateOutput(_) => {
4849 <validateOutputCall as alloy_sol_types::SolCall>::SELECTOR
4850 }
4851 Self::validateOutputHash(_) => {
4852 <validateOutputHashCall as alloy_sol_types::SolCall>::SELECTOR
4853 }
4854 Self::wasOutputExecuted(_) => {
4855 <wasOutputExecutedCall as alloy_sol_types::SolCall>::SELECTOR
4856 }
4857 }
4858 }
4859 #[inline]
4860 fn selector_at(i: usize) -> ::core::option::Option<[u8; 4]> {
4861 Self::SELECTORS.get(i).copied()
4862 }
4863 #[inline]
4864 fn valid_selector(selector: [u8; 4]) -> bool {
4865 Self::SELECTORS.binary_search(&selector).is_ok()
4866 }
4867 #[inline]
4868 #[allow(non_snake_case)]
4869 fn abi_decode_raw(
4870 selector: [u8; 4],
4871 data: &[u8],
4872 ) -> alloy_sol_types::Result<Self> {
4873 static DECODE_SHIMS: &[fn(
4874 &[u8],
4875 ) -> alloy_sol_types::Result<ApplicationCalls>] = &[
4876 {
4877 fn supportsInterface(
4878 data: &[u8],
4879 ) -> alloy_sol_types::Result<ApplicationCalls> {
4880 <supportsInterfaceCall as alloy_sol_types::SolCall>::abi_decode_raw(
4881 data,
4882 )
4883 .map(ApplicationCalls::supportsInterface)
4884 }
4885 supportsInterface
4886 },
4887 {
4888 fn validateOutputHash(
4889 data: &[u8],
4890 ) -> alloy_sol_types::Result<ApplicationCalls> {
4891 <validateOutputHashCall as alloy_sol_types::SolCall>::abi_decode_raw(
4892 data,
4893 )
4894 .map(ApplicationCalls::validateOutputHash)
4895 }
4896 validateOutputHash
4897 },
4898 {
4899 fn onERC721Received(
4900 data: &[u8],
4901 ) -> alloy_sol_types::Result<ApplicationCalls> {
4902 <onERC721ReceivedCall as alloy_sol_types::SolCall>::abi_decode_raw(
4903 data,
4904 )
4905 .map(ApplicationCalls::onERC721Received)
4906 }
4907 onERC721Received
4908 },
4909 {
4910 fn executeOutput(
4911 data: &[u8],
4912 ) -> alloy_sol_types::Result<ApplicationCalls> {
4913 <executeOutputCall as alloy_sol_types::SolCall>::abi_decode_raw(
4914 data,
4915 )
4916 .map(ApplicationCalls::executeOutput)
4917 }
4918 executeOutput
4919 },
4920 {
4921 fn getTemplateHash(
4922 data: &[u8],
4923 ) -> alloy_sol_types::Result<ApplicationCalls> {
4924 <getTemplateHashCall as alloy_sol_types::SolCall>::abi_decode_raw(
4925 data,
4926 )
4927 .map(ApplicationCalls::getTemplateHash)
4928 }
4929 getTemplateHash
4930 },
4931 {
4932 fn renounceOwnership(
4933 data: &[u8],
4934 ) -> alloy_sol_types::Result<ApplicationCalls> {
4935 <renounceOwnershipCall as alloy_sol_types::SolCall>::abi_decode_raw(
4936 data,
4937 )
4938 .map(ApplicationCalls::renounceOwnership)
4939 }
4940 renounceOwnership
4941 },
4942 {
4943 fn wasOutputExecuted(
4944 data: &[u8],
4945 ) -> alloy_sol_types::Result<ApplicationCalls> {
4946 <wasOutputExecutedCall as alloy_sol_types::SolCall>::abi_decode_raw(
4947 data,
4948 )
4949 .map(ApplicationCalls::wasOutputExecuted)
4950 }
4951 wasOutputExecuted
4952 },
4953 {
4954 fn owner(data: &[u8]) -> alloy_sol_types::Result<ApplicationCalls> {
4955 <ownerCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
4956 .map(ApplicationCalls::owner)
4957 }
4958 owner
4959 },
4960 {
4961 fn getOutputsMerkleRootValidator(
4962 data: &[u8],
4963 ) -> alloy_sol_types::Result<ApplicationCalls> {
4964 <getOutputsMerkleRootValidatorCall as alloy_sol_types::SolCall>::abi_decode_raw(
4965 data,
4966 )
4967 .map(ApplicationCalls::getOutputsMerkleRootValidator)
4968 }
4969 getOutputsMerkleRootValidator
4970 },
4971 {
4972 fn getDeploymentBlockNumber(
4973 data: &[u8],
4974 ) -> alloy_sol_types::Result<ApplicationCalls> {
4975 <getDeploymentBlockNumberCall as alloy_sol_types::SolCall>::abi_decode_raw(
4976 data,
4977 )
4978 .map(ApplicationCalls::getDeploymentBlockNumber)
4979 }
4980 getDeploymentBlockNumber
4981 },
4982 {
4983 fn onERC1155BatchReceived(
4984 data: &[u8],
4985 ) -> alloy_sol_types::Result<ApplicationCalls> {
4986 <onERC1155BatchReceivedCall as alloy_sol_types::SolCall>::abi_decode_raw(
4987 data,
4988 )
4989 .map(ApplicationCalls::onERC1155BatchReceived)
4990 }
4991 onERC1155BatchReceived
4992 },
4993 {
4994 fn migrateToOutputsMerkleRootValidator(
4995 data: &[u8],
4996 ) -> alloy_sol_types::Result<ApplicationCalls> {
4997 <migrateToOutputsMerkleRootValidatorCall as alloy_sol_types::SolCall>::abi_decode_raw(
4998 data,
4999 )
5000 .map(ApplicationCalls::migrateToOutputsMerkleRootValidator)
5001 }
5002 migrateToOutputsMerkleRootValidator
5003 },
5004 {
5005 fn getNumberOfExecutedOutputs(
5006 data: &[u8],
5007 ) -> alloy_sol_types::Result<ApplicationCalls> {
5008 <getNumberOfExecutedOutputsCall as alloy_sol_types::SolCall>::abi_decode_raw(
5009 data,
5010 )
5011 .map(ApplicationCalls::getNumberOfExecutedOutputs)
5012 }
5013 getNumberOfExecutedOutputs
5014 },
5015 {
5016 fn validateOutput(
5017 data: &[u8],
5018 ) -> alloy_sol_types::Result<ApplicationCalls> {
5019 <validateOutputCall as alloy_sol_types::SolCall>::abi_decode_raw(
5020 data,
5021 )
5022 .map(ApplicationCalls::validateOutput)
5023 }
5024 validateOutput
5025 },
5026 {
5027 fn getDataAvailability(
5028 data: &[u8],
5029 ) -> alloy_sol_types::Result<ApplicationCalls> {
5030 <getDataAvailabilityCall as alloy_sol_types::SolCall>::abi_decode_raw(
5031 data,
5032 )
5033 .map(ApplicationCalls::getDataAvailability)
5034 }
5035 getDataAvailability
5036 },
5037 {
5038 fn onERC1155Received(
5039 data: &[u8],
5040 ) -> alloy_sol_types::Result<ApplicationCalls> {
5041 <onERC1155ReceivedCall as alloy_sol_types::SolCall>::abi_decode_raw(
5042 data,
5043 )
5044 .map(ApplicationCalls::onERC1155Received)
5045 }
5046 onERC1155Received
5047 },
5048 {
5049 fn transferOwnership(
5050 data: &[u8],
5051 ) -> alloy_sol_types::Result<ApplicationCalls> {
5052 <transferOwnershipCall as alloy_sol_types::SolCall>::abi_decode_raw(
5053 data,
5054 )
5055 .map(ApplicationCalls::transferOwnership)
5056 }
5057 transferOwnership
5058 },
5059 ];
5060 let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
5061 return Err(
5062 alloy_sol_types::Error::unknown_selector(
5063 <Self as alloy_sol_types::SolInterface>::NAME,
5064 selector,
5065 ),
5066 );
5067 };
5068 DECODE_SHIMS[idx](data)
5069 }
5070 #[inline]
5071 #[allow(non_snake_case)]
5072 fn abi_decode_raw_validate(
5073 selector: [u8; 4],
5074 data: &[u8],
5075 ) -> alloy_sol_types::Result<Self> {
5076 static DECODE_VALIDATE_SHIMS: &[fn(
5077 &[u8],
5078 ) -> alloy_sol_types::Result<ApplicationCalls>] = &[
5079 {
5080 fn supportsInterface(
5081 data: &[u8],
5082 ) -> alloy_sol_types::Result<ApplicationCalls> {
5083 <supportsInterfaceCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
5084 data,
5085 )
5086 .map(ApplicationCalls::supportsInterface)
5087 }
5088 supportsInterface
5089 },
5090 {
5091 fn validateOutputHash(
5092 data: &[u8],
5093 ) -> alloy_sol_types::Result<ApplicationCalls> {
5094 <validateOutputHashCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
5095 data,
5096 )
5097 .map(ApplicationCalls::validateOutputHash)
5098 }
5099 validateOutputHash
5100 },
5101 {
5102 fn onERC721Received(
5103 data: &[u8],
5104 ) -> alloy_sol_types::Result<ApplicationCalls> {
5105 <onERC721ReceivedCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
5106 data,
5107 )
5108 .map(ApplicationCalls::onERC721Received)
5109 }
5110 onERC721Received
5111 },
5112 {
5113 fn executeOutput(
5114 data: &[u8],
5115 ) -> alloy_sol_types::Result<ApplicationCalls> {
5116 <executeOutputCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
5117 data,
5118 )
5119 .map(ApplicationCalls::executeOutput)
5120 }
5121 executeOutput
5122 },
5123 {
5124 fn getTemplateHash(
5125 data: &[u8],
5126 ) -> alloy_sol_types::Result<ApplicationCalls> {
5127 <getTemplateHashCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
5128 data,
5129 )
5130 .map(ApplicationCalls::getTemplateHash)
5131 }
5132 getTemplateHash
5133 },
5134 {
5135 fn renounceOwnership(
5136 data: &[u8],
5137 ) -> alloy_sol_types::Result<ApplicationCalls> {
5138 <renounceOwnershipCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
5139 data,
5140 )
5141 .map(ApplicationCalls::renounceOwnership)
5142 }
5143 renounceOwnership
5144 },
5145 {
5146 fn wasOutputExecuted(
5147 data: &[u8],
5148 ) -> alloy_sol_types::Result<ApplicationCalls> {
5149 <wasOutputExecutedCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
5150 data,
5151 )
5152 .map(ApplicationCalls::wasOutputExecuted)
5153 }
5154 wasOutputExecuted
5155 },
5156 {
5157 fn owner(data: &[u8]) -> alloy_sol_types::Result<ApplicationCalls> {
5158 <ownerCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
5159 data,
5160 )
5161 .map(ApplicationCalls::owner)
5162 }
5163 owner
5164 },
5165 {
5166 fn getOutputsMerkleRootValidator(
5167 data: &[u8],
5168 ) -> alloy_sol_types::Result<ApplicationCalls> {
5169 <getOutputsMerkleRootValidatorCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
5170 data,
5171 )
5172 .map(ApplicationCalls::getOutputsMerkleRootValidator)
5173 }
5174 getOutputsMerkleRootValidator
5175 },
5176 {
5177 fn getDeploymentBlockNumber(
5178 data: &[u8],
5179 ) -> alloy_sol_types::Result<ApplicationCalls> {
5180 <getDeploymentBlockNumberCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
5181 data,
5182 )
5183 .map(ApplicationCalls::getDeploymentBlockNumber)
5184 }
5185 getDeploymentBlockNumber
5186 },
5187 {
5188 fn onERC1155BatchReceived(
5189 data: &[u8],
5190 ) -> alloy_sol_types::Result<ApplicationCalls> {
5191 <onERC1155BatchReceivedCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
5192 data,
5193 )
5194 .map(ApplicationCalls::onERC1155BatchReceived)
5195 }
5196 onERC1155BatchReceived
5197 },
5198 {
5199 fn migrateToOutputsMerkleRootValidator(
5200 data: &[u8],
5201 ) -> alloy_sol_types::Result<ApplicationCalls> {
5202 <migrateToOutputsMerkleRootValidatorCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
5203 data,
5204 )
5205 .map(ApplicationCalls::migrateToOutputsMerkleRootValidator)
5206 }
5207 migrateToOutputsMerkleRootValidator
5208 },
5209 {
5210 fn getNumberOfExecutedOutputs(
5211 data: &[u8],
5212 ) -> alloy_sol_types::Result<ApplicationCalls> {
5213 <getNumberOfExecutedOutputsCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
5214 data,
5215 )
5216 .map(ApplicationCalls::getNumberOfExecutedOutputs)
5217 }
5218 getNumberOfExecutedOutputs
5219 },
5220 {
5221 fn validateOutput(
5222 data: &[u8],
5223 ) -> alloy_sol_types::Result<ApplicationCalls> {
5224 <validateOutputCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
5225 data,
5226 )
5227 .map(ApplicationCalls::validateOutput)
5228 }
5229 validateOutput
5230 },
5231 {
5232 fn getDataAvailability(
5233 data: &[u8],
5234 ) -> alloy_sol_types::Result<ApplicationCalls> {
5235 <getDataAvailabilityCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
5236 data,
5237 )
5238 .map(ApplicationCalls::getDataAvailability)
5239 }
5240 getDataAvailability
5241 },
5242 {
5243 fn onERC1155Received(
5244 data: &[u8],
5245 ) -> alloy_sol_types::Result<ApplicationCalls> {
5246 <onERC1155ReceivedCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
5247 data,
5248 )
5249 .map(ApplicationCalls::onERC1155Received)
5250 }
5251 onERC1155Received
5252 },
5253 {
5254 fn transferOwnership(
5255 data: &[u8],
5256 ) -> alloy_sol_types::Result<ApplicationCalls> {
5257 <transferOwnershipCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
5258 data,
5259 )
5260 .map(ApplicationCalls::transferOwnership)
5261 }
5262 transferOwnership
5263 },
5264 ];
5265 let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
5266 return Err(
5267 alloy_sol_types::Error::unknown_selector(
5268 <Self as alloy_sol_types::SolInterface>::NAME,
5269 selector,
5270 ),
5271 );
5272 };
5273 DECODE_VALIDATE_SHIMS[idx](data)
5274 }
5275 #[inline]
5276 fn abi_encoded_size(&self) -> usize {
5277 match self {
5278 Self::executeOutput(inner) => {
5279 <executeOutputCall as alloy_sol_types::SolCall>::abi_encoded_size(
5280 inner,
5281 )
5282 }
5283 Self::getDataAvailability(inner) => {
5284 <getDataAvailabilityCall as alloy_sol_types::SolCall>::abi_encoded_size(
5285 inner,
5286 )
5287 }
5288 Self::getDeploymentBlockNumber(inner) => {
5289 <getDeploymentBlockNumberCall as alloy_sol_types::SolCall>::abi_encoded_size(
5290 inner,
5291 )
5292 }
5293 Self::getNumberOfExecutedOutputs(inner) => {
5294 <getNumberOfExecutedOutputsCall as alloy_sol_types::SolCall>::abi_encoded_size(
5295 inner,
5296 )
5297 }
5298 Self::getOutputsMerkleRootValidator(inner) => {
5299 <getOutputsMerkleRootValidatorCall as alloy_sol_types::SolCall>::abi_encoded_size(
5300 inner,
5301 )
5302 }
5303 Self::getTemplateHash(inner) => {
5304 <getTemplateHashCall as alloy_sol_types::SolCall>::abi_encoded_size(
5305 inner,
5306 )
5307 }
5308 Self::migrateToOutputsMerkleRootValidator(inner) => {
5309 <migrateToOutputsMerkleRootValidatorCall as alloy_sol_types::SolCall>::abi_encoded_size(
5310 inner,
5311 )
5312 }
5313 Self::onERC1155BatchReceived(inner) => {
5314 <onERC1155BatchReceivedCall as alloy_sol_types::SolCall>::abi_encoded_size(
5315 inner,
5316 )
5317 }
5318 Self::onERC1155Received(inner) => {
5319 <onERC1155ReceivedCall as alloy_sol_types::SolCall>::abi_encoded_size(
5320 inner,
5321 )
5322 }
5323 Self::onERC721Received(inner) => {
5324 <onERC721ReceivedCall as alloy_sol_types::SolCall>::abi_encoded_size(
5325 inner,
5326 )
5327 }
5328 Self::owner(inner) => {
5329 <ownerCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
5330 }
5331 Self::renounceOwnership(inner) => {
5332 <renounceOwnershipCall as alloy_sol_types::SolCall>::abi_encoded_size(
5333 inner,
5334 )
5335 }
5336 Self::supportsInterface(inner) => {
5337 <supportsInterfaceCall as alloy_sol_types::SolCall>::abi_encoded_size(
5338 inner,
5339 )
5340 }
5341 Self::transferOwnership(inner) => {
5342 <transferOwnershipCall as alloy_sol_types::SolCall>::abi_encoded_size(
5343 inner,
5344 )
5345 }
5346 Self::validateOutput(inner) => {
5347 <validateOutputCall as alloy_sol_types::SolCall>::abi_encoded_size(
5348 inner,
5349 )
5350 }
5351 Self::validateOutputHash(inner) => {
5352 <validateOutputHashCall as alloy_sol_types::SolCall>::abi_encoded_size(
5353 inner,
5354 )
5355 }
5356 Self::wasOutputExecuted(inner) => {
5357 <wasOutputExecutedCall as alloy_sol_types::SolCall>::abi_encoded_size(
5358 inner,
5359 )
5360 }
5361 }
5362 }
5363 #[inline]
5364 fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
5365 match self {
5366 Self::executeOutput(inner) => {
5367 <executeOutputCall as alloy_sol_types::SolCall>::abi_encode_raw(
5368 inner,
5369 out,
5370 )
5371 }
5372 Self::getDataAvailability(inner) => {
5373 <getDataAvailabilityCall as alloy_sol_types::SolCall>::abi_encode_raw(
5374 inner,
5375 out,
5376 )
5377 }
5378 Self::getDeploymentBlockNumber(inner) => {
5379 <getDeploymentBlockNumberCall as alloy_sol_types::SolCall>::abi_encode_raw(
5380 inner,
5381 out,
5382 )
5383 }
5384 Self::getNumberOfExecutedOutputs(inner) => {
5385 <getNumberOfExecutedOutputsCall as alloy_sol_types::SolCall>::abi_encode_raw(
5386 inner,
5387 out,
5388 )
5389 }
5390 Self::getOutputsMerkleRootValidator(inner) => {
5391 <getOutputsMerkleRootValidatorCall as alloy_sol_types::SolCall>::abi_encode_raw(
5392 inner,
5393 out,
5394 )
5395 }
5396 Self::getTemplateHash(inner) => {
5397 <getTemplateHashCall as alloy_sol_types::SolCall>::abi_encode_raw(
5398 inner,
5399 out,
5400 )
5401 }
5402 Self::migrateToOutputsMerkleRootValidator(inner) => {
5403 <migrateToOutputsMerkleRootValidatorCall as alloy_sol_types::SolCall>::abi_encode_raw(
5404 inner,
5405 out,
5406 )
5407 }
5408 Self::onERC1155BatchReceived(inner) => {
5409 <onERC1155BatchReceivedCall as alloy_sol_types::SolCall>::abi_encode_raw(
5410 inner,
5411 out,
5412 )
5413 }
5414 Self::onERC1155Received(inner) => {
5415 <onERC1155ReceivedCall as alloy_sol_types::SolCall>::abi_encode_raw(
5416 inner,
5417 out,
5418 )
5419 }
5420 Self::onERC721Received(inner) => {
5421 <onERC721ReceivedCall as alloy_sol_types::SolCall>::abi_encode_raw(
5422 inner,
5423 out,
5424 )
5425 }
5426 Self::owner(inner) => {
5427 <ownerCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
5428 }
5429 Self::renounceOwnership(inner) => {
5430 <renounceOwnershipCall as alloy_sol_types::SolCall>::abi_encode_raw(
5431 inner,
5432 out,
5433 )
5434 }
5435 Self::supportsInterface(inner) => {
5436 <supportsInterfaceCall as alloy_sol_types::SolCall>::abi_encode_raw(
5437 inner,
5438 out,
5439 )
5440 }
5441 Self::transferOwnership(inner) => {
5442 <transferOwnershipCall as alloy_sol_types::SolCall>::abi_encode_raw(
5443 inner,
5444 out,
5445 )
5446 }
5447 Self::validateOutput(inner) => {
5448 <validateOutputCall as alloy_sol_types::SolCall>::abi_encode_raw(
5449 inner,
5450 out,
5451 )
5452 }
5453 Self::validateOutputHash(inner) => {
5454 <validateOutputHashCall as alloy_sol_types::SolCall>::abi_encode_raw(
5455 inner,
5456 out,
5457 )
5458 }
5459 Self::wasOutputExecuted(inner) => {
5460 <wasOutputExecutedCall as alloy_sol_types::SolCall>::abi_encode_raw(
5461 inner,
5462 out,
5463 )
5464 }
5465 }
5466 }
5467 }
5468 #[derive(Clone)]
5470 #[derive(serde::Serialize, serde::Deserialize)]
5471 #[derive(Debug, PartialEq, Eq, Hash)]
5472 pub enum ApplicationErrors {
5473 #[allow(missing_docs)]
5474 InsufficientFunds(InsufficientFunds),
5475 #[allow(missing_docs)]
5476 InvalidOutputHashesSiblingsArrayLength(InvalidOutputHashesSiblingsArrayLength),
5477 #[allow(missing_docs)]
5478 InvalidOutputsMerkleRoot(InvalidOutputsMerkleRoot),
5479 #[allow(missing_docs)]
5480 OutputNotExecutable(OutputNotExecutable),
5481 #[allow(missing_docs)]
5482 OutputNotReexecutable(OutputNotReexecutable),
5483 #[allow(missing_docs)]
5484 OwnableInvalidOwner(OwnableInvalidOwner),
5485 #[allow(missing_docs)]
5486 OwnableUnauthorizedAccount(OwnableUnauthorizedAccount),
5487 #[allow(missing_docs)]
5488 ReentrancyGuardReentrantCall(ReentrancyGuardReentrantCall),
5489 }
5490 impl ApplicationErrors {
5491 pub const SELECTORS: &'static [[u8; 4usize]] = &[
5498 [3u8, 235u8, 139u8, 84u8],
5499 [17u8, 140u8, 218u8, 167u8],
5500 [30u8, 79u8, 189u8, 247u8],
5501 [62u8, 229u8, 174u8, 181u8],
5502 [68u8, 161u8, 146u8, 255u8],
5503 [123u8, 151u8, 166u8, 187u8],
5504 [186u8, 88u8, 189u8, 54u8],
5505 [210u8, 132u8, 192u8, 30u8],
5506 ];
5507 pub const VARIANT_NAMES: &'static [&'static str] = &[
5509 ::core::stringify!(InsufficientFunds),
5510 ::core::stringify!(OwnableUnauthorizedAccount),
5511 ::core::stringify!(OwnableInvalidOwner),
5512 ::core::stringify!(ReentrancyGuardReentrantCall),
5513 ::core::stringify!(InvalidOutputsMerkleRoot),
5514 ::core::stringify!(OutputNotReexecutable),
5515 ::core::stringify!(InvalidOutputHashesSiblingsArrayLength),
5516 ::core::stringify!(OutputNotExecutable),
5517 ];
5518 pub const SIGNATURES: &'static [&'static str] = &[
5520 <InsufficientFunds as alloy_sol_types::SolError>::SIGNATURE,
5521 <OwnableUnauthorizedAccount as alloy_sol_types::SolError>::SIGNATURE,
5522 <OwnableInvalidOwner as alloy_sol_types::SolError>::SIGNATURE,
5523 <ReentrancyGuardReentrantCall as alloy_sol_types::SolError>::SIGNATURE,
5524 <InvalidOutputsMerkleRoot as alloy_sol_types::SolError>::SIGNATURE,
5525 <OutputNotReexecutable as alloy_sol_types::SolError>::SIGNATURE,
5526 <InvalidOutputHashesSiblingsArrayLength as alloy_sol_types::SolError>::SIGNATURE,
5527 <OutputNotExecutable as alloy_sol_types::SolError>::SIGNATURE,
5528 ];
5529 #[inline]
5531 pub fn signature_by_selector(
5532 selector: [u8; 4usize],
5533 ) -> ::core::option::Option<&'static str> {
5534 match Self::SELECTORS.binary_search(&selector) {
5535 ::core::result::Result::Ok(idx) => {
5536 ::core::option::Option::Some(Self::SIGNATURES[idx])
5537 }
5538 ::core::result::Result::Err(_) => ::core::option::Option::None,
5539 }
5540 }
5541 #[inline]
5543 pub fn name_by_selector(
5544 selector: [u8; 4usize],
5545 ) -> ::core::option::Option<&'static str> {
5546 let sig = Self::signature_by_selector(selector)?;
5547 sig.split_once('(').map(|(name, _)| name)
5548 }
5549 }
5550 #[automatically_derived]
5551 impl alloy_sol_types::SolInterface for ApplicationErrors {
5552 const NAME: &'static str = "ApplicationErrors";
5553 const MIN_DATA_LENGTH: usize = 0usize;
5554 const COUNT: usize = 8usize;
5555 #[inline]
5556 fn selector(&self) -> [u8; 4] {
5557 match self {
5558 Self::InsufficientFunds(_) => {
5559 <InsufficientFunds as alloy_sol_types::SolError>::SELECTOR
5560 }
5561 Self::InvalidOutputHashesSiblingsArrayLength(_) => {
5562 <InvalidOutputHashesSiblingsArrayLength as alloy_sol_types::SolError>::SELECTOR
5563 }
5564 Self::InvalidOutputsMerkleRoot(_) => {
5565 <InvalidOutputsMerkleRoot as alloy_sol_types::SolError>::SELECTOR
5566 }
5567 Self::OutputNotExecutable(_) => {
5568 <OutputNotExecutable as alloy_sol_types::SolError>::SELECTOR
5569 }
5570 Self::OutputNotReexecutable(_) => {
5571 <OutputNotReexecutable as alloy_sol_types::SolError>::SELECTOR
5572 }
5573 Self::OwnableInvalidOwner(_) => {
5574 <OwnableInvalidOwner as alloy_sol_types::SolError>::SELECTOR
5575 }
5576 Self::OwnableUnauthorizedAccount(_) => {
5577 <OwnableUnauthorizedAccount as alloy_sol_types::SolError>::SELECTOR
5578 }
5579 Self::ReentrancyGuardReentrantCall(_) => {
5580 <ReentrancyGuardReentrantCall as alloy_sol_types::SolError>::SELECTOR
5581 }
5582 }
5583 }
5584 #[inline]
5585 fn selector_at(i: usize) -> ::core::option::Option<[u8; 4]> {
5586 Self::SELECTORS.get(i).copied()
5587 }
5588 #[inline]
5589 fn valid_selector(selector: [u8; 4]) -> bool {
5590 Self::SELECTORS.binary_search(&selector).is_ok()
5591 }
5592 #[inline]
5593 #[allow(non_snake_case)]
5594 fn abi_decode_raw(
5595 selector: [u8; 4],
5596 data: &[u8],
5597 ) -> alloy_sol_types::Result<Self> {
5598 static DECODE_SHIMS: &[fn(
5599 &[u8],
5600 ) -> alloy_sol_types::Result<ApplicationErrors>] = &[
5601 {
5602 fn InsufficientFunds(
5603 data: &[u8],
5604 ) -> alloy_sol_types::Result<ApplicationErrors> {
5605 <InsufficientFunds as alloy_sol_types::SolError>::abi_decode_raw(
5606 data,
5607 )
5608 .map(ApplicationErrors::InsufficientFunds)
5609 }
5610 InsufficientFunds
5611 },
5612 {
5613 fn OwnableUnauthorizedAccount(
5614 data: &[u8],
5615 ) -> alloy_sol_types::Result<ApplicationErrors> {
5616 <OwnableUnauthorizedAccount as alloy_sol_types::SolError>::abi_decode_raw(
5617 data,
5618 )
5619 .map(ApplicationErrors::OwnableUnauthorizedAccount)
5620 }
5621 OwnableUnauthorizedAccount
5622 },
5623 {
5624 fn OwnableInvalidOwner(
5625 data: &[u8],
5626 ) -> alloy_sol_types::Result<ApplicationErrors> {
5627 <OwnableInvalidOwner as alloy_sol_types::SolError>::abi_decode_raw(
5628 data,
5629 )
5630 .map(ApplicationErrors::OwnableInvalidOwner)
5631 }
5632 OwnableInvalidOwner
5633 },
5634 {
5635 fn ReentrancyGuardReentrantCall(
5636 data: &[u8],
5637 ) -> alloy_sol_types::Result<ApplicationErrors> {
5638 <ReentrancyGuardReentrantCall as alloy_sol_types::SolError>::abi_decode_raw(
5639 data,
5640 )
5641 .map(ApplicationErrors::ReentrancyGuardReentrantCall)
5642 }
5643 ReentrancyGuardReentrantCall
5644 },
5645 {
5646 fn InvalidOutputsMerkleRoot(
5647 data: &[u8],
5648 ) -> alloy_sol_types::Result<ApplicationErrors> {
5649 <InvalidOutputsMerkleRoot as alloy_sol_types::SolError>::abi_decode_raw(
5650 data,
5651 )
5652 .map(ApplicationErrors::InvalidOutputsMerkleRoot)
5653 }
5654 InvalidOutputsMerkleRoot
5655 },
5656 {
5657 fn OutputNotReexecutable(
5658 data: &[u8],
5659 ) -> alloy_sol_types::Result<ApplicationErrors> {
5660 <OutputNotReexecutable as alloy_sol_types::SolError>::abi_decode_raw(
5661 data,
5662 )
5663 .map(ApplicationErrors::OutputNotReexecutable)
5664 }
5665 OutputNotReexecutable
5666 },
5667 {
5668 fn InvalidOutputHashesSiblingsArrayLength(
5669 data: &[u8],
5670 ) -> alloy_sol_types::Result<ApplicationErrors> {
5671 <InvalidOutputHashesSiblingsArrayLength as alloy_sol_types::SolError>::abi_decode_raw(
5672 data,
5673 )
5674 .map(
5675 ApplicationErrors::InvalidOutputHashesSiblingsArrayLength,
5676 )
5677 }
5678 InvalidOutputHashesSiblingsArrayLength
5679 },
5680 {
5681 fn OutputNotExecutable(
5682 data: &[u8],
5683 ) -> alloy_sol_types::Result<ApplicationErrors> {
5684 <OutputNotExecutable as alloy_sol_types::SolError>::abi_decode_raw(
5685 data,
5686 )
5687 .map(ApplicationErrors::OutputNotExecutable)
5688 }
5689 OutputNotExecutable
5690 },
5691 ];
5692 let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
5693 return Err(
5694 alloy_sol_types::Error::unknown_selector(
5695 <Self as alloy_sol_types::SolInterface>::NAME,
5696 selector,
5697 ),
5698 );
5699 };
5700 DECODE_SHIMS[idx](data)
5701 }
5702 #[inline]
5703 #[allow(non_snake_case)]
5704 fn abi_decode_raw_validate(
5705 selector: [u8; 4],
5706 data: &[u8],
5707 ) -> alloy_sol_types::Result<Self> {
5708 static DECODE_VALIDATE_SHIMS: &[fn(
5709 &[u8],
5710 ) -> alloy_sol_types::Result<ApplicationErrors>] = &[
5711 {
5712 fn InsufficientFunds(
5713 data: &[u8],
5714 ) -> alloy_sol_types::Result<ApplicationErrors> {
5715 <InsufficientFunds as alloy_sol_types::SolError>::abi_decode_raw_validate(
5716 data,
5717 )
5718 .map(ApplicationErrors::InsufficientFunds)
5719 }
5720 InsufficientFunds
5721 },
5722 {
5723 fn OwnableUnauthorizedAccount(
5724 data: &[u8],
5725 ) -> alloy_sol_types::Result<ApplicationErrors> {
5726 <OwnableUnauthorizedAccount as alloy_sol_types::SolError>::abi_decode_raw_validate(
5727 data,
5728 )
5729 .map(ApplicationErrors::OwnableUnauthorizedAccount)
5730 }
5731 OwnableUnauthorizedAccount
5732 },
5733 {
5734 fn OwnableInvalidOwner(
5735 data: &[u8],
5736 ) -> alloy_sol_types::Result<ApplicationErrors> {
5737 <OwnableInvalidOwner as alloy_sol_types::SolError>::abi_decode_raw_validate(
5738 data,
5739 )
5740 .map(ApplicationErrors::OwnableInvalidOwner)
5741 }
5742 OwnableInvalidOwner
5743 },
5744 {
5745 fn ReentrancyGuardReentrantCall(
5746 data: &[u8],
5747 ) -> alloy_sol_types::Result<ApplicationErrors> {
5748 <ReentrancyGuardReentrantCall as alloy_sol_types::SolError>::abi_decode_raw_validate(
5749 data,
5750 )
5751 .map(ApplicationErrors::ReentrancyGuardReentrantCall)
5752 }
5753 ReentrancyGuardReentrantCall
5754 },
5755 {
5756 fn InvalidOutputsMerkleRoot(
5757 data: &[u8],
5758 ) -> alloy_sol_types::Result<ApplicationErrors> {
5759 <InvalidOutputsMerkleRoot as alloy_sol_types::SolError>::abi_decode_raw_validate(
5760 data,
5761 )
5762 .map(ApplicationErrors::InvalidOutputsMerkleRoot)
5763 }
5764 InvalidOutputsMerkleRoot
5765 },
5766 {
5767 fn OutputNotReexecutable(
5768 data: &[u8],
5769 ) -> alloy_sol_types::Result<ApplicationErrors> {
5770 <OutputNotReexecutable as alloy_sol_types::SolError>::abi_decode_raw_validate(
5771 data,
5772 )
5773 .map(ApplicationErrors::OutputNotReexecutable)
5774 }
5775 OutputNotReexecutable
5776 },
5777 {
5778 fn InvalidOutputHashesSiblingsArrayLength(
5779 data: &[u8],
5780 ) -> alloy_sol_types::Result<ApplicationErrors> {
5781 <InvalidOutputHashesSiblingsArrayLength as alloy_sol_types::SolError>::abi_decode_raw_validate(
5782 data,
5783 )
5784 .map(
5785 ApplicationErrors::InvalidOutputHashesSiblingsArrayLength,
5786 )
5787 }
5788 InvalidOutputHashesSiblingsArrayLength
5789 },
5790 {
5791 fn OutputNotExecutable(
5792 data: &[u8],
5793 ) -> alloy_sol_types::Result<ApplicationErrors> {
5794 <OutputNotExecutable as alloy_sol_types::SolError>::abi_decode_raw_validate(
5795 data,
5796 )
5797 .map(ApplicationErrors::OutputNotExecutable)
5798 }
5799 OutputNotExecutable
5800 },
5801 ];
5802 let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
5803 return Err(
5804 alloy_sol_types::Error::unknown_selector(
5805 <Self as alloy_sol_types::SolInterface>::NAME,
5806 selector,
5807 ),
5808 );
5809 };
5810 DECODE_VALIDATE_SHIMS[idx](data)
5811 }
5812 #[inline]
5813 fn abi_encoded_size(&self) -> usize {
5814 match self {
5815 Self::InsufficientFunds(inner) => {
5816 <InsufficientFunds as alloy_sol_types::SolError>::abi_encoded_size(
5817 inner,
5818 )
5819 }
5820 Self::InvalidOutputHashesSiblingsArrayLength(inner) => {
5821 <InvalidOutputHashesSiblingsArrayLength as alloy_sol_types::SolError>::abi_encoded_size(
5822 inner,
5823 )
5824 }
5825 Self::InvalidOutputsMerkleRoot(inner) => {
5826 <InvalidOutputsMerkleRoot as alloy_sol_types::SolError>::abi_encoded_size(
5827 inner,
5828 )
5829 }
5830 Self::OutputNotExecutable(inner) => {
5831 <OutputNotExecutable as alloy_sol_types::SolError>::abi_encoded_size(
5832 inner,
5833 )
5834 }
5835 Self::OutputNotReexecutable(inner) => {
5836 <OutputNotReexecutable as alloy_sol_types::SolError>::abi_encoded_size(
5837 inner,
5838 )
5839 }
5840 Self::OwnableInvalidOwner(inner) => {
5841 <OwnableInvalidOwner as alloy_sol_types::SolError>::abi_encoded_size(
5842 inner,
5843 )
5844 }
5845 Self::OwnableUnauthorizedAccount(inner) => {
5846 <OwnableUnauthorizedAccount as alloy_sol_types::SolError>::abi_encoded_size(
5847 inner,
5848 )
5849 }
5850 Self::ReentrancyGuardReentrantCall(inner) => {
5851 <ReentrancyGuardReentrantCall as alloy_sol_types::SolError>::abi_encoded_size(
5852 inner,
5853 )
5854 }
5855 }
5856 }
5857 #[inline]
5858 fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
5859 match self {
5860 Self::InsufficientFunds(inner) => {
5861 <InsufficientFunds as alloy_sol_types::SolError>::abi_encode_raw(
5862 inner,
5863 out,
5864 )
5865 }
5866 Self::InvalidOutputHashesSiblingsArrayLength(inner) => {
5867 <InvalidOutputHashesSiblingsArrayLength as alloy_sol_types::SolError>::abi_encode_raw(
5868 inner,
5869 out,
5870 )
5871 }
5872 Self::InvalidOutputsMerkleRoot(inner) => {
5873 <InvalidOutputsMerkleRoot as alloy_sol_types::SolError>::abi_encode_raw(
5874 inner,
5875 out,
5876 )
5877 }
5878 Self::OutputNotExecutable(inner) => {
5879 <OutputNotExecutable as alloy_sol_types::SolError>::abi_encode_raw(
5880 inner,
5881 out,
5882 )
5883 }
5884 Self::OutputNotReexecutable(inner) => {
5885 <OutputNotReexecutable as alloy_sol_types::SolError>::abi_encode_raw(
5886 inner,
5887 out,
5888 )
5889 }
5890 Self::OwnableInvalidOwner(inner) => {
5891 <OwnableInvalidOwner as alloy_sol_types::SolError>::abi_encode_raw(
5892 inner,
5893 out,
5894 )
5895 }
5896 Self::OwnableUnauthorizedAccount(inner) => {
5897 <OwnableUnauthorizedAccount as alloy_sol_types::SolError>::abi_encode_raw(
5898 inner,
5899 out,
5900 )
5901 }
5902 Self::ReentrancyGuardReentrantCall(inner) => {
5903 <ReentrancyGuardReentrantCall as alloy_sol_types::SolError>::abi_encode_raw(
5904 inner,
5905 out,
5906 )
5907 }
5908 }
5909 }
5910 }
5911 #[derive(Clone)]
5913 #[derive(serde::Serialize, serde::Deserialize)]
5914 #[derive(Debug, PartialEq, Eq, Hash)]
5915 pub enum ApplicationEvents {
5916 #[allow(missing_docs)]
5917 OutputExecuted(OutputExecuted),
5918 #[allow(missing_docs)]
5919 OutputsMerkleRootValidatorChanged(OutputsMerkleRootValidatorChanged),
5920 #[allow(missing_docs)]
5921 OwnershipTransferred(OwnershipTransferred),
5922 }
5923 impl ApplicationEvents {
5924 pub const SELECTORS: &'static [[u8; 32usize]] = &[
5931 [
5932 106u8, 211u8, 24u8, 139u8, 168u8, 244u8, 48u8, 251u8, 160u8, 101u8,
5933 108u8, 176u8, 167u8, 232u8, 57u8, 171u8, 32u8, 32u8, 213u8, 88u8, 107u8,
5934 161u8, 26u8, 20u8, 119u8, 209u8, 143u8, 112u8, 146u8, 248u8, 190u8, 206u8,
5935 ],
5936 [
5937 139u8, 224u8, 7u8, 156u8, 83u8, 22u8, 89u8, 20u8, 19u8, 68u8, 205u8,
5938 31u8, 208u8, 164u8, 242u8, 132u8, 25u8, 73u8, 127u8, 151u8, 34u8, 163u8,
5939 218u8, 175u8, 227u8, 180u8, 24u8, 111u8, 107u8, 100u8, 87u8, 224u8,
5940 ],
5941 [
5942 202u8, 209u8, 243u8, 97u8, 198u8, 232u8, 70u8, 100u8, 232u8, 146u8, 35u8,
5943 2u8, 145u8, 200u8, 232u8, 235u8, 149u8, 85u8, 104u8, 62u8, 10u8, 106u8,
5944 92u8, 232u8, 234u8, 123u8, 32u8, 74u8, 192u8, 172u8, 54u8, 118u8,
5945 ],
5946 ];
5947 pub const VARIANT_NAMES: &'static [&'static str] = &[
5949 ::core::stringify!(OutputsMerkleRootValidatorChanged),
5950 ::core::stringify!(OwnershipTransferred),
5951 ::core::stringify!(OutputExecuted),
5952 ];
5953 pub const SIGNATURES: &'static [&'static str] = &[
5955 <OutputsMerkleRootValidatorChanged as alloy_sol_types::SolEvent>::SIGNATURE,
5956 <OwnershipTransferred as alloy_sol_types::SolEvent>::SIGNATURE,
5957 <OutputExecuted as alloy_sol_types::SolEvent>::SIGNATURE,
5958 ];
5959 #[inline]
5961 pub fn signature_by_selector(
5962 selector: [u8; 32usize],
5963 ) -> ::core::option::Option<&'static str> {
5964 match Self::SELECTORS.binary_search(&selector) {
5965 ::core::result::Result::Ok(idx) => {
5966 ::core::option::Option::Some(Self::SIGNATURES[idx])
5967 }
5968 ::core::result::Result::Err(_) => ::core::option::Option::None,
5969 }
5970 }
5971 #[inline]
5973 pub fn name_by_selector(
5974 selector: [u8; 32usize],
5975 ) -> ::core::option::Option<&'static str> {
5976 let sig = Self::signature_by_selector(selector)?;
5977 sig.split_once('(').map(|(name, _)| name)
5978 }
5979 }
5980 #[automatically_derived]
5981 impl alloy_sol_types::SolEventInterface for ApplicationEvents {
5982 const NAME: &'static str = "ApplicationEvents";
5983 const COUNT: usize = 3usize;
5984 fn decode_raw_log(
5985 topics: &[alloy_sol_types::Word],
5986 data: &[u8],
5987 ) -> alloy_sol_types::Result<Self> {
5988 match topics.first().copied() {
5989 Some(<OutputExecuted as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
5990 <OutputExecuted as alloy_sol_types::SolEvent>::decode_raw_log(
5991 topics,
5992 data,
5993 )
5994 .map(Self::OutputExecuted)
5995 }
5996 Some(
5997 <OutputsMerkleRootValidatorChanged as alloy_sol_types::SolEvent>::SIGNATURE_HASH,
5998 ) => {
5999 <OutputsMerkleRootValidatorChanged as alloy_sol_types::SolEvent>::decode_raw_log(
6000 topics,
6001 data,
6002 )
6003 .map(Self::OutputsMerkleRootValidatorChanged)
6004 }
6005 Some(
6006 <OwnershipTransferred as alloy_sol_types::SolEvent>::SIGNATURE_HASH,
6007 ) => {
6008 <OwnershipTransferred as alloy_sol_types::SolEvent>::decode_raw_log(
6009 topics,
6010 data,
6011 )
6012 .map(Self::OwnershipTransferred)
6013 }
6014 _ => {
6015 alloy_sol_types::private::Err(alloy_sol_types::Error::InvalidLog {
6016 name: <Self as alloy_sol_types::SolEventInterface>::NAME,
6017 log: alloy_sol_types::private::Box::new(
6018 alloy_sol_types::private::LogData::new_unchecked(
6019 topics.to_vec(),
6020 data.to_vec().into(),
6021 ),
6022 ),
6023 })
6024 }
6025 }
6026 }
6027 }
6028 #[automatically_derived]
6029 impl alloy_sol_types::private::IntoLogData for ApplicationEvents {
6030 fn to_log_data(&self) -> alloy_sol_types::private::LogData {
6031 match self {
6032 Self::OutputExecuted(inner) => {
6033 alloy_sol_types::private::IntoLogData::to_log_data(inner)
6034 }
6035 Self::OutputsMerkleRootValidatorChanged(inner) => {
6036 alloy_sol_types::private::IntoLogData::to_log_data(inner)
6037 }
6038 Self::OwnershipTransferred(inner) => {
6039 alloy_sol_types::private::IntoLogData::to_log_data(inner)
6040 }
6041 }
6042 }
6043 fn into_log_data(self) -> alloy_sol_types::private::LogData {
6044 match self {
6045 Self::OutputExecuted(inner) => {
6046 alloy_sol_types::private::IntoLogData::into_log_data(inner)
6047 }
6048 Self::OutputsMerkleRootValidatorChanged(inner) => {
6049 alloy_sol_types::private::IntoLogData::into_log_data(inner)
6050 }
6051 Self::OwnershipTransferred(inner) => {
6052 alloy_sol_types::private::IntoLogData::into_log_data(inner)
6053 }
6054 }
6055 }
6056 }
6057 use alloy::contract as alloy_contract;
6058 #[inline]
6062 pub const fn new<
6063 P: alloy_contract::private::Provider<N>,
6064 N: alloy_contract::private::Network,
6065 >(
6066 address: alloy_sol_types::private::Address,
6067 __provider: P,
6068 ) -> ApplicationInstance<P, N> {
6069 ApplicationInstance::<P, N>::new(address, __provider)
6070 }
6071 #[inline]
6077 pub fn deploy<
6078 P: alloy_contract::private::Provider<N>,
6079 N: alloy_contract::private::Network,
6080 >(
6081 __provider: P,
6082 outputsMerkleRootValidator: alloy::sol_types::private::Address,
6083 initialOwner: alloy::sol_types::private::Address,
6084 templateHash: alloy::sol_types::private::FixedBytes<32>,
6085 dataAvailability: alloy::sol_types::private::Bytes,
6086 ) -> impl ::core::future::Future<
6087 Output = alloy_contract::Result<ApplicationInstance<P, N>>,
6088 > {
6089 ApplicationInstance::<
6090 P,
6091 N,
6092 >::deploy(
6093 __provider,
6094 outputsMerkleRootValidator,
6095 initialOwner,
6096 templateHash,
6097 dataAvailability,
6098 )
6099 }
6100 #[inline]
6106 pub fn deploy_builder<
6107 P: alloy_contract::private::Provider<N>,
6108 N: alloy_contract::private::Network,
6109 >(
6110 __provider: P,
6111 outputsMerkleRootValidator: alloy::sol_types::private::Address,
6112 initialOwner: alloy::sol_types::private::Address,
6113 templateHash: alloy::sol_types::private::FixedBytes<32>,
6114 dataAvailability: alloy::sol_types::private::Bytes,
6115 ) -> alloy_contract::RawCallBuilder<P, N> {
6116 ApplicationInstance::<
6117 P,
6118 N,
6119 >::deploy_builder(
6120 __provider,
6121 outputsMerkleRootValidator,
6122 initialOwner,
6123 templateHash,
6124 dataAvailability,
6125 )
6126 }
6127 #[derive(Clone)]
6139 pub struct ApplicationInstance<P, N = alloy_contract::private::Ethereum> {
6140 address: alloy_sol_types::private::Address,
6141 provider: P,
6142 _network: ::core::marker::PhantomData<N>,
6143 }
6144 #[automatically_derived]
6145 impl<P, N> ::core::fmt::Debug for ApplicationInstance<P, N> {
6146 #[inline]
6147 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
6148 f.debug_tuple("ApplicationInstance").field(&self.address).finish()
6149 }
6150 }
6151 impl<
6153 P: alloy_contract::private::Provider<N>,
6154 N: alloy_contract::private::Network,
6155 > ApplicationInstance<P, N> {
6156 #[inline]
6160 pub const fn new(
6161 address: alloy_sol_types::private::Address,
6162 __provider: P,
6163 ) -> Self {
6164 Self {
6165 address,
6166 provider: __provider,
6167 _network: ::core::marker::PhantomData,
6168 }
6169 }
6170 #[inline]
6176 pub async fn deploy(
6177 __provider: P,
6178 outputsMerkleRootValidator: alloy::sol_types::private::Address,
6179 initialOwner: alloy::sol_types::private::Address,
6180 templateHash: alloy::sol_types::private::FixedBytes<32>,
6181 dataAvailability: alloy::sol_types::private::Bytes,
6182 ) -> alloy_contract::Result<ApplicationInstance<P, N>> {
6183 let call_builder = Self::deploy_builder(
6184 __provider,
6185 outputsMerkleRootValidator,
6186 initialOwner,
6187 templateHash,
6188 dataAvailability,
6189 );
6190 let contract_address = call_builder.deploy().await?;
6191 Ok(Self::new(contract_address, call_builder.provider))
6192 }
6193 #[inline]
6199 pub fn deploy_builder(
6200 __provider: P,
6201 outputsMerkleRootValidator: alloy::sol_types::private::Address,
6202 initialOwner: alloy::sol_types::private::Address,
6203 templateHash: alloy::sol_types::private::FixedBytes<32>,
6204 dataAvailability: alloy::sol_types::private::Bytes,
6205 ) -> alloy_contract::RawCallBuilder<P, N> {
6206 alloy_contract::RawCallBuilder::new_raw_deploy(
6207 __provider,
6208 [
6209 &BYTECODE[..],
6210 &alloy_sol_types::SolConstructor::abi_encode(
6211 &constructorCall {
6212 outputsMerkleRootValidator,
6213 initialOwner,
6214 templateHash,
6215 dataAvailability,
6216 },
6217 )[..],
6218 ]
6219 .concat()
6220 .into(),
6221 )
6222 }
6223 #[inline]
6225 pub const fn address(&self) -> &alloy_sol_types::private::Address {
6226 &self.address
6227 }
6228 #[inline]
6230 pub fn set_address(&mut self, address: alloy_sol_types::private::Address) {
6231 self.address = address;
6232 }
6233 pub fn at(mut self, address: alloy_sol_types::private::Address) -> Self {
6235 self.set_address(address);
6236 self
6237 }
6238 #[inline]
6240 pub const fn provider(&self) -> &P {
6241 &self.provider
6242 }
6243 }
6244 impl<P: ::core::clone::Clone, N> ApplicationInstance<&P, N> {
6245 #[inline]
6247 pub fn with_cloned_provider(self) -> ApplicationInstance<P, N> {
6248 ApplicationInstance {
6249 address: self.address,
6250 provider: ::core::clone::Clone::clone(&self.provider),
6251 _network: ::core::marker::PhantomData,
6252 }
6253 }
6254 }
6255 impl<
6257 P: alloy_contract::private::Provider<N>,
6258 N: alloy_contract::private::Network,
6259 > ApplicationInstance<P, N> {
6260 pub fn call_builder<C: alloy_sol_types::SolCall>(
6265 &self,
6266 call: &C,
6267 ) -> alloy_contract::SolCallBuilder<&P, C, N> {
6268 alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call)
6269 }
6270 pub fn executeOutput(
6272 &self,
6273 output: alloy::sol_types::private::Bytes,
6274 proof: <OutputValidityProof as alloy::sol_types::SolType>::RustType,
6275 ) -> alloy_contract::SolCallBuilder<&P, executeOutputCall, N> {
6276 self.call_builder(&executeOutputCall { output, proof })
6277 }
6278 pub fn getDataAvailability(
6280 &self,
6281 ) -> alloy_contract::SolCallBuilder<&P, getDataAvailabilityCall, N> {
6282 self.call_builder(&getDataAvailabilityCall)
6283 }
6284 pub fn getDeploymentBlockNumber(
6286 &self,
6287 ) -> alloy_contract::SolCallBuilder<&P, getDeploymentBlockNumberCall, N> {
6288 self.call_builder(&getDeploymentBlockNumberCall)
6289 }
6290 pub fn getNumberOfExecutedOutputs(
6292 &self,
6293 ) -> alloy_contract::SolCallBuilder<&P, getNumberOfExecutedOutputsCall, N> {
6294 self.call_builder(&getNumberOfExecutedOutputsCall)
6295 }
6296 pub fn getOutputsMerkleRootValidator(
6298 &self,
6299 ) -> alloy_contract::SolCallBuilder<&P, getOutputsMerkleRootValidatorCall, N> {
6300 self.call_builder(&getOutputsMerkleRootValidatorCall)
6301 }
6302 pub fn getTemplateHash(
6304 &self,
6305 ) -> alloy_contract::SolCallBuilder<&P, getTemplateHashCall, N> {
6306 self.call_builder(&getTemplateHashCall)
6307 }
6308 pub fn migrateToOutputsMerkleRootValidator(
6310 &self,
6311 newOutputsMerkleRootValidator: alloy::sol_types::private::Address,
6312 ) -> alloy_contract::SolCallBuilder<
6313 &P,
6314 migrateToOutputsMerkleRootValidatorCall,
6315 N,
6316 > {
6317 self.call_builder(
6318 &migrateToOutputsMerkleRootValidatorCall {
6319 newOutputsMerkleRootValidator,
6320 },
6321 )
6322 }
6323 pub fn onERC1155BatchReceived(
6325 &self,
6326 _0: alloy::sol_types::private::Address,
6327 _1: alloy::sol_types::private::Address,
6328 _2: alloy::sol_types::private::Vec<
6329 alloy::sol_types::private::primitives::aliases::U256,
6330 >,
6331 _3: alloy::sol_types::private::Vec<
6332 alloy::sol_types::private::primitives::aliases::U256,
6333 >,
6334 _4: alloy::sol_types::private::Bytes,
6335 ) -> alloy_contract::SolCallBuilder<&P, onERC1155BatchReceivedCall, N> {
6336 self.call_builder(
6337 &onERC1155BatchReceivedCall {
6338 _0,
6339 _1,
6340 _2,
6341 _3,
6342 _4,
6343 },
6344 )
6345 }
6346 pub fn onERC1155Received(
6348 &self,
6349 _0: alloy::sol_types::private::Address,
6350 _1: alloy::sol_types::private::Address,
6351 _2: alloy::sol_types::private::primitives::aliases::U256,
6352 _3: alloy::sol_types::private::primitives::aliases::U256,
6353 _4: alloy::sol_types::private::Bytes,
6354 ) -> alloy_contract::SolCallBuilder<&P, onERC1155ReceivedCall, N> {
6355 self.call_builder(
6356 &onERC1155ReceivedCall {
6357 _0,
6358 _1,
6359 _2,
6360 _3,
6361 _4,
6362 },
6363 )
6364 }
6365 pub fn onERC721Received(
6367 &self,
6368 _0: alloy::sol_types::private::Address,
6369 _1: alloy::sol_types::private::Address,
6370 _2: alloy::sol_types::private::primitives::aliases::U256,
6371 _3: alloy::sol_types::private::Bytes,
6372 ) -> alloy_contract::SolCallBuilder<&P, onERC721ReceivedCall, N> {
6373 self.call_builder(
6374 &onERC721ReceivedCall {
6375 _0,
6376 _1,
6377 _2,
6378 _3,
6379 },
6380 )
6381 }
6382 pub fn owner(&self) -> alloy_contract::SolCallBuilder<&P, ownerCall, N> {
6384 self.call_builder(&ownerCall)
6385 }
6386 pub fn renounceOwnership(
6388 &self,
6389 ) -> alloy_contract::SolCallBuilder<&P, renounceOwnershipCall, N> {
6390 self.call_builder(&renounceOwnershipCall)
6391 }
6392 pub fn supportsInterface(
6394 &self,
6395 interfaceId: alloy::sol_types::private::FixedBytes<4>,
6396 ) -> alloy_contract::SolCallBuilder<&P, supportsInterfaceCall, N> {
6397 self.call_builder(
6398 &supportsInterfaceCall {
6399 interfaceId,
6400 },
6401 )
6402 }
6403 pub fn transferOwnership(
6405 &self,
6406 newOwner: alloy::sol_types::private::Address,
6407 ) -> alloy_contract::SolCallBuilder<&P, transferOwnershipCall, N> {
6408 self.call_builder(&transferOwnershipCall { newOwner })
6409 }
6410 pub fn validateOutput(
6412 &self,
6413 output: alloy::sol_types::private::Bytes,
6414 proof: <OutputValidityProof as alloy::sol_types::SolType>::RustType,
6415 ) -> alloy_contract::SolCallBuilder<&P, validateOutputCall, N> {
6416 self.call_builder(
6417 &validateOutputCall {
6418 output,
6419 proof,
6420 },
6421 )
6422 }
6423 pub fn validateOutputHash(
6425 &self,
6426 outputHash: alloy::sol_types::private::FixedBytes<32>,
6427 proof: <OutputValidityProof as alloy::sol_types::SolType>::RustType,
6428 ) -> alloy_contract::SolCallBuilder<&P, validateOutputHashCall, N> {
6429 self.call_builder(
6430 &validateOutputHashCall {
6431 outputHash,
6432 proof,
6433 },
6434 )
6435 }
6436 pub fn wasOutputExecuted(
6438 &self,
6439 outputIndex: alloy::sol_types::private::primitives::aliases::U256,
6440 ) -> alloy_contract::SolCallBuilder<&P, wasOutputExecutedCall, N> {
6441 self.call_builder(
6442 &wasOutputExecutedCall {
6443 outputIndex,
6444 },
6445 )
6446 }
6447 }
6448 impl<
6450 P: alloy_contract::private::Provider<N>,
6451 N: alloy_contract::private::Network,
6452 > ApplicationInstance<P, N> {
6453 pub fn event_filter<E: alloy_sol_types::SolEvent>(
6458 &self,
6459 ) -> alloy_contract::Event<&P, E, N> {
6460 alloy_contract::Event::new_sol(&self.provider, &self.address)
6461 }
6462 pub fn OutputExecuted_filter(
6464 &self,
6465 ) -> alloy_contract::Event<&P, OutputExecuted, N> {
6466 self.event_filter::<OutputExecuted>()
6467 }
6468 pub fn OutputsMerkleRootValidatorChanged_filter(
6470 &self,
6471 ) -> alloy_contract::Event<&P, OutputsMerkleRootValidatorChanged, N> {
6472 self.event_filter::<OutputsMerkleRootValidatorChanged>()
6473 }
6474 pub fn OwnershipTransferred_filter(
6476 &self,
6477 ) -> alloy_contract::Event<&P, OwnershipTransferred, N> {
6478 self.event_filter::<OwnershipTransferred>()
6479 }
6480 }
6481}