1#[allow(
318 non_camel_case_types,
319 non_snake_case,
320 clippy::pub_underscore_fields,
321 clippy::style,
322 clippy::empty_structs_with_brackets
323)]
324pub mod MockERC20 {
325 use super::*;
326 use alloy::sol_types as alloy_sol_types;
327 #[rustfmt::skip]
333 #[allow(clippy::all)]
334 pub static BYTECODE: alloy_sol_types::private::Bytes = alloy_sol_types::private::Bytes::from_static(
335 b"`\x80`@R4a\x03\x13W`@\x80Q\x90\x81\x01`\x01`\x01`@\x1B\x03\x81\x11\x82\x82\x10\x17a\x02&W`@\x90\x81R`\n\x82Ri&\xB7\xB1\xB5\x90*7\xB5\xB2\xB7`\xB1\x1B` \x83\x01R\x80Q\x90\x81\x01`\x01`\x01`@\x1B\x03\x81\x11\x82\x82\x10\x17a\x02&W`@R`\x03\x81RbMCK`\xE8\x1B` \x82\x01R\x81Q`\x01`\x01`@\x1B\x03\x81\x11a\x02&W`\x03T`\x01\x81\x81\x1C\x91\x16\x80\x15a\x03\tW[` \x82\x10\x14a\x02\x08W`\x1F\x81\x11a\x02\xA6W[P` \x92`\x1F\x82\x11`\x01\x14a\x02EW\x92\x81\x92\x93_\x92a\x02:W[PP\x81`\x01\x1B\x91_\x19\x90`\x03\x1B\x1C\x19\x16\x17`\x03U[\x80Q`\x01`\x01`@\x1B\x03\x81\x11a\x02&W`\x04T`\x01\x81\x81\x1C\x91\x16\x80\x15a\x02\x1CW[` \x82\x10\x14a\x02\x08W`\x1F\x81\x11a\x01\xA5W[P` \x91`\x1F\x82\x11`\x01\x14a\x01EW\x91\x81\x92_\x92a\x01:W[PP\x81`\x01\x1B\x91_\x19\x90`\x03\x1B\x1C\x19\x16\x17`\x04U[`@Qa\x08\xB4\x90\x81a\x03\x18\x829\xF3[\x01Q\x90P_\x80a\x01\x16V[`\x1F\x19\x82\x16\x92`\x04_R\x80_ \x91_[\x85\x81\x10a\x01\x8DWP\x83`\x01\x95\x10a\x01uW[PPP\x81\x1B\x01`\x04Ua\x01+V[\x01Q_\x19`\xF8\x84`\x03\x1B\x16\x1C\x19\x16\x90U_\x80\x80a\x01gV[\x91\x92` `\x01\x81\x92\x86\x85\x01Q\x81U\x01\x94\x01\x92\x01a\x01UV[`\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\x01\xFEW[`\x1F\x01`\x05\x1C\x01\x90[\x81\x81\x10a\x01\xF3WPa\0\xFDV[_\x81U`\x01\x01a\x01\xE6V[\x90\x91P\x81\x90a\x01\xDDV[cNH{q`\xE0\x1B_R`\"`\x04R`$_\xFD[\x90`\x7F\x16\x90a\0\xEBV[cNH{q`\xE0\x1B_R`A`\x04R`$_\xFD[\x01Q\x90P_\x80a\0\xB5V[`\x1F\x19\x82\x16\x93`\x03_R\x80_ \x91_[\x86\x81\x10a\x02\x8EWP\x83`\x01\x95\x96\x10a\x02vW[PPP\x81\x1B\x01`\x03Ua\0\xCAV[\x01Q_\x19`\xF8\x84`\x03\x1B\x16\x1C\x19\x16\x90U_\x80\x80a\x02hV[\x91\x92` `\x01\x81\x92\x86\x85\x01Q\x81U\x01\x94\x01\x92\x01a\x02UV[`\x03_R\x7F\xC2WZ\x0E\x9EY<\0\xF9Y\xF8\xC9/\x12\xDB(i\xC39Z;\x05\x02\xD0^%\x16Doq\xF8[`\x1F\x83\x01`\x05\x1C\x81\x01\x91` \x84\x10a\x02\xFFW[`\x1F\x01`\x05\x1C\x01\x90[\x81\x81\x10a\x02\xF4WPa\0\x9BV[_\x81U`\x01\x01a\x02\xE7V[\x90\x91P\x81\x90a\x02\xDEV[\x90`\x7F\x16\x90a\0\x89V[_\x80\xFD\xFE`\x80\x80`@R`\x046\x10\x15a\0\x12W_\x80\xFD[_5`\xE0\x1C\x90\x81c\x06\xFD\xDE\x03\x14a\x04\xB7WP\x80c\t^\xA7\xB3\x14a\x04\x91W\x80c\x18\x16\r\xDD\x14a\x04tW\x80c#\xB8r\xDD\x14a\x04GW\x80c1<\xE5g\x14a\x04,W\x80c9P\x93Q\x14a\x03\xDEW\x80c@\xC1\x0F\x19\x14a\x03\x1AW\x80cp\xA0\x821\x14a\x02\xE3W\x80c\x95\xD8\x9BA\x14a\x01\xC8W\x80c\xA4W\xC2\xD7\x14a\x01%W\x80c\xA9\x05\x9C\xBB\x14a\0\xF4Wc\xDDb\xED>\x14a\0\xA0W_\x80\xFD[4a\0\xF0W`@6`\x03\x19\x01\x12a\0\xF0Wa\0\xB9a\x05\xB0V[a\0\xC1a\x05\xC6V[`\x01`\x01`\xA0\x1B\x03\x91\x82\x16_\x90\x81R`\x01` \x90\x81R`@\x80\x83 \x94\x90\x93\x16\x82R\x92\x83R\x81\x90 T\x90Q\x90\x81R\xF3[_\x80\xFD[4a\0\xF0W`@6`\x03\x19\x01\x12a\0\xF0Wa\x01\x1Aa\x01\x10a\x05\xB0V[`$5\x903a\x07\x01V[` `@Q`\x01\x81R\xF3[4a\0\xF0W`@6`\x03\x19\x01\x12a\0\xF0Wa\x01>a\x05\xB0V[`$5\x903_R`\x01` R`@_ `\x01\x80`\xA0\x1B\x03\x82\x16_R` R`@_ T\x91\x80\x83\x10a\x01uWa\x01\x1A\x92\x03\x903a\x05\xFDV[`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`%`$\x82\x01R\x7FERC20: decreased allowance below`D\x82\x01Rd zero`\xD8\x1B`d\x82\x01R`\x84\x90\xFD[4a\0\xF0W_6`\x03\x19\x01\x12a\0\xF0W`@Q_`\x04T\x80`\x01\x1C\x90`\x01\x81\x16\x80\x15a\x02\xD9W[` \x83\x10\x81\x14a\x02\xC5W\x82\x85R\x90\x81\x15a\x02\xA9WP`\x01\x14a\x02TW[P\x81\x90\x03`\x1F\x01`\x1F\x19\x16\x81\x01\x90g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x11\x81\x83\x10\x17a\x02@Wa\x02<\x82\x91\x82`@R\x82a\x05\x86V[\x03\x90\xF3[cNH{q`\xE0\x1B_R`A`\x04R`$_\xFD[\x90P`\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_\x90[\x82\x82\x10a\x02\x93WP` \x91P\x82\x01\x01\x82a\x02\x0CV[`\x01\x81` \x92T\x83\x85\x88\x01\x01R\x01\x91\x01\x90a\x02~V[\x90P` \x92P`\xFF\x19\x16\x82\x84\x01R\x15\x15`\x05\x1B\x82\x01\x01\x82a\x02\x0CV[cNH{q`\xE0\x1B_R`\"`\x04R`$_\xFD[\x91`\x7F\x16\x91a\x01\xEFV[4a\0\xF0W` 6`\x03\x19\x01\x12a\0\xF0W`\x01`\x01`\xA0\x1B\x03a\x03\x04a\x05\xB0V[\x16_R_` R` `@_ T`@Q\x90\x81R\xF3[4a\0\xF0W`@6`\x03\x19\x01\x12a\0\xF0Wa\x033a\x05\xB0V[`\x01`\x01`\xA0\x1B\x03\x16`$5\x81\x15a\x03\x99W\x7F\xDD\xF2R\xAD\x1B\xE2\xC8\x9Bi\xC2\xB0h\xFC7\x8D\xAA\x95+\xA7\xF1c\xC4\xA1\x16(\xF5ZM\xF5#\xB3\xEF` \x82a\x03v_\x94`\x02Ta\x05\xDCV[`\x02U\x84\x84R\x83\x82R`@\x84 a\x03\x8E\x82\x82Ta\x05\xDCV[\x90U`@Q\x90\x81R\xA3\0[`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1F`$\x82\x01R\x7FERC20: mint to the zero address\0`D\x82\x01R`d\x90\xFD[4a\0\xF0W`@6`\x03\x19\x01\x12a\0\xF0Wa\x01\x1Aa\x03\xFAa\x05\xB0V[3_R`\x01` R`@_ `\x01\x80`\xA0\x1B\x03\x82\x16_R` Ra\x04%`@_ `$5\x90Ta\x05\xDCV[\x903a\x05\xFDV[4a\0\xF0W_6`\x03\x19\x01\x12a\0\xF0W` `@Q`\x12\x81R\xF3[4a\0\xF0W``6`\x03\x19\x01\x12a\0\xF0Wa\x01\x1Aa\x04ca\x05\xB0V[a\x04ka\x05\xC6V[`D5\x91a\x07\x01V[4a\0\xF0W_6`\x03\x19\x01\x12a\0\xF0W` `\x02T`@Q\x90\x81R\xF3[4a\0\xF0W`@6`\x03\x19\x01\x12a\0\xF0Wa\x01\x1Aa\x04\xADa\x05\xB0V[`$5\x903a\x05\xFDV[4a\0\xF0W_6`\x03\x19\x01\x12a\0\xF0W_`\x03T\x80`\x01\x1C\x90`\x01\x81\x16\x80\x15a\x05|W[` \x83\x10\x81\x14a\x02\xC5W\x82\x85R\x90\x81\x15a\x02\xA9WP`\x01\x14a\x05'WP\x81\x90\x03`\x1F\x01`\x1F\x19\x16\x81\x01\x90g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x11\x81\x83\x10\x17a\x02@Wa\x02<\x82\x91\x82`@R\x82a\x05\x86V[\x90P`\x03_R\x7F\xC2WZ\x0E\x9EY<\0\xF9Y\xF8\xC9/\x12\xDB(i\xC39Z;\x05\x02\xD0^%\x16Doq\xF8[_\x90[\x82\x82\x10a\x05fWP` \x91P\x82\x01\x01\x82a\x02\x0CV[`\x01\x81` \x92T\x83\x85\x88\x01\x01R\x01\x91\x01\x90a\x05QV[\x91`\x7F\x16\x91a\x04\xDBV[` `@\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[`\x045\x90`\x01`\x01`\xA0\x1B\x03\x82\x16\x82\x03a\0\xF0WV[`$5\x90`\x01`\x01`\xA0\x1B\x03\x82\x16\x82\x03a\0\xF0WV[\x91\x90\x82\x01\x80\x92\x11a\x05\xE9WV[cNH{q`\xE0\x1B_R`\x11`\x04R`$_\xFD[`\x01`\x01`\xA0\x1B\x03\x16\x90\x81\x15a\x06\xB0W`\x01`\x01`\xA0\x1B\x03\x16\x91\x82\x15a\x06`W` \x7F\x8C[\xE1\xE5\xEB\xEC}[\xD1OqB}\x1E\x84\xF3\xDD\x03\x14\xC0\xF7\xB2)\x1E[ \n\xC8\xC7\xC3\xB9%\x91\x83_R`\x01\x82R`@_ \x85_R\x82R\x80`@_ U`@Q\x90\x81R\xA3V[`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\"`$\x82\x01R\x7FERC20: approve to the zero addre`D\x82\x01Rass`\xF0\x1B`d\x82\x01R`\x84\x90\xFD[`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`$\x80\x82\x01R\x7FERC20: approve from the zero add`D\x82\x01Rcress`\xE0\x1B`d\x82\x01R`\x84\x90\xFD[`\x01`\x01`\xA0\x1B\x03\x16\x90\x81\x15a\x08+W`\x01`\x01`\xA0\x1B\x03\x16\x91\x82\x15a\x07\xDAW\x81_R_` R`@_ T\x81\x81\x10a\x07\x86W\x81\x7F\xDD\xF2R\xAD\x1B\xE2\xC8\x9Bi\xC2\xB0h\xFC7\x8D\xAA\x95+\xA7\xF1c\xC4\xA1\x16(\xF5ZM\xF5#\xB3\xEF\x92` \x92\x85_R_\x84R\x03`@_ U\x84_R_\x82R`@_ a\x07{\x82\x82Ta\x05\xDCV[\x90U`@Q\x90\x81R\xA3V[`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`&`$\x82\x01R\x7FERC20: transfer amount exceeds b`D\x82\x01Realance`\xD0\x1B`d\x82\x01R`\x84\x90\xFD[`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`#`$\x82\x01R\x7FERC20: transfer to the zero addr`D\x82\x01Rbess`\xE8\x1B`d\x82\x01R`\x84\x90\xFD[`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`%`$\x82\x01R\x7FERC20: transfer from the zero ad`D\x82\x01Rddress`\xD8\x1B`d\x82\x01R`\x84\x90\xFD\xFE\xA2dipfsX\"\x12 (\xC9\xE0\xEE\x126\xC5\xC5\x8B\xFD\xD2Jm\x9BB\xE45'^m\"*\x117 \x08\x81\xC2_\xD0\x9A\x8EdsolcC\0\x08\x1B\x003",
336 );
337 #[rustfmt::skip]
343 #[allow(clippy::all)]
344 pub static DEPLOYED_BYTECODE: alloy_sol_types::private::Bytes = alloy_sol_types::private::Bytes::from_static(
345 b"`\x80\x80`@R`\x046\x10\x15a\0\x12W_\x80\xFD[_5`\xE0\x1C\x90\x81c\x06\xFD\xDE\x03\x14a\x04\xB7WP\x80c\t^\xA7\xB3\x14a\x04\x91W\x80c\x18\x16\r\xDD\x14a\x04tW\x80c#\xB8r\xDD\x14a\x04GW\x80c1<\xE5g\x14a\x04,W\x80c9P\x93Q\x14a\x03\xDEW\x80c@\xC1\x0F\x19\x14a\x03\x1AW\x80cp\xA0\x821\x14a\x02\xE3W\x80c\x95\xD8\x9BA\x14a\x01\xC8W\x80c\xA4W\xC2\xD7\x14a\x01%W\x80c\xA9\x05\x9C\xBB\x14a\0\xF4Wc\xDDb\xED>\x14a\0\xA0W_\x80\xFD[4a\0\xF0W`@6`\x03\x19\x01\x12a\0\xF0Wa\0\xB9a\x05\xB0V[a\0\xC1a\x05\xC6V[`\x01`\x01`\xA0\x1B\x03\x91\x82\x16_\x90\x81R`\x01` \x90\x81R`@\x80\x83 \x94\x90\x93\x16\x82R\x92\x83R\x81\x90 T\x90Q\x90\x81R\xF3[_\x80\xFD[4a\0\xF0W`@6`\x03\x19\x01\x12a\0\xF0Wa\x01\x1Aa\x01\x10a\x05\xB0V[`$5\x903a\x07\x01V[` `@Q`\x01\x81R\xF3[4a\0\xF0W`@6`\x03\x19\x01\x12a\0\xF0Wa\x01>a\x05\xB0V[`$5\x903_R`\x01` R`@_ `\x01\x80`\xA0\x1B\x03\x82\x16_R` R`@_ T\x91\x80\x83\x10a\x01uWa\x01\x1A\x92\x03\x903a\x05\xFDV[`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`%`$\x82\x01R\x7FERC20: decreased allowance below`D\x82\x01Rd zero`\xD8\x1B`d\x82\x01R`\x84\x90\xFD[4a\0\xF0W_6`\x03\x19\x01\x12a\0\xF0W`@Q_`\x04T\x80`\x01\x1C\x90`\x01\x81\x16\x80\x15a\x02\xD9W[` \x83\x10\x81\x14a\x02\xC5W\x82\x85R\x90\x81\x15a\x02\xA9WP`\x01\x14a\x02TW[P\x81\x90\x03`\x1F\x01`\x1F\x19\x16\x81\x01\x90g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x11\x81\x83\x10\x17a\x02@Wa\x02<\x82\x91\x82`@R\x82a\x05\x86V[\x03\x90\xF3[cNH{q`\xE0\x1B_R`A`\x04R`$_\xFD[\x90P`\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_\x90[\x82\x82\x10a\x02\x93WP` \x91P\x82\x01\x01\x82a\x02\x0CV[`\x01\x81` \x92T\x83\x85\x88\x01\x01R\x01\x91\x01\x90a\x02~V[\x90P` \x92P`\xFF\x19\x16\x82\x84\x01R\x15\x15`\x05\x1B\x82\x01\x01\x82a\x02\x0CV[cNH{q`\xE0\x1B_R`\"`\x04R`$_\xFD[\x91`\x7F\x16\x91a\x01\xEFV[4a\0\xF0W` 6`\x03\x19\x01\x12a\0\xF0W`\x01`\x01`\xA0\x1B\x03a\x03\x04a\x05\xB0V[\x16_R_` R` `@_ T`@Q\x90\x81R\xF3[4a\0\xF0W`@6`\x03\x19\x01\x12a\0\xF0Wa\x033a\x05\xB0V[`\x01`\x01`\xA0\x1B\x03\x16`$5\x81\x15a\x03\x99W\x7F\xDD\xF2R\xAD\x1B\xE2\xC8\x9Bi\xC2\xB0h\xFC7\x8D\xAA\x95+\xA7\xF1c\xC4\xA1\x16(\xF5ZM\xF5#\xB3\xEF` \x82a\x03v_\x94`\x02Ta\x05\xDCV[`\x02U\x84\x84R\x83\x82R`@\x84 a\x03\x8E\x82\x82Ta\x05\xDCV[\x90U`@Q\x90\x81R\xA3\0[`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1F`$\x82\x01R\x7FERC20: mint to the zero address\0`D\x82\x01R`d\x90\xFD[4a\0\xF0W`@6`\x03\x19\x01\x12a\0\xF0Wa\x01\x1Aa\x03\xFAa\x05\xB0V[3_R`\x01` R`@_ `\x01\x80`\xA0\x1B\x03\x82\x16_R` Ra\x04%`@_ `$5\x90Ta\x05\xDCV[\x903a\x05\xFDV[4a\0\xF0W_6`\x03\x19\x01\x12a\0\xF0W` `@Q`\x12\x81R\xF3[4a\0\xF0W``6`\x03\x19\x01\x12a\0\xF0Wa\x01\x1Aa\x04ca\x05\xB0V[a\x04ka\x05\xC6V[`D5\x91a\x07\x01V[4a\0\xF0W_6`\x03\x19\x01\x12a\0\xF0W` `\x02T`@Q\x90\x81R\xF3[4a\0\xF0W`@6`\x03\x19\x01\x12a\0\xF0Wa\x01\x1Aa\x04\xADa\x05\xB0V[`$5\x903a\x05\xFDV[4a\0\xF0W_6`\x03\x19\x01\x12a\0\xF0W_`\x03T\x80`\x01\x1C\x90`\x01\x81\x16\x80\x15a\x05|W[` \x83\x10\x81\x14a\x02\xC5W\x82\x85R\x90\x81\x15a\x02\xA9WP`\x01\x14a\x05'WP\x81\x90\x03`\x1F\x01`\x1F\x19\x16\x81\x01\x90g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x11\x81\x83\x10\x17a\x02@Wa\x02<\x82\x91\x82`@R\x82a\x05\x86V[\x90P`\x03_R\x7F\xC2WZ\x0E\x9EY<\0\xF9Y\xF8\xC9/\x12\xDB(i\xC39Z;\x05\x02\xD0^%\x16Doq\xF8[_\x90[\x82\x82\x10a\x05fWP` \x91P\x82\x01\x01\x82a\x02\x0CV[`\x01\x81` \x92T\x83\x85\x88\x01\x01R\x01\x91\x01\x90a\x05QV[\x91`\x7F\x16\x91a\x04\xDBV[` `@\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[`\x045\x90`\x01`\x01`\xA0\x1B\x03\x82\x16\x82\x03a\0\xF0WV[`$5\x90`\x01`\x01`\xA0\x1B\x03\x82\x16\x82\x03a\0\xF0WV[\x91\x90\x82\x01\x80\x92\x11a\x05\xE9WV[cNH{q`\xE0\x1B_R`\x11`\x04R`$_\xFD[`\x01`\x01`\xA0\x1B\x03\x16\x90\x81\x15a\x06\xB0W`\x01`\x01`\xA0\x1B\x03\x16\x91\x82\x15a\x06`W` \x7F\x8C[\xE1\xE5\xEB\xEC}[\xD1OqB}\x1E\x84\xF3\xDD\x03\x14\xC0\xF7\xB2)\x1E[ \n\xC8\xC7\xC3\xB9%\x91\x83_R`\x01\x82R`@_ \x85_R\x82R\x80`@_ U`@Q\x90\x81R\xA3V[`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\"`$\x82\x01R\x7FERC20: approve to the zero addre`D\x82\x01Rass`\xF0\x1B`d\x82\x01R`\x84\x90\xFD[`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`$\x80\x82\x01R\x7FERC20: approve from the zero add`D\x82\x01Rcress`\xE0\x1B`d\x82\x01R`\x84\x90\xFD[`\x01`\x01`\xA0\x1B\x03\x16\x90\x81\x15a\x08+W`\x01`\x01`\xA0\x1B\x03\x16\x91\x82\x15a\x07\xDAW\x81_R_` R`@_ T\x81\x81\x10a\x07\x86W\x81\x7F\xDD\xF2R\xAD\x1B\xE2\xC8\x9Bi\xC2\xB0h\xFC7\x8D\xAA\x95+\xA7\xF1c\xC4\xA1\x16(\xF5ZM\xF5#\xB3\xEF\x92` \x92\x85_R_\x84R\x03`@_ U\x84_R_\x82R`@_ a\x07{\x82\x82Ta\x05\xDCV[\x90U`@Q\x90\x81R\xA3V[`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`&`$\x82\x01R\x7FERC20: transfer amount exceeds b`D\x82\x01Realance`\xD0\x1B`d\x82\x01R`\x84\x90\xFD[`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`#`$\x82\x01R\x7FERC20: transfer to the zero addr`D\x82\x01Rbess`\xE8\x1B`d\x82\x01R`\x84\x90\xFD[`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`%`$\x82\x01R\x7FERC20: transfer from the zero ad`D\x82\x01Rddress`\xD8\x1B`d\x82\x01R`\x84\x90\xFD\xFE\xA2dipfsX\"\x12 (\xC9\xE0\xEE\x126\xC5\xC5\x8B\xFD\xD2Jm\x9BB\xE45'^m\"*\x117 \x08\x81\xC2_\xD0\x9A\x8EdsolcC\0\x08\x1B\x003",
346 );
347 #[derive(serde::Serialize, serde::Deserialize, Default, Debug, PartialEq, Eq, Hash)]
348 #[allow(
353 non_camel_case_types,
354 non_snake_case,
355 clippy::pub_underscore_fields,
356 clippy::style
357 )]
358 #[derive(Clone)]
359 pub struct Approval {
360 #[allow(missing_docs)]
361 pub owner: alloy::sol_types::private::Address,
362 #[allow(missing_docs)]
363 pub spender: alloy::sol_types::private::Address,
364 #[allow(missing_docs)]
365 pub value: alloy::sol_types::private::primitives::aliases::U256,
366 }
367 #[allow(
368 non_camel_case_types,
369 non_snake_case,
370 clippy::pub_underscore_fields,
371 clippy::style
372 )]
373 const _: () = {
374 use alloy::sol_types as alloy_sol_types;
375 #[automatically_derived]
376 impl alloy_sol_types::SolEvent for Approval {
377 type DataTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
378 type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
379 type TopicList = (
380 alloy_sol_types::sol_data::FixedBytes<32>,
381 alloy::sol_types::sol_data::Address,
382 alloy::sol_types::sol_data::Address,
383 );
384 const SIGNATURE: &'static str = "Approval(address,address,uint256)";
385 const SIGNATURE_HASH: alloy_sol_types::private::B256 =
386 alloy_sol_types::private::B256::new([
387 140u8, 91u8, 225u8, 229u8, 235u8, 236u8, 125u8, 91u8, 209u8, 79u8, 113u8, 66u8,
388 125u8, 30u8, 132u8, 243u8, 221u8, 3u8, 20u8, 192u8, 247u8, 178u8, 41u8, 30u8,
389 91u8, 32u8, 10u8, 200u8, 199u8, 195u8, 185u8, 37u8,
390 ]);
391 const ANONYMOUS: bool = false;
392 #[allow(unused_variables)]
393 #[inline]
394 fn new(
395 topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
396 data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
397 ) -> Self {
398 Self {
399 owner: topics.1,
400 spender: topics.2,
401 value: data.0,
402 }
403 }
404 #[inline]
405 fn check_signature(
406 topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
407 ) -> alloy_sol_types::Result<()> {
408 if topics.0 != Self::SIGNATURE_HASH {
409 return Err(alloy_sol_types::Error::invalid_event_signature_hash(
410 Self::SIGNATURE,
411 topics.0,
412 Self::SIGNATURE_HASH,
413 ));
414 }
415 Ok(())
416 }
417 #[inline]
418 fn tokenize_body(&self) -> Self::DataToken<'_> {
419 (
420 <alloy::sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
421 &self.value,
422 ),
423 )
424 }
425 #[inline]
426 fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
427 (
428 Self::SIGNATURE_HASH.into(),
429 self.owner.clone(),
430 self.spender.clone(),
431 )
432 }
433 #[inline]
434 fn encode_topics_raw(
435 &self,
436 out: &mut [alloy_sol_types::abi::token::WordToken],
437 ) -> alloy_sol_types::Result<()> {
438 if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
439 return Err(alloy_sol_types::Error::Overrun);
440 }
441 out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
442 out[1usize] = <alloy::sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
443 &self.owner,
444 );
445 out[2usize] = <alloy::sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
446 &self.spender,
447 );
448 Ok(())
449 }
450 }
451 #[automatically_derived]
452 impl alloy_sol_types::private::IntoLogData for Approval {
453 fn to_log_data(&self) -> alloy_sol_types::private::LogData {
454 From::from(self)
455 }
456 fn into_log_data(self) -> alloy_sol_types::private::LogData {
457 From::from(&self)
458 }
459 }
460 #[automatically_derived]
461 impl From<&Approval> for alloy_sol_types::private::LogData {
462 #[inline]
463 fn from(this: &Approval) -> alloy_sol_types::private::LogData {
464 alloy_sol_types::SolEvent::encode_log_data(this)
465 }
466 }
467 };
468 #[derive(serde::Serialize, serde::Deserialize, Default, Debug, PartialEq, Eq, Hash)]
469 #[allow(
474 non_camel_case_types,
475 non_snake_case,
476 clippy::pub_underscore_fields,
477 clippy::style
478 )]
479 #[derive(Clone)]
480 pub struct Transfer {
481 #[allow(missing_docs)]
482 pub from: alloy::sol_types::private::Address,
483 #[allow(missing_docs)]
484 pub to: alloy::sol_types::private::Address,
485 #[allow(missing_docs)]
486 pub value: alloy::sol_types::private::primitives::aliases::U256,
487 }
488 #[allow(
489 non_camel_case_types,
490 non_snake_case,
491 clippy::pub_underscore_fields,
492 clippy::style
493 )]
494 const _: () = {
495 use alloy::sol_types as alloy_sol_types;
496 #[automatically_derived]
497 impl alloy_sol_types::SolEvent for Transfer {
498 type DataTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
499 type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
500 type TopicList = (
501 alloy_sol_types::sol_data::FixedBytes<32>,
502 alloy::sol_types::sol_data::Address,
503 alloy::sol_types::sol_data::Address,
504 );
505 const SIGNATURE: &'static str = "Transfer(address,address,uint256)";
506 const SIGNATURE_HASH: alloy_sol_types::private::B256 =
507 alloy_sol_types::private::B256::new([
508 221u8, 242u8, 82u8, 173u8, 27u8, 226u8, 200u8, 155u8, 105u8, 194u8, 176u8,
509 104u8, 252u8, 55u8, 141u8, 170u8, 149u8, 43u8, 167u8, 241u8, 99u8, 196u8,
510 161u8, 22u8, 40u8, 245u8, 90u8, 77u8, 245u8, 35u8, 179u8, 239u8,
511 ]);
512 const ANONYMOUS: bool = false;
513 #[allow(unused_variables)]
514 #[inline]
515 fn new(
516 topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
517 data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
518 ) -> Self {
519 Self {
520 from: topics.1,
521 to: topics.2,
522 value: data.0,
523 }
524 }
525 #[inline]
526 fn check_signature(
527 topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
528 ) -> alloy_sol_types::Result<()> {
529 if topics.0 != Self::SIGNATURE_HASH {
530 return Err(alloy_sol_types::Error::invalid_event_signature_hash(
531 Self::SIGNATURE,
532 topics.0,
533 Self::SIGNATURE_HASH,
534 ));
535 }
536 Ok(())
537 }
538 #[inline]
539 fn tokenize_body(&self) -> Self::DataToken<'_> {
540 (
541 <alloy::sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
542 &self.value,
543 ),
544 )
545 }
546 #[inline]
547 fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
548 (
549 Self::SIGNATURE_HASH.into(),
550 self.from.clone(),
551 self.to.clone(),
552 )
553 }
554 #[inline]
555 fn encode_topics_raw(
556 &self,
557 out: &mut [alloy_sol_types::abi::token::WordToken],
558 ) -> alloy_sol_types::Result<()> {
559 if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
560 return Err(alloy_sol_types::Error::Overrun);
561 }
562 out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
563 out[1usize] = <alloy::sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
564 &self.from,
565 );
566 out[2usize] = <alloy::sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
567 &self.to,
568 );
569 Ok(())
570 }
571 }
572 #[automatically_derived]
573 impl alloy_sol_types::private::IntoLogData for Transfer {
574 fn to_log_data(&self) -> alloy_sol_types::private::LogData {
575 From::from(self)
576 }
577 fn into_log_data(self) -> alloy_sol_types::private::LogData {
578 From::from(&self)
579 }
580 }
581 #[automatically_derived]
582 impl From<&Transfer> for alloy_sol_types::private::LogData {
583 #[inline]
584 fn from(this: &Transfer) -> alloy_sol_types::private::LogData {
585 alloy_sol_types::SolEvent::encode_log_data(this)
586 }
587 }
588 };
589 #[derive(serde::Serialize, serde::Deserialize, Default, Debug, PartialEq, Eq, Hash)]
590 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
595 #[derive(Clone)]
596 pub struct allowanceCall {
597 #[allow(missing_docs)]
598 pub owner: alloy::sol_types::private::Address,
599 #[allow(missing_docs)]
600 pub spender: alloy::sol_types::private::Address,
601 }
602 #[derive(serde::Serialize, serde::Deserialize, Default, Debug, PartialEq, Eq, Hash)]
603 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
605 #[derive(Clone)]
606 pub struct allowanceReturn {
607 #[allow(missing_docs)]
608 pub _0: alloy::sol_types::private::primitives::aliases::U256,
609 }
610 #[allow(
611 non_camel_case_types,
612 non_snake_case,
613 clippy::pub_underscore_fields,
614 clippy::style
615 )]
616 const _: () = {
617 use alloy::sol_types as alloy_sol_types;
618 {
619 #[doc(hidden)]
620 type UnderlyingSolTuple<'a> = (
621 alloy::sol_types::sol_data::Address,
622 alloy::sol_types::sol_data::Address,
623 );
624 #[doc(hidden)]
625 type UnderlyingRustTuple<'a> = (
626 alloy::sol_types::private::Address,
627 alloy::sol_types::private::Address,
628 );
629 #[cfg(test)]
630 #[allow(dead_code, unreachable_patterns)]
631 fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
632 match _t {
633 alloy_sol_types::private::AssertTypeEq::<
634 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
635 >(_) => {}
636 }
637 }
638 #[automatically_derived]
639 #[doc(hidden)]
640 impl ::core::convert::From<allowanceCall> for UnderlyingRustTuple<'_> {
641 fn from(value: allowanceCall) -> Self {
642 (value.owner, value.spender)
643 }
644 }
645 #[automatically_derived]
646 #[doc(hidden)]
647 impl ::core::convert::From<UnderlyingRustTuple<'_>> for allowanceCall {
648 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
649 Self {
650 owner: tuple.0,
651 spender: tuple.1,
652 }
653 }
654 }
655 }
656 {
657 #[doc(hidden)]
658 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
659 #[doc(hidden)]
660 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::primitives::aliases::U256,);
661 #[cfg(test)]
662 #[allow(dead_code, unreachable_patterns)]
663 fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
664 match _t {
665 alloy_sol_types::private::AssertTypeEq::<
666 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
667 >(_) => {}
668 }
669 }
670 #[automatically_derived]
671 #[doc(hidden)]
672 impl ::core::convert::From<allowanceReturn> for UnderlyingRustTuple<'_> {
673 fn from(value: allowanceReturn) -> Self {
674 (value._0,)
675 }
676 }
677 #[automatically_derived]
678 #[doc(hidden)]
679 impl ::core::convert::From<UnderlyingRustTuple<'_>> for allowanceReturn {
680 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
681 Self { _0: tuple.0 }
682 }
683 }
684 }
685 #[automatically_derived]
686 impl alloy_sol_types::SolCall for allowanceCall {
687 type Parameters<'a> = (
688 alloy::sol_types::sol_data::Address,
689 alloy::sol_types::sol_data::Address,
690 );
691 type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
692 type Return = alloy::sol_types::private::primitives::aliases::U256;
693 type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
694 type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
695 const SIGNATURE: &'static str = "allowance(address,address)";
696 const SELECTOR: [u8; 4] = [221u8, 98u8, 237u8, 62u8];
697 #[inline]
698 fn new<'a>(
699 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
700 ) -> Self {
701 tuple.into()
702 }
703 #[inline]
704 fn tokenize(&self) -> Self::Token<'_> {
705 (
706 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
707 &self.owner,
708 ),
709 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
710 &self.spender,
711 ),
712 )
713 }
714 #[inline]
715 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
716 (
717 <alloy::sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
718 ret,
719 ),
720 )
721 }
722 #[inline]
723 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
724 <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
725 |r| {
726 let r: allowanceReturn = r.into();
727 r._0
728 },
729 )
730 }
731 #[inline]
732 fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
733 <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
734 data,
735 )
736 .map(|r| {
737 let r: allowanceReturn = r.into();
738 r._0
739 })
740 }
741 }
742 };
743 #[derive(serde::Serialize, serde::Deserialize, Default, Debug, PartialEq, Eq, Hash)]
744 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
749 #[derive(Clone)]
750 pub struct approveCall {
751 #[allow(missing_docs)]
752 pub spender: alloy::sol_types::private::Address,
753 #[allow(missing_docs)]
754 pub amount: alloy::sol_types::private::primitives::aliases::U256,
755 }
756 #[derive(serde::Serialize, serde::Deserialize, Default, Debug, PartialEq, Eq, Hash)]
757 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
759 #[derive(Clone)]
760 pub struct approveReturn {
761 #[allow(missing_docs)]
762 pub _0: bool,
763 }
764 #[allow(
765 non_camel_case_types,
766 non_snake_case,
767 clippy::pub_underscore_fields,
768 clippy::style
769 )]
770 const _: () = {
771 use alloy::sol_types as alloy_sol_types;
772 {
773 #[doc(hidden)]
774 type UnderlyingSolTuple<'a> = (
775 alloy::sol_types::sol_data::Address,
776 alloy::sol_types::sol_data::Uint<256>,
777 );
778 #[doc(hidden)]
779 type UnderlyingRustTuple<'a> = (
780 alloy::sol_types::private::Address,
781 alloy::sol_types::private::primitives::aliases::U256,
782 );
783 #[cfg(test)]
784 #[allow(dead_code, unreachable_patterns)]
785 fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
786 match _t {
787 alloy_sol_types::private::AssertTypeEq::<
788 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
789 >(_) => {}
790 }
791 }
792 #[automatically_derived]
793 #[doc(hidden)]
794 impl ::core::convert::From<approveCall> for UnderlyingRustTuple<'_> {
795 fn from(value: approveCall) -> Self {
796 (value.spender, value.amount)
797 }
798 }
799 #[automatically_derived]
800 #[doc(hidden)]
801 impl ::core::convert::From<UnderlyingRustTuple<'_>> for approveCall {
802 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
803 Self {
804 spender: tuple.0,
805 amount: tuple.1,
806 }
807 }
808 }
809 }
810 {
811 #[doc(hidden)]
812 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Bool,);
813 #[doc(hidden)]
814 type UnderlyingRustTuple<'a> = (bool,);
815 #[cfg(test)]
816 #[allow(dead_code, unreachable_patterns)]
817 fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
818 match _t {
819 alloy_sol_types::private::AssertTypeEq::<
820 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
821 >(_) => {}
822 }
823 }
824 #[automatically_derived]
825 #[doc(hidden)]
826 impl ::core::convert::From<approveReturn> for UnderlyingRustTuple<'_> {
827 fn from(value: approveReturn) -> Self {
828 (value._0,)
829 }
830 }
831 #[automatically_derived]
832 #[doc(hidden)]
833 impl ::core::convert::From<UnderlyingRustTuple<'_>> for approveReturn {
834 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
835 Self { _0: tuple.0 }
836 }
837 }
838 }
839 #[automatically_derived]
840 impl alloy_sol_types::SolCall for approveCall {
841 type Parameters<'a> = (
842 alloy::sol_types::sol_data::Address,
843 alloy::sol_types::sol_data::Uint<256>,
844 );
845 type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
846 type Return = bool;
847 type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,);
848 type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
849 const SIGNATURE: &'static str = "approve(address,uint256)";
850 const SELECTOR: [u8; 4] = [9u8, 94u8, 167u8, 179u8];
851 #[inline]
852 fn new<'a>(
853 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
854 ) -> Self {
855 tuple.into()
856 }
857 #[inline]
858 fn tokenize(&self) -> Self::Token<'_> {
859 (
860 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
861 &self.spender,
862 ),
863 <alloy::sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
864 &self.amount,
865 ),
866 )
867 }
868 #[inline]
869 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
870 (<alloy::sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(ret),)
871 }
872 #[inline]
873 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
874 <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
875 |r| {
876 let r: approveReturn = r.into();
877 r._0
878 },
879 )
880 }
881 #[inline]
882 fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
883 <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
884 data,
885 )
886 .map(|r| {
887 let r: approveReturn = r.into();
888 r._0
889 })
890 }
891 }
892 };
893 #[derive(serde::Serialize, serde::Deserialize, Default, Debug, PartialEq, Eq, Hash)]
894 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
899 #[derive(Clone)]
900 pub struct balanceOfCall {
901 #[allow(missing_docs)]
902 pub account: alloy::sol_types::private::Address,
903 }
904 #[derive(serde::Serialize, serde::Deserialize, Default, Debug, PartialEq, Eq, Hash)]
905 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
907 #[derive(Clone)]
908 pub struct balanceOfReturn {
909 #[allow(missing_docs)]
910 pub _0: alloy::sol_types::private::primitives::aliases::U256,
911 }
912 #[allow(
913 non_camel_case_types,
914 non_snake_case,
915 clippy::pub_underscore_fields,
916 clippy::style
917 )]
918 const _: () = {
919 use alloy::sol_types as alloy_sol_types;
920 {
921 #[doc(hidden)]
922 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
923 #[doc(hidden)]
924 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
925 #[cfg(test)]
926 #[allow(dead_code, unreachable_patterns)]
927 fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
928 match _t {
929 alloy_sol_types::private::AssertTypeEq::<
930 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
931 >(_) => {}
932 }
933 }
934 #[automatically_derived]
935 #[doc(hidden)]
936 impl ::core::convert::From<balanceOfCall> for UnderlyingRustTuple<'_> {
937 fn from(value: balanceOfCall) -> Self {
938 (value.account,)
939 }
940 }
941 #[automatically_derived]
942 #[doc(hidden)]
943 impl ::core::convert::From<UnderlyingRustTuple<'_>> for balanceOfCall {
944 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
945 Self { account: tuple.0 }
946 }
947 }
948 }
949 {
950 #[doc(hidden)]
951 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
952 #[doc(hidden)]
953 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::primitives::aliases::U256,);
954 #[cfg(test)]
955 #[allow(dead_code, unreachable_patterns)]
956 fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
957 match _t {
958 alloy_sol_types::private::AssertTypeEq::<
959 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
960 >(_) => {}
961 }
962 }
963 #[automatically_derived]
964 #[doc(hidden)]
965 impl ::core::convert::From<balanceOfReturn> for UnderlyingRustTuple<'_> {
966 fn from(value: balanceOfReturn) -> Self {
967 (value._0,)
968 }
969 }
970 #[automatically_derived]
971 #[doc(hidden)]
972 impl ::core::convert::From<UnderlyingRustTuple<'_>> for balanceOfReturn {
973 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
974 Self { _0: tuple.0 }
975 }
976 }
977 }
978 #[automatically_derived]
979 impl alloy_sol_types::SolCall for balanceOfCall {
980 type Parameters<'a> = (alloy::sol_types::sol_data::Address,);
981 type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
982 type Return = alloy::sol_types::private::primitives::aliases::U256;
983 type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
984 type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
985 const SIGNATURE: &'static str = "balanceOf(address)";
986 const SELECTOR: [u8; 4] = [112u8, 160u8, 130u8, 49u8];
987 #[inline]
988 fn new<'a>(
989 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
990 ) -> Self {
991 tuple.into()
992 }
993 #[inline]
994 fn tokenize(&self) -> Self::Token<'_> {
995 (
996 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
997 &self.account,
998 ),
999 )
1000 }
1001 #[inline]
1002 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
1003 (
1004 <alloy::sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
1005 ret,
1006 ),
1007 )
1008 }
1009 #[inline]
1010 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
1011 <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
1012 |r| {
1013 let r: balanceOfReturn = r.into();
1014 r._0
1015 },
1016 )
1017 }
1018 #[inline]
1019 fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
1020 <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
1021 data,
1022 )
1023 .map(|r| {
1024 let r: balanceOfReturn = r.into();
1025 r._0
1026 })
1027 }
1028 }
1029 };
1030 #[derive(serde::Serialize, serde::Deserialize, Default, Debug, PartialEq, Eq, Hash)]
1031 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1036 #[derive(Clone)]
1037 pub struct decimalsCall;
1038 #[derive(serde::Serialize, serde::Deserialize, Default, Debug, PartialEq, Eq, Hash)]
1039 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1041 #[derive(Clone)]
1042 pub struct decimalsReturn {
1043 #[allow(missing_docs)]
1044 pub _0: u8,
1045 }
1046 #[allow(
1047 non_camel_case_types,
1048 non_snake_case,
1049 clippy::pub_underscore_fields,
1050 clippy::style
1051 )]
1052 const _: () = {
1053 use alloy::sol_types as alloy_sol_types;
1054 {
1055 #[doc(hidden)]
1056 type UnderlyingSolTuple<'a> = ();
1057 #[doc(hidden)]
1058 type UnderlyingRustTuple<'a> = ();
1059 #[cfg(test)]
1060 #[allow(dead_code, unreachable_patterns)]
1061 fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
1062 match _t {
1063 alloy_sol_types::private::AssertTypeEq::<
1064 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1065 >(_) => {}
1066 }
1067 }
1068 #[automatically_derived]
1069 #[doc(hidden)]
1070 impl ::core::convert::From<decimalsCall> for UnderlyingRustTuple<'_> {
1071 fn from(value: decimalsCall) -> Self {
1072 ()
1073 }
1074 }
1075 #[automatically_derived]
1076 #[doc(hidden)]
1077 impl ::core::convert::From<UnderlyingRustTuple<'_>> for decimalsCall {
1078 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1079 Self
1080 }
1081 }
1082 }
1083 {
1084 #[doc(hidden)]
1085 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<8>,);
1086 #[doc(hidden)]
1087 type UnderlyingRustTuple<'a> = (u8,);
1088 #[cfg(test)]
1089 #[allow(dead_code, unreachable_patterns)]
1090 fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
1091 match _t {
1092 alloy_sol_types::private::AssertTypeEq::<
1093 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1094 >(_) => {}
1095 }
1096 }
1097 #[automatically_derived]
1098 #[doc(hidden)]
1099 impl ::core::convert::From<decimalsReturn> for UnderlyingRustTuple<'_> {
1100 fn from(value: decimalsReturn) -> Self {
1101 (value._0,)
1102 }
1103 }
1104 #[automatically_derived]
1105 #[doc(hidden)]
1106 impl ::core::convert::From<UnderlyingRustTuple<'_>> for decimalsReturn {
1107 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1108 Self { _0: tuple.0 }
1109 }
1110 }
1111 }
1112 #[automatically_derived]
1113 impl alloy_sol_types::SolCall for decimalsCall {
1114 type Parameters<'a> = ();
1115 type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
1116 type Return = u8;
1117 type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<8>,);
1118 type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
1119 const SIGNATURE: &'static str = "decimals()";
1120 const SELECTOR: [u8; 4] = [49u8, 60u8, 229u8, 103u8];
1121 #[inline]
1122 fn new<'a>(
1123 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
1124 ) -> Self {
1125 tuple.into()
1126 }
1127 #[inline]
1128 fn tokenize(&self) -> Self::Token<'_> {
1129 ()
1130 }
1131 #[inline]
1132 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
1133 (
1134 <alloy::sol_types::sol_data::Uint<8> as alloy_sol_types::SolType>::tokenize(
1135 ret,
1136 ),
1137 )
1138 }
1139 #[inline]
1140 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
1141 <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
1142 |r| {
1143 let r: decimalsReturn = r.into();
1144 r._0
1145 },
1146 )
1147 }
1148 #[inline]
1149 fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
1150 <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
1151 data,
1152 )
1153 .map(|r| {
1154 let r: decimalsReturn = r.into();
1155 r._0
1156 })
1157 }
1158 }
1159 };
1160 #[derive(serde::Serialize, serde::Deserialize, Default, Debug, PartialEq, Eq, Hash)]
1161 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1166 #[derive(Clone)]
1167 pub struct decreaseAllowanceCall {
1168 #[allow(missing_docs)]
1169 pub spender: alloy::sol_types::private::Address,
1170 #[allow(missing_docs)]
1171 pub subtractedValue: alloy::sol_types::private::primitives::aliases::U256,
1172 }
1173 #[derive(serde::Serialize, serde::Deserialize, Default, Debug, PartialEq, Eq, Hash)]
1174 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1176 #[derive(Clone)]
1177 pub struct decreaseAllowanceReturn {
1178 #[allow(missing_docs)]
1179 pub _0: bool,
1180 }
1181 #[allow(
1182 non_camel_case_types,
1183 non_snake_case,
1184 clippy::pub_underscore_fields,
1185 clippy::style
1186 )]
1187 const _: () = {
1188 use alloy::sol_types as alloy_sol_types;
1189 {
1190 #[doc(hidden)]
1191 type UnderlyingSolTuple<'a> = (
1192 alloy::sol_types::sol_data::Address,
1193 alloy::sol_types::sol_data::Uint<256>,
1194 );
1195 #[doc(hidden)]
1196 type UnderlyingRustTuple<'a> = (
1197 alloy::sol_types::private::Address,
1198 alloy::sol_types::private::primitives::aliases::U256,
1199 );
1200 #[cfg(test)]
1201 #[allow(dead_code, unreachable_patterns)]
1202 fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
1203 match _t {
1204 alloy_sol_types::private::AssertTypeEq::<
1205 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1206 >(_) => {}
1207 }
1208 }
1209 #[automatically_derived]
1210 #[doc(hidden)]
1211 impl ::core::convert::From<decreaseAllowanceCall> for UnderlyingRustTuple<'_> {
1212 fn from(value: decreaseAllowanceCall) -> Self {
1213 (value.spender, value.subtractedValue)
1214 }
1215 }
1216 #[automatically_derived]
1217 #[doc(hidden)]
1218 impl ::core::convert::From<UnderlyingRustTuple<'_>> for decreaseAllowanceCall {
1219 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1220 Self {
1221 spender: tuple.0,
1222 subtractedValue: tuple.1,
1223 }
1224 }
1225 }
1226 }
1227 {
1228 #[doc(hidden)]
1229 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Bool,);
1230 #[doc(hidden)]
1231 type UnderlyingRustTuple<'a> = (bool,);
1232 #[cfg(test)]
1233 #[allow(dead_code, unreachable_patterns)]
1234 fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
1235 match _t {
1236 alloy_sol_types::private::AssertTypeEq::<
1237 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1238 >(_) => {}
1239 }
1240 }
1241 #[automatically_derived]
1242 #[doc(hidden)]
1243 impl ::core::convert::From<decreaseAllowanceReturn> for UnderlyingRustTuple<'_> {
1244 fn from(value: decreaseAllowanceReturn) -> Self {
1245 (value._0,)
1246 }
1247 }
1248 #[automatically_derived]
1249 #[doc(hidden)]
1250 impl ::core::convert::From<UnderlyingRustTuple<'_>> for decreaseAllowanceReturn {
1251 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1252 Self { _0: tuple.0 }
1253 }
1254 }
1255 }
1256 #[automatically_derived]
1257 impl alloy_sol_types::SolCall for decreaseAllowanceCall {
1258 type Parameters<'a> = (
1259 alloy::sol_types::sol_data::Address,
1260 alloy::sol_types::sol_data::Uint<256>,
1261 );
1262 type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
1263 type Return = bool;
1264 type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,);
1265 type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
1266 const SIGNATURE: &'static str = "decreaseAllowance(address,uint256)";
1267 const SELECTOR: [u8; 4] = [164u8, 87u8, 194u8, 215u8];
1268 #[inline]
1269 fn new<'a>(
1270 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
1271 ) -> Self {
1272 tuple.into()
1273 }
1274 #[inline]
1275 fn tokenize(&self) -> Self::Token<'_> {
1276 (
1277 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
1278 &self.spender,
1279 ),
1280 <alloy::sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
1281 &self.subtractedValue,
1282 ),
1283 )
1284 }
1285 #[inline]
1286 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
1287 (<alloy::sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(ret),)
1288 }
1289 #[inline]
1290 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
1291 <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
1292 |r| {
1293 let r: decreaseAllowanceReturn = r.into();
1294 r._0
1295 },
1296 )
1297 }
1298 #[inline]
1299 fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
1300 <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
1301 data,
1302 )
1303 .map(|r| {
1304 let r: decreaseAllowanceReturn = r.into();
1305 r._0
1306 })
1307 }
1308 }
1309 };
1310 #[derive(serde::Serialize, serde::Deserialize, Default, Debug, PartialEq, Eq, Hash)]
1311 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1316 #[derive(Clone)]
1317 pub struct increaseAllowanceCall {
1318 #[allow(missing_docs)]
1319 pub spender: alloy::sol_types::private::Address,
1320 #[allow(missing_docs)]
1321 pub addedValue: alloy::sol_types::private::primitives::aliases::U256,
1322 }
1323 #[derive(serde::Serialize, serde::Deserialize, Default, Debug, PartialEq, Eq, Hash)]
1324 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1326 #[derive(Clone)]
1327 pub struct increaseAllowanceReturn {
1328 #[allow(missing_docs)]
1329 pub _0: bool,
1330 }
1331 #[allow(
1332 non_camel_case_types,
1333 non_snake_case,
1334 clippy::pub_underscore_fields,
1335 clippy::style
1336 )]
1337 const _: () = {
1338 use alloy::sol_types as alloy_sol_types;
1339 {
1340 #[doc(hidden)]
1341 type UnderlyingSolTuple<'a> = (
1342 alloy::sol_types::sol_data::Address,
1343 alloy::sol_types::sol_data::Uint<256>,
1344 );
1345 #[doc(hidden)]
1346 type UnderlyingRustTuple<'a> = (
1347 alloy::sol_types::private::Address,
1348 alloy::sol_types::private::primitives::aliases::U256,
1349 );
1350 #[cfg(test)]
1351 #[allow(dead_code, unreachable_patterns)]
1352 fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
1353 match _t {
1354 alloy_sol_types::private::AssertTypeEq::<
1355 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1356 >(_) => {}
1357 }
1358 }
1359 #[automatically_derived]
1360 #[doc(hidden)]
1361 impl ::core::convert::From<increaseAllowanceCall> for UnderlyingRustTuple<'_> {
1362 fn from(value: increaseAllowanceCall) -> Self {
1363 (value.spender, value.addedValue)
1364 }
1365 }
1366 #[automatically_derived]
1367 #[doc(hidden)]
1368 impl ::core::convert::From<UnderlyingRustTuple<'_>> for increaseAllowanceCall {
1369 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1370 Self {
1371 spender: tuple.0,
1372 addedValue: tuple.1,
1373 }
1374 }
1375 }
1376 }
1377 {
1378 #[doc(hidden)]
1379 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Bool,);
1380 #[doc(hidden)]
1381 type UnderlyingRustTuple<'a> = (bool,);
1382 #[cfg(test)]
1383 #[allow(dead_code, unreachable_patterns)]
1384 fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
1385 match _t {
1386 alloy_sol_types::private::AssertTypeEq::<
1387 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1388 >(_) => {}
1389 }
1390 }
1391 #[automatically_derived]
1392 #[doc(hidden)]
1393 impl ::core::convert::From<increaseAllowanceReturn> for UnderlyingRustTuple<'_> {
1394 fn from(value: increaseAllowanceReturn) -> Self {
1395 (value._0,)
1396 }
1397 }
1398 #[automatically_derived]
1399 #[doc(hidden)]
1400 impl ::core::convert::From<UnderlyingRustTuple<'_>> for increaseAllowanceReturn {
1401 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1402 Self { _0: tuple.0 }
1403 }
1404 }
1405 }
1406 #[automatically_derived]
1407 impl alloy_sol_types::SolCall for increaseAllowanceCall {
1408 type Parameters<'a> = (
1409 alloy::sol_types::sol_data::Address,
1410 alloy::sol_types::sol_data::Uint<256>,
1411 );
1412 type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
1413 type Return = bool;
1414 type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,);
1415 type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
1416 const SIGNATURE: &'static str = "increaseAllowance(address,uint256)";
1417 const SELECTOR: [u8; 4] = [57u8, 80u8, 147u8, 81u8];
1418 #[inline]
1419 fn new<'a>(
1420 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
1421 ) -> Self {
1422 tuple.into()
1423 }
1424 #[inline]
1425 fn tokenize(&self) -> Self::Token<'_> {
1426 (
1427 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
1428 &self.spender,
1429 ),
1430 <alloy::sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
1431 &self.addedValue,
1432 ),
1433 )
1434 }
1435 #[inline]
1436 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
1437 (<alloy::sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(ret),)
1438 }
1439 #[inline]
1440 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
1441 <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
1442 |r| {
1443 let r: increaseAllowanceReturn = r.into();
1444 r._0
1445 },
1446 )
1447 }
1448 #[inline]
1449 fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
1450 <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
1451 data,
1452 )
1453 .map(|r| {
1454 let r: increaseAllowanceReturn = r.into();
1455 r._0
1456 })
1457 }
1458 }
1459 };
1460 #[derive(serde::Serialize, serde::Deserialize, Default, Debug, PartialEq, Eq, Hash)]
1461 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1466 #[derive(Clone)]
1467 pub struct mintCall {
1468 #[allow(missing_docs)]
1469 pub account: alloy::sol_types::private::Address,
1470 #[allow(missing_docs)]
1471 pub amount: alloy::sol_types::private::primitives::aliases::U256,
1472 }
1473 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1475 #[derive(Clone)]
1476 pub struct mintReturn {}
1477 #[allow(
1478 non_camel_case_types,
1479 non_snake_case,
1480 clippy::pub_underscore_fields,
1481 clippy::style
1482 )]
1483 const _: () = {
1484 use alloy::sol_types as alloy_sol_types;
1485 {
1486 #[doc(hidden)]
1487 type UnderlyingSolTuple<'a> = (
1488 alloy::sol_types::sol_data::Address,
1489 alloy::sol_types::sol_data::Uint<256>,
1490 );
1491 #[doc(hidden)]
1492 type UnderlyingRustTuple<'a> = (
1493 alloy::sol_types::private::Address,
1494 alloy::sol_types::private::primitives::aliases::U256,
1495 );
1496 #[cfg(test)]
1497 #[allow(dead_code, unreachable_patterns)]
1498 fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
1499 match _t {
1500 alloy_sol_types::private::AssertTypeEq::<
1501 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1502 >(_) => {}
1503 }
1504 }
1505 #[automatically_derived]
1506 #[doc(hidden)]
1507 impl ::core::convert::From<mintCall> for UnderlyingRustTuple<'_> {
1508 fn from(value: mintCall) -> Self {
1509 (value.account, value.amount)
1510 }
1511 }
1512 #[automatically_derived]
1513 #[doc(hidden)]
1514 impl ::core::convert::From<UnderlyingRustTuple<'_>> for mintCall {
1515 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1516 Self {
1517 account: tuple.0,
1518 amount: tuple.1,
1519 }
1520 }
1521 }
1522 }
1523 {
1524 #[doc(hidden)]
1525 type UnderlyingSolTuple<'a> = ();
1526 #[doc(hidden)]
1527 type UnderlyingRustTuple<'a> = ();
1528 #[cfg(test)]
1529 #[allow(dead_code, unreachable_patterns)]
1530 fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
1531 match _t {
1532 alloy_sol_types::private::AssertTypeEq::<
1533 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1534 >(_) => {}
1535 }
1536 }
1537 #[automatically_derived]
1538 #[doc(hidden)]
1539 impl ::core::convert::From<mintReturn> for UnderlyingRustTuple<'_> {
1540 fn from(value: mintReturn) -> Self {
1541 ()
1542 }
1543 }
1544 #[automatically_derived]
1545 #[doc(hidden)]
1546 impl ::core::convert::From<UnderlyingRustTuple<'_>> for mintReturn {
1547 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1548 Self {}
1549 }
1550 }
1551 }
1552 impl mintReturn {
1553 fn _tokenize(&self) -> <mintCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
1554 ()
1555 }
1556 }
1557 #[automatically_derived]
1558 impl alloy_sol_types::SolCall for mintCall {
1559 type Parameters<'a> = (
1560 alloy::sol_types::sol_data::Address,
1561 alloy::sol_types::sol_data::Uint<256>,
1562 );
1563 type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
1564 type Return = mintReturn;
1565 type ReturnTuple<'a> = ();
1566 type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
1567 const SIGNATURE: &'static str = "mint(address,uint256)";
1568 const SELECTOR: [u8; 4] = [64u8, 193u8, 15u8, 25u8];
1569 #[inline]
1570 fn new<'a>(
1571 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
1572 ) -> Self {
1573 tuple.into()
1574 }
1575 #[inline]
1576 fn tokenize(&self) -> Self::Token<'_> {
1577 (
1578 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
1579 &self.account,
1580 ),
1581 <alloy::sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
1582 &self.amount,
1583 ),
1584 )
1585 }
1586 #[inline]
1587 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
1588 mintReturn::_tokenize(ret)
1589 }
1590 #[inline]
1591 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
1592 <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
1593 .map(Into::into)
1594 }
1595 #[inline]
1596 fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
1597 <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
1598 data,
1599 )
1600 .map(Into::into)
1601 }
1602 }
1603 };
1604 #[derive(serde::Serialize, serde::Deserialize, Default, Debug, PartialEq, Eq, Hash)]
1605 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1610 #[derive(Clone)]
1611 pub struct nameCall;
1612 #[derive(serde::Serialize, serde::Deserialize, Default, Debug, PartialEq, Eq, Hash)]
1613 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1615 #[derive(Clone)]
1616 pub struct nameReturn {
1617 #[allow(missing_docs)]
1618 pub _0: alloy::sol_types::private::String,
1619 }
1620 #[allow(
1621 non_camel_case_types,
1622 non_snake_case,
1623 clippy::pub_underscore_fields,
1624 clippy::style
1625 )]
1626 const _: () = {
1627 use alloy::sol_types as alloy_sol_types;
1628 {
1629 #[doc(hidden)]
1630 type UnderlyingSolTuple<'a> = ();
1631 #[doc(hidden)]
1632 type UnderlyingRustTuple<'a> = ();
1633 #[cfg(test)]
1634 #[allow(dead_code, unreachable_patterns)]
1635 fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
1636 match _t {
1637 alloy_sol_types::private::AssertTypeEq::<
1638 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1639 >(_) => {}
1640 }
1641 }
1642 #[automatically_derived]
1643 #[doc(hidden)]
1644 impl ::core::convert::From<nameCall> for UnderlyingRustTuple<'_> {
1645 fn from(value: nameCall) -> Self {
1646 ()
1647 }
1648 }
1649 #[automatically_derived]
1650 #[doc(hidden)]
1651 impl ::core::convert::From<UnderlyingRustTuple<'_>> for nameCall {
1652 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1653 Self
1654 }
1655 }
1656 }
1657 {
1658 #[doc(hidden)]
1659 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::String,);
1660 #[doc(hidden)]
1661 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::String,);
1662 #[cfg(test)]
1663 #[allow(dead_code, unreachable_patterns)]
1664 fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
1665 match _t {
1666 alloy_sol_types::private::AssertTypeEq::<
1667 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1668 >(_) => {}
1669 }
1670 }
1671 #[automatically_derived]
1672 #[doc(hidden)]
1673 impl ::core::convert::From<nameReturn> for UnderlyingRustTuple<'_> {
1674 fn from(value: nameReturn) -> Self {
1675 (value._0,)
1676 }
1677 }
1678 #[automatically_derived]
1679 #[doc(hidden)]
1680 impl ::core::convert::From<UnderlyingRustTuple<'_>> for nameReturn {
1681 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1682 Self { _0: tuple.0 }
1683 }
1684 }
1685 }
1686 #[automatically_derived]
1687 impl alloy_sol_types::SolCall for nameCall {
1688 type Parameters<'a> = ();
1689 type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
1690 type Return = alloy::sol_types::private::String;
1691 type ReturnTuple<'a> = (alloy::sol_types::sol_data::String,);
1692 type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
1693 const SIGNATURE: &'static str = "name()";
1694 const SELECTOR: [u8; 4] = [6u8, 253u8, 222u8, 3u8];
1695 #[inline]
1696 fn new<'a>(
1697 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
1698 ) -> Self {
1699 tuple.into()
1700 }
1701 #[inline]
1702 fn tokenize(&self) -> Self::Token<'_> {
1703 ()
1704 }
1705 #[inline]
1706 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
1707 (<alloy::sol_types::sol_data::String as alloy_sol_types::SolType>::tokenize(ret),)
1708 }
1709 #[inline]
1710 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
1711 <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
1712 |r| {
1713 let r: nameReturn = r.into();
1714 r._0
1715 },
1716 )
1717 }
1718 #[inline]
1719 fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
1720 <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
1721 data,
1722 )
1723 .map(|r| {
1724 let r: nameReturn = r.into();
1725 r._0
1726 })
1727 }
1728 }
1729 };
1730 #[derive(serde::Serialize, serde::Deserialize, Default, Debug, PartialEq, Eq, Hash)]
1731 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1736 #[derive(Clone)]
1737 pub struct symbolCall;
1738 #[derive(serde::Serialize, serde::Deserialize, Default, Debug, PartialEq, Eq, Hash)]
1739 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1741 #[derive(Clone)]
1742 pub struct symbolReturn {
1743 #[allow(missing_docs)]
1744 pub _0: alloy::sol_types::private::String,
1745 }
1746 #[allow(
1747 non_camel_case_types,
1748 non_snake_case,
1749 clippy::pub_underscore_fields,
1750 clippy::style
1751 )]
1752 const _: () = {
1753 use alloy::sol_types as alloy_sol_types;
1754 {
1755 #[doc(hidden)]
1756 type UnderlyingSolTuple<'a> = ();
1757 #[doc(hidden)]
1758 type UnderlyingRustTuple<'a> = ();
1759 #[cfg(test)]
1760 #[allow(dead_code, unreachable_patterns)]
1761 fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
1762 match _t {
1763 alloy_sol_types::private::AssertTypeEq::<
1764 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1765 >(_) => {}
1766 }
1767 }
1768 #[automatically_derived]
1769 #[doc(hidden)]
1770 impl ::core::convert::From<symbolCall> for UnderlyingRustTuple<'_> {
1771 fn from(value: symbolCall) -> Self {
1772 ()
1773 }
1774 }
1775 #[automatically_derived]
1776 #[doc(hidden)]
1777 impl ::core::convert::From<UnderlyingRustTuple<'_>> for symbolCall {
1778 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1779 Self
1780 }
1781 }
1782 }
1783 {
1784 #[doc(hidden)]
1785 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::String,);
1786 #[doc(hidden)]
1787 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::String,);
1788 #[cfg(test)]
1789 #[allow(dead_code, unreachable_patterns)]
1790 fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
1791 match _t {
1792 alloy_sol_types::private::AssertTypeEq::<
1793 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1794 >(_) => {}
1795 }
1796 }
1797 #[automatically_derived]
1798 #[doc(hidden)]
1799 impl ::core::convert::From<symbolReturn> for UnderlyingRustTuple<'_> {
1800 fn from(value: symbolReturn) -> Self {
1801 (value._0,)
1802 }
1803 }
1804 #[automatically_derived]
1805 #[doc(hidden)]
1806 impl ::core::convert::From<UnderlyingRustTuple<'_>> for symbolReturn {
1807 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1808 Self { _0: tuple.0 }
1809 }
1810 }
1811 }
1812 #[automatically_derived]
1813 impl alloy_sol_types::SolCall for symbolCall {
1814 type Parameters<'a> = ();
1815 type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
1816 type Return = alloy::sol_types::private::String;
1817 type ReturnTuple<'a> = (alloy::sol_types::sol_data::String,);
1818 type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
1819 const SIGNATURE: &'static str = "symbol()";
1820 const SELECTOR: [u8; 4] = [149u8, 216u8, 155u8, 65u8];
1821 #[inline]
1822 fn new<'a>(
1823 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
1824 ) -> Self {
1825 tuple.into()
1826 }
1827 #[inline]
1828 fn tokenize(&self) -> Self::Token<'_> {
1829 ()
1830 }
1831 #[inline]
1832 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
1833 (<alloy::sol_types::sol_data::String as alloy_sol_types::SolType>::tokenize(ret),)
1834 }
1835 #[inline]
1836 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
1837 <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
1838 |r| {
1839 let r: symbolReturn = r.into();
1840 r._0
1841 },
1842 )
1843 }
1844 #[inline]
1845 fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
1846 <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
1847 data,
1848 )
1849 .map(|r| {
1850 let r: symbolReturn = r.into();
1851 r._0
1852 })
1853 }
1854 }
1855 };
1856 #[derive(serde::Serialize, serde::Deserialize, Default, Debug, PartialEq, Eq, Hash)]
1857 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1862 #[derive(Clone)]
1863 pub struct totalSupplyCall;
1864 #[derive(serde::Serialize, serde::Deserialize, Default, Debug, PartialEq, Eq, Hash)]
1865 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1867 #[derive(Clone)]
1868 pub struct totalSupplyReturn {
1869 #[allow(missing_docs)]
1870 pub _0: alloy::sol_types::private::primitives::aliases::U256,
1871 }
1872 #[allow(
1873 non_camel_case_types,
1874 non_snake_case,
1875 clippy::pub_underscore_fields,
1876 clippy::style
1877 )]
1878 const _: () = {
1879 use alloy::sol_types as alloy_sol_types;
1880 {
1881 #[doc(hidden)]
1882 type UnderlyingSolTuple<'a> = ();
1883 #[doc(hidden)]
1884 type UnderlyingRustTuple<'a> = ();
1885 #[cfg(test)]
1886 #[allow(dead_code, unreachable_patterns)]
1887 fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
1888 match _t {
1889 alloy_sol_types::private::AssertTypeEq::<
1890 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1891 >(_) => {}
1892 }
1893 }
1894 #[automatically_derived]
1895 #[doc(hidden)]
1896 impl ::core::convert::From<totalSupplyCall> for UnderlyingRustTuple<'_> {
1897 fn from(value: totalSupplyCall) -> Self {
1898 ()
1899 }
1900 }
1901 #[automatically_derived]
1902 #[doc(hidden)]
1903 impl ::core::convert::From<UnderlyingRustTuple<'_>> for totalSupplyCall {
1904 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1905 Self
1906 }
1907 }
1908 }
1909 {
1910 #[doc(hidden)]
1911 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
1912 #[doc(hidden)]
1913 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::primitives::aliases::U256,);
1914 #[cfg(test)]
1915 #[allow(dead_code, unreachable_patterns)]
1916 fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
1917 match _t {
1918 alloy_sol_types::private::AssertTypeEq::<
1919 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1920 >(_) => {}
1921 }
1922 }
1923 #[automatically_derived]
1924 #[doc(hidden)]
1925 impl ::core::convert::From<totalSupplyReturn> for UnderlyingRustTuple<'_> {
1926 fn from(value: totalSupplyReturn) -> Self {
1927 (value._0,)
1928 }
1929 }
1930 #[automatically_derived]
1931 #[doc(hidden)]
1932 impl ::core::convert::From<UnderlyingRustTuple<'_>> for totalSupplyReturn {
1933 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1934 Self { _0: tuple.0 }
1935 }
1936 }
1937 }
1938 #[automatically_derived]
1939 impl alloy_sol_types::SolCall for totalSupplyCall {
1940 type Parameters<'a> = ();
1941 type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
1942 type Return = alloy::sol_types::private::primitives::aliases::U256;
1943 type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
1944 type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
1945 const SIGNATURE: &'static str = "totalSupply()";
1946 const SELECTOR: [u8; 4] = [24u8, 22u8, 13u8, 221u8];
1947 #[inline]
1948 fn new<'a>(
1949 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
1950 ) -> Self {
1951 tuple.into()
1952 }
1953 #[inline]
1954 fn tokenize(&self) -> Self::Token<'_> {
1955 ()
1956 }
1957 #[inline]
1958 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
1959 (
1960 <alloy::sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
1961 ret,
1962 ),
1963 )
1964 }
1965 #[inline]
1966 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
1967 <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
1968 |r| {
1969 let r: totalSupplyReturn = r.into();
1970 r._0
1971 },
1972 )
1973 }
1974 #[inline]
1975 fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
1976 <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
1977 data,
1978 )
1979 .map(|r| {
1980 let r: totalSupplyReturn = r.into();
1981 r._0
1982 })
1983 }
1984 }
1985 };
1986 #[derive(serde::Serialize, serde::Deserialize, Default, Debug, PartialEq, Eq, Hash)]
1987 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1992 #[derive(Clone)]
1993 pub struct transferCall {
1994 #[allow(missing_docs)]
1995 pub to: alloy::sol_types::private::Address,
1996 #[allow(missing_docs)]
1997 pub amount: alloy::sol_types::private::primitives::aliases::U256,
1998 }
1999 #[derive(serde::Serialize, serde::Deserialize, Default, Debug, PartialEq, Eq, Hash)]
2000 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2002 #[derive(Clone)]
2003 pub struct transferReturn {
2004 #[allow(missing_docs)]
2005 pub _0: bool,
2006 }
2007 #[allow(
2008 non_camel_case_types,
2009 non_snake_case,
2010 clippy::pub_underscore_fields,
2011 clippy::style
2012 )]
2013 const _: () = {
2014 use alloy::sol_types as alloy_sol_types;
2015 {
2016 #[doc(hidden)]
2017 type UnderlyingSolTuple<'a> = (
2018 alloy::sol_types::sol_data::Address,
2019 alloy::sol_types::sol_data::Uint<256>,
2020 );
2021 #[doc(hidden)]
2022 type UnderlyingRustTuple<'a> = (
2023 alloy::sol_types::private::Address,
2024 alloy::sol_types::private::primitives::aliases::U256,
2025 );
2026 #[cfg(test)]
2027 #[allow(dead_code, unreachable_patterns)]
2028 fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
2029 match _t {
2030 alloy_sol_types::private::AssertTypeEq::<
2031 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2032 >(_) => {}
2033 }
2034 }
2035 #[automatically_derived]
2036 #[doc(hidden)]
2037 impl ::core::convert::From<transferCall> for UnderlyingRustTuple<'_> {
2038 fn from(value: transferCall) -> Self {
2039 (value.to, value.amount)
2040 }
2041 }
2042 #[automatically_derived]
2043 #[doc(hidden)]
2044 impl ::core::convert::From<UnderlyingRustTuple<'_>> for transferCall {
2045 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2046 Self {
2047 to: tuple.0,
2048 amount: tuple.1,
2049 }
2050 }
2051 }
2052 }
2053 {
2054 #[doc(hidden)]
2055 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Bool,);
2056 #[doc(hidden)]
2057 type UnderlyingRustTuple<'a> = (bool,);
2058 #[cfg(test)]
2059 #[allow(dead_code, unreachable_patterns)]
2060 fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
2061 match _t {
2062 alloy_sol_types::private::AssertTypeEq::<
2063 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2064 >(_) => {}
2065 }
2066 }
2067 #[automatically_derived]
2068 #[doc(hidden)]
2069 impl ::core::convert::From<transferReturn> for UnderlyingRustTuple<'_> {
2070 fn from(value: transferReturn) -> Self {
2071 (value._0,)
2072 }
2073 }
2074 #[automatically_derived]
2075 #[doc(hidden)]
2076 impl ::core::convert::From<UnderlyingRustTuple<'_>> for transferReturn {
2077 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2078 Self { _0: tuple.0 }
2079 }
2080 }
2081 }
2082 #[automatically_derived]
2083 impl alloy_sol_types::SolCall for transferCall {
2084 type Parameters<'a> = (
2085 alloy::sol_types::sol_data::Address,
2086 alloy::sol_types::sol_data::Uint<256>,
2087 );
2088 type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
2089 type Return = bool;
2090 type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,);
2091 type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
2092 const SIGNATURE: &'static str = "transfer(address,uint256)";
2093 const SELECTOR: [u8; 4] = [169u8, 5u8, 156u8, 187u8];
2094 #[inline]
2095 fn new<'a>(
2096 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
2097 ) -> Self {
2098 tuple.into()
2099 }
2100 #[inline]
2101 fn tokenize(&self) -> Self::Token<'_> {
2102 (
2103 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
2104 &self.to,
2105 ),
2106 <alloy::sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
2107 &self.amount,
2108 ),
2109 )
2110 }
2111 #[inline]
2112 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
2113 (<alloy::sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(ret),)
2114 }
2115 #[inline]
2116 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
2117 <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
2118 |r| {
2119 let r: transferReturn = r.into();
2120 r._0
2121 },
2122 )
2123 }
2124 #[inline]
2125 fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
2126 <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
2127 data,
2128 )
2129 .map(|r| {
2130 let r: transferReturn = r.into();
2131 r._0
2132 })
2133 }
2134 }
2135 };
2136 #[derive(serde::Serialize, serde::Deserialize, Default, Debug, PartialEq, Eq, Hash)]
2137 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2142 #[derive(Clone)]
2143 pub struct transferFromCall {
2144 #[allow(missing_docs)]
2145 pub from: alloy::sol_types::private::Address,
2146 #[allow(missing_docs)]
2147 pub to: alloy::sol_types::private::Address,
2148 #[allow(missing_docs)]
2149 pub amount: alloy::sol_types::private::primitives::aliases::U256,
2150 }
2151 #[derive(serde::Serialize, serde::Deserialize, Default, Debug, PartialEq, Eq, Hash)]
2152 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2154 #[derive(Clone)]
2155 pub struct transferFromReturn {
2156 #[allow(missing_docs)]
2157 pub _0: bool,
2158 }
2159 #[allow(
2160 non_camel_case_types,
2161 non_snake_case,
2162 clippy::pub_underscore_fields,
2163 clippy::style
2164 )]
2165 const _: () = {
2166 use alloy::sol_types as alloy_sol_types;
2167 {
2168 #[doc(hidden)]
2169 type UnderlyingSolTuple<'a> = (
2170 alloy::sol_types::sol_data::Address,
2171 alloy::sol_types::sol_data::Address,
2172 alloy::sol_types::sol_data::Uint<256>,
2173 );
2174 #[doc(hidden)]
2175 type UnderlyingRustTuple<'a> = (
2176 alloy::sol_types::private::Address,
2177 alloy::sol_types::private::Address,
2178 alloy::sol_types::private::primitives::aliases::U256,
2179 );
2180 #[cfg(test)]
2181 #[allow(dead_code, unreachable_patterns)]
2182 fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
2183 match _t {
2184 alloy_sol_types::private::AssertTypeEq::<
2185 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2186 >(_) => {}
2187 }
2188 }
2189 #[automatically_derived]
2190 #[doc(hidden)]
2191 impl ::core::convert::From<transferFromCall> for UnderlyingRustTuple<'_> {
2192 fn from(value: transferFromCall) -> Self {
2193 (value.from, value.to, value.amount)
2194 }
2195 }
2196 #[automatically_derived]
2197 #[doc(hidden)]
2198 impl ::core::convert::From<UnderlyingRustTuple<'_>> for transferFromCall {
2199 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2200 Self {
2201 from: tuple.0,
2202 to: tuple.1,
2203 amount: tuple.2,
2204 }
2205 }
2206 }
2207 }
2208 {
2209 #[doc(hidden)]
2210 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Bool,);
2211 #[doc(hidden)]
2212 type UnderlyingRustTuple<'a> = (bool,);
2213 #[cfg(test)]
2214 #[allow(dead_code, unreachable_patterns)]
2215 fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
2216 match _t {
2217 alloy_sol_types::private::AssertTypeEq::<
2218 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2219 >(_) => {}
2220 }
2221 }
2222 #[automatically_derived]
2223 #[doc(hidden)]
2224 impl ::core::convert::From<transferFromReturn> for UnderlyingRustTuple<'_> {
2225 fn from(value: transferFromReturn) -> Self {
2226 (value._0,)
2227 }
2228 }
2229 #[automatically_derived]
2230 #[doc(hidden)]
2231 impl ::core::convert::From<UnderlyingRustTuple<'_>> for transferFromReturn {
2232 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2233 Self { _0: tuple.0 }
2234 }
2235 }
2236 }
2237 #[automatically_derived]
2238 impl alloy_sol_types::SolCall for transferFromCall {
2239 type Parameters<'a> = (
2240 alloy::sol_types::sol_data::Address,
2241 alloy::sol_types::sol_data::Address,
2242 alloy::sol_types::sol_data::Uint<256>,
2243 );
2244 type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
2245 type Return = bool;
2246 type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,);
2247 type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
2248 const SIGNATURE: &'static str = "transferFrom(address,address,uint256)";
2249 const SELECTOR: [u8; 4] = [35u8, 184u8, 114u8, 221u8];
2250 #[inline]
2251 fn new<'a>(
2252 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
2253 ) -> Self {
2254 tuple.into()
2255 }
2256 #[inline]
2257 fn tokenize(&self) -> Self::Token<'_> {
2258 (
2259 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
2260 &self.from,
2261 ),
2262 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
2263 &self.to,
2264 ),
2265 <alloy::sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
2266 &self.amount,
2267 ),
2268 )
2269 }
2270 #[inline]
2271 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
2272 (<alloy::sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(ret),)
2273 }
2274 #[inline]
2275 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
2276 <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
2277 |r| {
2278 let r: transferFromReturn = r.into();
2279 r._0
2280 },
2281 )
2282 }
2283 #[inline]
2284 fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
2285 <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
2286 data,
2287 )
2288 .map(|r| {
2289 let r: transferFromReturn = r.into();
2290 r._0
2291 })
2292 }
2293 }
2294 };
2295 #[derive(serde::Serialize, serde::Deserialize)]
2297 pub enum MockERC20Calls {
2298 #[allow(missing_docs)]
2299 allowance(allowanceCall),
2300 #[allow(missing_docs)]
2301 approve(approveCall),
2302 #[allow(missing_docs)]
2303 balanceOf(balanceOfCall),
2304 #[allow(missing_docs)]
2305 decimals(decimalsCall),
2306 #[allow(missing_docs)]
2307 decreaseAllowance(decreaseAllowanceCall),
2308 #[allow(missing_docs)]
2309 increaseAllowance(increaseAllowanceCall),
2310 #[allow(missing_docs)]
2311 mint(mintCall),
2312 #[allow(missing_docs)]
2313 name(nameCall),
2314 #[allow(missing_docs)]
2315 symbol(symbolCall),
2316 #[allow(missing_docs)]
2317 totalSupply(totalSupplyCall),
2318 #[allow(missing_docs)]
2319 transfer(transferCall),
2320 #[allow(missing_docs)]
2321 transferFrom(transferFromCall),
2322 }
2323 #[automatically_derived]
2324 impl MockERC20Calls {
2325 pub const SELECTORS: &'static [[u8; 4usize]] = &[
2332 [6u8, 253u8, 222u8, 3u8],
2333 [9u8, 94u8, 167u8, 179u8],
2334 [24u8, 22u8, 13u8, 221u8],
2335 [35u8, 184u8, 114u8, 221u8],
2336 [49u8, 60u8, 229u8, 103u8],
2337 [57u8, 80u8, 147u8, 81u8],
2338 [64u8, 193u8, 15u8, 25u8],
2339 [112u8, 160u8, 130u8, 49u8],
2340 [149u8, 216u8, 155u8, 65u8],
2341 [164u8, 87u8, 194u8, 215u8],
2342 [169u8, 5u8, 156u8, 187u8],
2343 [221u8, 98u8, 237u8, 62u8],
2344 ];
2345 }
2346 #[automatically_derived]
2347 impl alloy_sol_types::SolInterface for MockERC20Calls {
2348 const NAME: &'static str = "MockERC20Calls";
2349 const MIN_DATA_LENGTH: usize = 0usize;
2350 const COUNT: usize = 12usize;
2351 #[inline]
2352 fn selector(&self) -> [u8; 4] {
2353 match self {
2354 Self::allowance(_) => <allowanceCall as alloy_sol_types::SolCall>::SELECTOR,
2355 Self::approve(_) => <approveCall as alloy_sol_types::SolCall>::SELECTOR,
2356 Self::balanceOf(_) => <balanceOfCall as alloy_sol_types::SolCall>::SELECTOR,
2357 Self::decimals(_) => <decimalsCall as alloy_sol_types::SolCall>::SELECTOR,
2358 Self::decreaseAllowance(_) => {
2359 <decreaseAllowanceCall as alloy_sol_types::SolCall>::SELECTOR
2360 }
2361 Self::increaseAllowance(_) => {
2362 <increaseAllowanceCall as alloy_sol_types::SolCall>::SELECTOR
2363 }
2364 Self::mint(_) => <mintCall as alloy_sol_types::SolCall>::SELECTOR,
2365 Self::name(_) => <nameCall as alloy_sol_types::SolCall>::SELECTOR,
2366 Self::symbol(_) => <symbolCall as alloy_sol_types::SolCall>::SELECTOR,
2367 Self::totalSupply(_) => <totalSupplyCall as alloy_sol_types::SolCall>::SELECTOR,
2368 Self::transfer(_) => <transferCall as alloy_sol_types::SolCall>::SELECTOR,
2369 Self::transferFrom(_) => <transferFromCall as alloy_sol_types::SolCall>::SELECTOR,
2370 }
2371 }
2372 #[inline]
2373 fn selector_at(i: usize) -> ::core::option::Option<[u8; 4]> {
2374 Self::SELECTORS.get(i).copied()
2375 }
2376 #[inline]
2377 fn valid_selector(selector: [u8; 4]) -> bool {
2378 Self::SELECTORS.binary_search(&selector).is_ok()
2379 }
2380 #[inline]
2381 #[allow(non_snake_case)]
2382 fn abi_decode_raw(selector: [u8; 4], data: &[u8]) -> alloy_sol_types::Result<Self> {
2383 static DECODE_SHIMS: &[fn(&[u8]) -> alloy_sol_types::Result<MockERC20Calls>] = &[
2384 {
2385 fn name(data: &[u8]) -> alloy_sol_types::Result<MockERC20Calls> {
2386 <nameCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
2387 .map(MockERC20Calls::name)
2388 }
2389 name
2390 },
2391 {
2392 fn approve(data: &[u8]) -> alloy_sol_types::Result<MockERC20Calls> {
2393 <approveCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
2394 .map(MockERC20Calls::approve)
2395 }
2396 approve
2397 },
2398 {
2399 fn totalSupply(data: &[u8]) -> alloy_sol_types::Result<MockERC20Calls> {
2400 <totalSupplyCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
2401 .map(MockERC20Calls::totalSupply)
2402 }
2403 totalSupply
2404 },
2405 {
2406 fn transferFrom(data: &[u8]) -> alloy_sol_types::Result<MockERC20Calls> {
2407 <transferFromCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
2408 .map(MockERC20Calls::transferFrom)
2409 }
2410 transferFrom
2411 },
2412 {
2413 fn decimals(data: &[u8]) -> alloy_sol_types::Result<MockERC20Calls> {
2414 <decimalsCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
2415 .map(MockERC20Calls::decimals)
2416 }
2417 decimals
2418 },
2419 {
2420 fn increaseAllowance(data: &[u8]) -> alloy_sol_types::Result<MockERC20Calls> {
2421 <increaseAllowanceCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
2422 .map(MockERC20Calls::increaseAllowance)
2423 }
2424 increaseAllowance
2425 },
2426 {
2427 fn mint(data: &[u8]) -> alloy_sol_types::Result<MockERC20Calls> {
2428 <mintCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
2429 .map(MockERC20Calls::mint)
2430 }
2431 mint
2432 },
2433 {
2434 fn balanceOf(data: &[u8]) -> alloy_sol_types::Result<MockERC20Calls> {
2435 <balanceOfCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
2436 .map(MockERC20Calls::balanceOf)
2437 }
2438 balanceOf
2439 },
2440 {
2441 fn symbol(data: &[u8]) -> alloy_sol_types::Result<MockERC20Calls> {
2442 <symbolCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
2443 .map(MockERC20Calls::symbol)
2444 }
2445 symbol
2446 },
2447 {
2448 fn decreaseAllowance(data: &[u8]) -> alloy_sol_types::Result<MockERC20Calls> {
2449 <decreaseAllowanceCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
2450 .map(MockERC20Calls::decreaseAllowance)
2451 }
2452 decreaseAllowance
2453 },
2454 {
2455 fn transfer(data: &[u8]) -> alloy_sol_types::Result<MockERC20Calls> {
2456 <transferCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
2457 .map(MockERC20Calls::transfer)
2458 }
2459 transfer
2460 },
2461 {
2462 fn allowance(data: &[u8]) -> alloy_sol_types::Result<MockERC20Calls> {
2463 <allowanceCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
2464 .map(MockERC20Calls::allowance)
2465 }
2466 allowance
2467 },
2468 ];
2469 let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
2470 return Err(alloy_sol_types::Error::unknown_selector(
2471 <Self as alloy_sol_types::SolInterface>::NAME,
2472 selector,
2473 ));
2474 };
2475 DECODE_SHIMS[idx](data)
2476 }
2477 #[inline]
2478 #[allow(non_snake_case)]
2479 fn abi_decode_raw_validate(
2480 selector: [u8; 4],
2481 data: &[u8],
2482 ) -> alloy_sol_types::Result<Self> {
2483 static DECODE_VALIDATE_SHIMS: &[fn(
2484 &[u8],
2485 )
2486 -> alloy_sol_types::Result<MockERC20Calls>] = &[
2487 {
2488 fn name(data: &[u8]) -> alloy_sol_types::Result<MockERC20Calls> {
2489 <nameCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
2490 .map(MockERC20Calls::name)
2491 }
2492 name
2493 },
2494 {
2495 fn approve(data: &[u8]) -> alloy_sol_types::Result<MockERC20Calls> {
2496 <approveCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
2497 .map(MockERC20Calls::approve)
2498 }
2499 approve
2500 },
2501 {
2502 fn totalSupply(data: &[u8]) -> alloy_sol_types::Result<MockERC20Calls> {
2503 <totalSupplyCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
2504 .map(MockERC20Calls::totalSupply)
2505 }
2506 totalSupply
2507 },
2508 {
2509 fn transferFrom(data: &[u8]) -> alloy_sol_types::Result<MockERC20Calls> {
2510 <transferFromCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
2511 data,
2512 )
2513 .map(MockERC20Calls::transferFrom)
2514 }
2515 transferFrom
2516 },
2517 {
2518 fn decimals(data: &[u8]) -> alloy_sol_types::Result<MockERC20Calls> {
2519 <decimalsCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
2520 .map(MockERC20Calls::decimals)
2521 }
2522 decimals
2523 },
2524 {
2525 fn increaseAllowance(data: &[u8]) -> alloy_sol_types::Result<MockERC20Calls> {
2526 <increaseAllowanceCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
2527 data,
2528 )
2529 .map(MockERC20Calls::increaseAllowance)
2530 }
2531 increaseAllowance
2532 },
2533 {
2534 fn mint(data: &[u8]) -> alloy_sol_types::Result<MockERC20Calls> {
2535 <mintCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
2536 .map(MockERC20Calls::mint)
2537 }
2538 mint
2539 },
2540 {
2541 fn balanceOf(data: &[u8]) -> alloy_sol_types::Result<MockERC20Calls> {
2542 <balanceOfCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
2543 .map(MockERC20Calls::balanceOf)
2544 }
2545 balanceOf
2546 },
2547 {
2548 fn symbol(data: &[u8]) -> alloy_sol_types::Result<MockERC20Calls> {
2549 <symbolCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
2550 .map(MockERC20Calls::symbol)
2551 }
2552 symbol
2553 },
2554 {
2555 fn decreaseAllowance(data: &[u8]) -> alloy_sol_types::Result<MockERC20Calls> {
2556 <decreaseAllowanceCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
2557 data,
2558 )
2559 .map(MockERC20Calls::decreaseAllowance)
2560 }
2561 decreaseAllowance
2562 },
2563 {
2564 fn transfer(data: &[u8]) -> alloy_sol_types::Result<MockERC20Calls> {
2565 <transferCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
2566 .map(MockERC20Calls::transfer)
2567 }
2568 transfer
2569 },
2570 {
2571 fn allowance(data: &[u8]) -> alloy_sol_types::Result<MockERC20Calls> {
2572 <allowanceCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
2573 .map(MockERC20Calls::allowance)
2574 }
2575 allowance
2576 },
2577 ];
2578 let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
2579 return Err(alloy_sol_types::Error::unknown_selector(
2580 <Self as alloy_sol_types::SolInterface>::NAME,
2581 selector,
2582 ));
2583 };
2584 DECODE_VALIDATE_SHIMS[idx](data)
2585 }
2586 #[inline]
2587 fn abi_encoded_size(&self) -> usize {
2588 match self {
2589 Self::allowance(inner) => {
2590 <allowanceCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
2591 }
2592 Self::approve(inner) => {
2593 <approveCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
2594 }
2595 Self::balanceOf(inner) => {
2596 <balanceOfCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
2597 }
2598 Self::decimals(inner) => {
2599 <decimalsCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
2600 }
2601 Self::decreaseAllowance(inner) => {
2602 <decreaseAllowanceCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
2603 }
2604 Self::increaseAllowance(inner) => {
2605 <increaseAllowanceCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
2606 }
2607 Self::mint(inner) => {
2608 <mintCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
2609 }
2610 Self::name(inner) => {
2611 <nameCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
2612 }
2613 Self::symbol(inner) => {
2614 <symbolCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
2615 }
2616 Self::totalSupply(inner) => {
2617 <totalSupplyCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
2618 }
2619 Self::transfer(inner) => {
2620 <transferCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
2621 }
2622 Self::transferFrom(inner) => {
2623 <transferFromCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
2624 }
2625 }
2626 }
2627 #[inline]
2628 fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
2629 match self {
2630 Self::allowance(inner) => {
2631 <allowanceCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
2632 }
2633 Self::approve(inner) => {
2634 <approveCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
2635 }
2636 Self::balanceOf(inner) => {
2637 <balanceOfCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
2638 }
2639 Self::decimals(inner) => {
2640 <decimalsCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
2641 }
2642 Self::decreaseAllowance(inner) => {
2643 <decreaseAllowanceCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
2644 }
2645 Self::increaseAllowance(inner) => {
2646 <increaseAllowanceCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
2647 }
2648 Self::mint(inner) => {
2649 <mintCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
2650 }
2651 Self::name(inner) => {
2652 <nameCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
2653 }
2654 Self::symbol(inner) => {
2655 <symbolCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
2656 }
2657 Self::totalSupply(inner) => {
2658 <totalSupplyCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
2659 }
2660 Self::transfer(inner) => {
2661 <transferCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
2662 }
2663 Self::transferFrom(inner) => {
2664 <transferFromCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
2665 }
2666 }
2667 }
2668 }
2669 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq, Eq, Hash)]
2671 pub enum MockERC20Events {
2672 #[allow(missing_docs)]
2673 Approval(Approval),
2674 #[allow(missing_docs)]
2675 Transfer(Transfer),
2676 }
2677 #[automatically_derived]
2678 impl MockERC20Events {
2679 pub const SELECTORS: &'static [[u8; 32usize]] = &[
2686 [
2687 140u8, 91u8, 225u8, 229u8, 235u8, 236u8, 125u8, 91u8, 209u8, 79u8, 113u8, 66u8,
2688 125u8, 30u8, 132u8, 243u8, 221u8, 3u8, 20u8, 192u8, 247u8, 178u8, 41u8, 30u8, 91u8,
2689 32u8, 10u8, 200u8, 199u8, 195u8, 185u8, 37u8,
2690 ],
2691 [
2692 221u8, 242u8, 82u8, 173u8, 27u8, 226u8, 200u8, 155u8, 105u8, 194u8, 176u8, 104u8,
2693 252u8, 55u8, 141u8, 170u8, 149u8, 43u8, 167u8, 241u8, 99u8, 196u8, 161u8, 22u8,
2694 40u8, 245u8, 90u8, 77u8, 245u8, 35u8, 179u8, 239u8,
2695 ],
2696 ];
2697 }
2698 #[automatically_derived]
2699 impl alloy_sol_types::SolEventInterface for MockERC20Events {
2700 const NAME: &'static str = "MockERC20Events";
2701 const COUNT: usize = 2usize;
2702 fn decode_raw_log(
2703 topics: &[alloy_sol_types::Word],
2704 data: &[u8],
2705 ) -> alloy_sol_types::Result<Self> {
2706 match topics.first().copied() {
2707 Some(<Approval as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
2708 <Approval as alloy_sol_types::SolEvent>::decode_raw_log(topics, data)
2709 .map(Self::Approval)
2710 }
2711 Some(<Transfer as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
2712 <Transfer as alloy_sol_types::SolEvent>::decode_raw_log(topics, data)
2713 .map(Self::Transfer)
2714 }
2715 _ => alloy_sol_types::private::Err(alloy_sol_types::Error::InvalidLog {
2716 name: <Self as alloy_sol_types::SolEventInterface>::NAME,
2717 log: alloy_sol_types::private::Box::new(
2718 alloy_sol_types::private::LogData::new_unchecked(
2719 topics.to_vec(),
2720 data.to_vec().into(),
2721 ),
2722 ),
2723 }),
2724 }
2725 }
2726 }
2727 #[automatically_derived]
2728 impl alloy_sol_types::private::IntoLogData for MockERC20Events {
2729 fn to_log_data(&self) -> alloy_sol_types::private::LogData {
2730 match self {
2731 Self::Approval(inner) => alloy_sol_types::private::IntoLogData::to_log_data(inner),
2732 Self::Transfer(inner) => alloy_sol_types::private::IntoLogData::to_log_data(inner),
2733 }
2734 }
2735 fn into_log_data(self) -> alloy_sol_types::private::LogData {
2736 match self {
2737 Self::Approval(inner) => {
2738 alloy_sol_types::private::IntoLogData::into_log_data(inner)
2739 }
2740 Self::Transfer(inner) => {
2741 alloy_sol_types::private::IntoLogData::into_log_data(inner)
2742 }
2743 }
2744 }
2745 }
2746 use alloy::contract as alloy_contract;
2747 #[inline]
2751 pub const fn new<
2752 P: alloy_contract::private::Provider<N>,
2753 N: alloy_contract::private::Network,
2754 >(
2755 address: alloy_sol_types::private::Address,
2756 provider: P,
2757 ) -> MockERC20Instance<P, N> {
2758 MockERC20Instance::<P, N>::new(address, provider)
2759 }
2760 #[inline]
2766 pub fn deploy<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>(
2767 provider: P,
2768 ) -> impl ::core::future::Future<Output = alloy_contract::Result<MockERC20Instance<P, N>>> {
2769 MockERC20Instance::<P, N>::deploy(provider)
2770 }
2771 #[inline]
2777 pub fn deploy_builder<
2778 P: alloy_contract::private::Provider<N>,
2779 N: alloy_contract::private::Network,
2780 >(
2781 provider: P,
2782 ) -> alloy_contract::RawCallBuilder<P, N> {
2783 MockERC20Instance::<P, N>::deploy_builder(provider)
2784 }
2785 #[derive(Clone)]
2797 pub struct MockERC20Instance<P, N = alloy_contract::private::Ethereum> {
2798 address: alloy_sol_types::private::Address,
2799 provider: P,
2800 _network: ::core::marker::PhantomData<N>,
2801 }
2802 #[automatically_derived]
2803 impl<P, N> ::core::fmt::Debug for MockERC20Instance<P, N> {
2804 #[inline]
2805 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
2806 f.debug_tuple("MockERC20Instance")
2807 .field(&self.address)
2808 .finish()
2809 }
2810 }
2811 #[automatically_derived]
2813 impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
2814 MockERC20Instance<P, N>
2815 {
2816 #[inline]
2820 pub const fn new(address: alloy_sol_types::private::Address, provider: P) -> Self {
2821 Self {
2822 address,
2823 provider,
2824 _network: ::core::marker::PhantomData,
2825 }
2826 }
2827 #[inline]
2833 pub async fn deploy(provider: P) -> alloy_contract::Result<MockERC20Instance<P, N>> {
2834 let call_builder = Self::deploy_builder(provider);
2835 let contract_address = call_builder.deploy().await?;
2836 Ok(Self::new(contract_address, call_builder.provider))
2837 }
2838 #[inline]
2844 pub fn deploy_builder(provider: P) -> alloy_contract::RawCallBuilder<P, N> {
2845 alloy_contract::RawCallBuilder::new_raw_deploy(
2846 provider,
2847 ::core::clone::Clone::clone(&BYTECODE),
2848 )
2849 }
2850 #[inline]
2852 pub const fn address(&self) -> &alloy_sol_types::private::Address {
2853 &self.address
2854 }
2855 #[inline]
2857 pub fn set_address(&mut self, address: alloy_sol_types::private::Address) {
2858 self.address = address;
2859 }
2860 pub fn at(mut self, address: alloy_sol_types::private::Address) -> Self {
2862 self.set_address(address);
2863 self
2864 }
2865 #[inline]
2867 pub const fn provider(&self) -> &P {
2868 &self.provider
2869 }
2870 }
2871 impl<P: ::core::clone::Clone, N> MockERC20Instance<&P, N> {
2872 #[inline]
2874 pub fn with_cloned_provider(self) -> MockERC20Instance<P, N> {
2875 MockERC20Instance {
2876 address: self.address,
2877 provider: ::core::clone::Clone::clone(&self.provider),
2878 _network: ::core::marker::PhantomData,
2879 }
2880 }
2881 }
2882 #[automatically_derived]
2884 impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
2885 MockERC20Instance<P, N>
2886 {
2887 pub fn call_builder<C: alloy_sol_types::SolCall>(
2892 &self,
2893 call: &C,
2894 ) -> alloy_contract::SolCallBuilder<&P, C, N> {
2895 alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call)
2896 }
2897 pub fn allowance(
2899 &self,
2900 owner: alloy::sol_types::private::Address,
2901 spender: alloy::sol_types::private::Address,
2902 ) -> alloy_contract::SolCallBuilder<&P, allowanceCall, N> {
2903 self.call_builder(&allowanceCall { owner, spender })
2904 }
2905 pub fn approve(
2907 &self,
2908 spender: alloy::sol_types::private::Address,
2909 amount: alloy::sol_types::private::primitives::aliases::U256,
2910 ) -> alloy_contract::SolCallBuilder<&P, approveCall, N> {
2911 self.call_builder(&approveCall { spender, amount })
2912 }
2913 pub fn balanceOf(
2915 &self,
2916 account: alloy::sol_types::private::Address,
2917 ) -> alloy_contract::SolCallBuilder<&P, balanceOfCall, N> {
2918 self.call_builder(&balanceOfCall { account })
2919 }
2920 pub fn decimals(&self) -> alloy_contract::SolCallBuilder<&P, decimalsCall, N> {
2922 self.call_builder(&decimalsCall)
2923 }
2924 pub fn decreaseAllowance(
2926 &self,
2927 spender: alloy::sol_types::private::Address,
2928 subtractedValue: alloy::sol_types::private::primitives::aliases::U256,
2929 ) -> alloy_contract::SolCallBuilder<&P, decreaseAllowanceCall, N> {
2930 self.call_builder(&decreaseAllowanceCall {
2931 spender,
2932 subtractedValue,
2933 })
2934 }
2935 pub fn increaseAllowance(
2937 &self,
2938 spender: alloy::sol_types::private::Address,
2939 addedValue: alloy::sol_types::private::primitives::aliases::U256,
2940 ) -> alloy_contract::SolCallBuilder<&P, increaseAllowanceCall, N> {
2941 self.call_builder(&increaseAllowanceCall {
2942 spender,
2943 addedValue,
2944 })
2945 }
2946 pub fn mint(
2948 &self,
2949 account: alloy::sol_types::private::Address,
2950 amount: alloy::sol_types::private::primitives::aliases::U256,
2951 ) -> alloy_contract::SolCallBuilder<&P, mintCall, N> {
2952 self.call_builder(&mintCall { account, amount })
2953 }
2954 pub fn name(&self) -> alloy_contract::SolCallBuilder<&P, nameCall, N> {
2956 self.call_builder(&nameCall)
2957 }
2958 pub fn symbol(&self) -> alloy_contract::SolCallBuilder<&P, symbolCall, N> {
2960 self.call_builder(&symbolCall)
2961 }
2962 pub fn totalSupply(&self) -> alloy_contract::SolCallBuilder<&P, totalSupplyCall, N> {
2964 self.call_builder(&totalSupplyCall)
2965 }
2966 pub fn transfer(
2968 &self,
2969 to: alloy::sol_types::private::Address,
2970 amount: alloy::sol_types::private::primitives::aliases::U256,
2971 ) -> alloy_contract::SolCallBuilder<&P, transferCall, N> {
2972 self.call_builder(&transferCall { to, amount })
2973 }
2974 pub fn transferFrom(
2976 &self,
2977 from: alloy::sol_types::private::Address,
2978 to: alloy::sol_types::private::Address,
2979 amount: alloy::sol_types::private::primitives::aliases::U256,
2980 ) -> alloy_contract::SolCallBuilder<&P, transferFromCall, N> {
2981 self.call_builder(&transferFromCall { from, to, amount })
2982 }
2983 }
2984 #[automatically_derived]
2986 impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
2987 MockERC20Instance<P, N>
2988 {
2989 pub fn event_filter<E: alloy_sol_types::SolEvent>(
2994 &self,
2995 ) -> alloy_contract::Event<&P, E, N> {
2996 alloy_contract::Event::new_sol(&self.provider, &self.address)
2997 }
2998 pub fn Approval_filter(&self) -> alloy_contract::Event<&P, Approval, N> {
3000 self.event_filter::<Approval>()
3001 }
3002 pub fn Transfer_filter(&self) -> alloy_contract::Event<&P, Transfer, N> {
3004 self.event_filter::<Transfer>()
3005 }
3006 }
3007}