diff --git a/.tool-versions b/.tool-versions index 045dc3e..cca41ae 100644 --- a/.tool-versions +++ b/.tool-versions @@ -1 +1 @@ -scarb 2.7.0 +scarb 2.7.1 diff --git a/Cargo.lock b/Cargo.lock index 3384baf..beb04b2 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -147,6 +147,134 @@ version = "1.7.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "69f7f8c3906b62b754cd5326047894316021dcfe5a194c8ea52bdd94934a3457" +[[package]] +name = "ark-ec" +version = "0.4.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "defd9a439d56ac24968cca0571f598a61bc8c55f71d50a89cda591cb750670ba" +dependencies = [ + "ark-ff", + "ark-poly", + "ark-serialize", + "ark-std", + "derivative", + "hashbrown 0.13.2", + "itertools 0.10.5", + "num-traits 0.2.19", + "zeroize", +] + +[[package]] +name = "ark-ff" +version = "0.4.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ec847af850f44ad29048935519032c33da8aa03340876d351dfab5660d2966ba" +dependencies = [ + "ark-ff-asm", + "ark-ff-macros", + "ark-serialize", + "ark-std", + "derivative", + "digest", + "itertools 0.10.5", + "num-bigint", + "num-traits 0.2.19", + "paste", + "rustc_version", + "zeroize", +] + +[[package]] +name = "ark-ff-asm" +version = "0.4.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3ed4aa4fe255d0bc6d79373f7e31d2ea147bcf486cba1be5ba7ea85abdb92348" +dependencies = [ + "quote", + "syn 1.0.109", +] + +[[package]] +name = "ark-ff-macros" +version = "0.4.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7abe79b0e4288889c4574159ab790824d0033b9fdcb2a112a3182fac2e514565" +dependencies = [ + "num-bigint", + "num-traits 0.2.19", + "proc-macro2", + "quote", + "syn 1.0.109", +] + +[[package]] +name = "ark-poly" +version = "0.4.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d320bfc44ee185d899ccbadfa8bc31aab923ce1558716e1997a1e74057fe86bf" +dependencies = [ + "ark-ff", + "ark-serialize", + "ark-std", + "derivative", + "hashbrown 0.13.2", +] + +[[package]] +name = "ark-secp256k1" +version = "0.4.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4c02e954eaeb4ddb29613fee20840c2bbc85ca4396d53e33837e11905363c5f2" +dependencies = [ + "ark-ec", + "ark-ff", + "ark-std", +] + +[[package]] +name = "ark-secp256r1" +version = "0.4.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3975a01b0a6e3eae0f72ec7ca8598a6620fc72fa5981f6f5cca33b7cd788f633" +dependencies = [ + "ark-ec", + "ark-ff", + "ark-std", +] + +[[package]] +name = "ark-serialize" +version = "0.4.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "adb7b85a02b83d2f22f89bd5cac66c9c89474240cb6207cb1efc16d098e822a5" +dependencies = [ + "ark-serialize-derive", + "ark-std", + "digest", + "num-bigint", +] + +[[package]] +name = "ark-serialize-derive" +version = "0.4.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ae3281bc6d0fd7e549af32b52511e1302185bd688fd3359fa36423346ff682ea" +dependencies = [ + "proc-macro2", + "quote", + "syn 1.0.109", +] + +[[package]] +name = "ark-std" +version = "0.4.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "94893f1e0c6eeab764ade8dc4c0db24caf4fe7cbbaafc0eba0a9030f447b5185" +dependencies = [ + "num-traits 0.2.19", + "rand", +] + [[package]] name = "arrayvec" version = "0.7.6" @@ -162,6 +290,21 @@ dependencies = [ "term", ] +[[package]] +name = "assert_fs" +version = "1.1.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7efdb1fdb47602827a342857666feb372712cbc64b414172bd6b167a02927674" +dependencies = [ + "anstyle", + "doc-comment", + "globwalk", + "predicates", + "predicates-core", + "predicates-tree", + "tempfile", +] + [[package]] name = "assert_matches" version = "1.5.0" @@ -243,6 +386,21 @@ version = "0.22.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "72b3254f16251a8381aa12e40e3c4d2f0199f8c6508fbecb9d91f575e0fbb8c6" +[[package]] +name = "base64ct" +version = "1.6.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8c3c1a368f70d6cf7302d78f8f7093da241fb8e8807c05cc9e51a125895a6d5b" + +[[package]] +name = "bincode" +version = "2.0.0-rc.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f11ea1a0346b94ef188834a65c068a03aec181c94896d481d7a0a40d85b0ce95" +dependencies = [ + "serde", +] + [[package]] name = "bit-set" version = "0.5.3" @@ -353,6 +511,27 @@ version = "1.3.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "a3e368af43e418a04d52505cf3dbc23dda4e3407ae2fa99fd0e4f308ce546acc" +[[package]] +name = "bzip2" +version = "0.4.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "bdb116a6ef3f6c3698828873ad02c3014b3c85cadb88496095628e3ef1e347f8" +dependencies = [ + "bzip2-sys", + "libc", +] + +[[package]] +name = "bzip2-sys" +version = "0.1.11+1.0.8" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "736a955f3fa7875102d57c82b8cac37ec45224a07fd32d58f9f7a186b6cd4cdc" +dependencies = [ + "cc", + "libc", + "pkg-config", +] + [[package]] name = "cainome" version = "0.2.3" @@ -444,7 +623,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "e4425280959f189d8a5ebf1f5363c10663bc9f843a4819253e6be87d183b583e" dependencies = [ "cairo-lang-utils", - "indoc", + "indoc 2.0.5", "num-bigint", "num-traits 0.2.19", "parity-scale-codec", @@ -469,7 +648,7 @@ dependencies = [ "cairo-lang-sierra-generator", "cairo-lang-syntax", "cairo-lang-utils", - "indoc", + "indoc 2.0.5", "salsa", "semver", "smol_str", @@ -645,7 +824,7 @@ dependencies = [ "cairo-lang-syntax", "cairo-lang-utils", "indent", - "indoc", + "indoc 2.0.5", "itertools 0.12.1", "salsa", "smol_str", @@ -676,6 +855,37 @@ dependencies = [ "toml", ] +[[package]] +name = "cairo-lang-runner" +version = "2.7.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "18df87ee986ca0e02e2ea63483875b791602809873c908bbf7b3d592e3833a3a" +dependencies = [ + "ark-ff", + "ark-secp256k1", + "ark-secp256r1", + "cairo-lang-casm", + "cairo-lang-lowering", + "cairo-lang-sierra", + "cairo-lang-sierra-ap-change", + "cairo-lang-sierra-generator", + "cairo-lang-sierra-to-casm", + "cairo-lang-sierra-type-size", + "cairo-lang-starknet", + "cairo-lang-utils", + "cairo-vm", + "itertools 0.12.1", + "keccak", + "num-bigint", + "num-integer", + "num-traits 0.2.19", + "rand", + "sha2", + "smol_str", + "starknet-types-core", + "thiserror", +] + [[package]] name = "cairo-lang-semantic" version = "2.7.1" @@ -693,7 +903,7 @@ dependencies = [ "cairo-lang-test-utils", "cairo-lang-utils", "id-arena", - "indoc", + "indoc 2.0.5", "itertools 0.12.1", "num-bigint", "num-traits 0.2.19", @@ -801,7 +1011,7 @@ dependencies = [ "cairo-lang-sierra-gas", "cairo-lang-sierra-type-size", "cairo-lang-utils", - "indoc", + "indoc 2.0.5", "itertools 0.12.1", "num-bigint", "num-traits 0.2.19", @@ -840,7 +1050,7 @@ dependencies = [ "cairo-lang-utils", "const_format", "indent", - "indoc", + "indoc 2.0.5", "itertools 0.12.1", "once_cell", "serde", @@ -920,7 +1130,7 @@ dependencies = [ "cairo-lang-starknet-classes", "cairo-lang-syntax", "cairo-lang-utils", - "indoc", + "indoc 2.0.5", "itertools 0.12.1", "num-bigint", "num-traits 0.2.19", @@ -928,6 +1138,29 @@ dependencies = [ "starknet-types-core", ] +[[package]] +name = "cairo-lang-test-runner" +version = "2.7.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e56ba72ae465038a842195253cd497253cacb476b2d918a917a22fd6e397b205" +dependencies = [ + "anyhow", + "cairo-lang-compiler", + "cairo-lang-filesystem", + "cairo-lang-runner", + "cairo-lang-sierra", + "cairo-lang-sierra-generator", + "cairo-lang-sierra-to-casm", + "cairo-lang-starknet", + "cairo-lang-test-plugin", + "cairo-lang-utils", + "colored", + "itertools 0.12.1", + "num-traits 0.2.19", + "rayon", + "starknet-types-core", +] + [[package]] name = "cairo-lang-test-utils" version = "2.7.1" @@ -959,6 +1192,37 @@ dependencies = [ "time", ] +[[package]] +name = "cairo-vm" +version = "1.0.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "58363ad8065ed891e3b14a8191b707677c7c7cb5b9d10030822506786d8d8108" +dependencies = [ + "anyhow", + "bincode", + "bitvec", + "generic-array", + "hashbrown 0.14.5", + "hex", + "keccak", + "lazy_static", + "nom", + "num-bigint", + "num-integer", + "num-prime", + "num-traits 0.2.19", + "rand", + "rust_decimal", + "serde", + "serde_json", + "sha2", + "sha3", + "starknet-crypto 0.6.2", + "starknet-types-core", + "thiserror-no-std", + "zip", +] + [[package]] name = "camino" version = "1.1.9" @@ -1041,6 +1305,16 @@ dependencies = [ "clap_derive", ] +[[package]] +name = "clap-verbosity-flag" +version = "2.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e099138e1807662ff75e2cebe4ae2287add879245574489f9b1588eb5e5564ed" +dependencies = [ + "clap", + "log", +] + [[package]] name = "clap_builder" version = "4.5.18" @@ -1141,6 +1415,12 @@ dependencies = [ "unicode-xid", ] +[[package]] +name = "constant_time_eq" +version = "0.1.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "245097e9a4535ee1e3e3931fcfcd55a796a44c643e8596ff6566d68f09b87bbc" + [[package]] name = "convert_case" version = "0.6.0" @@ -1332,6 +1612,36 @@ version = "2.6.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "e8566979429cf69b49a5c740c60791108e86440e8be149bbea4fe54d2c32d6e2" +[[package]] +name = "demo-compiler" +version = "1.0.0-rc.1" +dependencies = [ + "anyhow", + "cairo-lang-compiler", + "cairo-lang-defs", + "cairo-lang-filesystem", + "cairo-lang-plugins", + "cairo-lang-project", + "cairo-lang-sierra", + "cairo-lang-sierra-to-casm", + "cairo-lang-starknet", + "cairo-lang-test-plugin", + "cairo-lang-test-runner", + "cairo-lang-utils", + "camino", + "clap", + "clap-verbosity-flag", + "clap_complete", + "dojo-compiler", + "notify", + "scarb", + "scarb-ui", + "smol_str", + "tracing", + "tracing-log 0.1.4", + "tracing-subscriber", +] + [[package]] name = "deno_task_shell" version = "0.18.0" @@ -1420,6 +1730,12 @@ version = "0.1.13" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "56254986775e3233ffa9c4d7d3faaf6d36a2c09d30b20687e9f88bc8bafc16c8" +[[package]] +name = "difflib" +version = "0.4.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6184e33543162437515c2e2b48714794e37845ec9851711914eec9d308f6ebe8" + [[package]] name = "diffy" version = "0.3.0" @@ -1482,6 +1798,12 @@ dependencies = [ "winapi", ] +[[package]] +name = "doc-comment" +version = "0.3.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "fea41bba32d969b513997752735605054bc0dfa92b4c56bf1189f2e174be7a10" + [[package]] name = "dojo-abigen" version = "1.0.0-rc.1" @@ -1497,6 +1819,51 @@ dependencies = [ "serde_json", ] +[[package]] +name = "dojo-compiler" +version = "1.0.0-rc.1" +dependencies = [ + "anyhow", + "assert_fs", + "cairo-lang-compiler", + "cairo-lang-debug", + "cairo-lang-defs", + "cairo-lang-diagnostics", + "cairo-lang-filesystem", + "cairo-lang-formatter", + "cairo-lang-parser", + "cairo-lang-plugins", + "cairo-lang-project", + "cairo-lang-semantic", + "cairo-lang-sierra-generator", + "cairo-lang-starknet", + "cairo-lang-starknet-classes", + "cairo-lang-syntax", + "cairo-lang-test-plugin", + "cairo-lang-test-utils", + "cairo-lang-utils", + "camino", + "convert_case", + "dojo-types", + "indoc 1.0.9", + "itertools 0.12.1", + "once_cell", + "regex", + "salsa", + "scarb", + "scarb-ui", + "semver", + "serde", + "serde_json", + "smol_str", + "starknet", + "tempfile", + "test-log", + "toml", + "tracing", + "url", +] + [[package]] name = "dojo-contracts" version = "1.0.0-rc.1" @@ -1505,14 +1872,17 @@ version = "1.0.0-rc.1" name = "dojo-types" version = "1.0.0-rc.1" dependencies = [ + "anyhow", "cainome", "crypto-bigint", "hex", "itertools 0.12.1", "num-traits 0.2.19", + "regex", "serde", "serde_json", "starknet", + "starknet-crypto 0.7.2", "strum", "strum_macros", "thiserror", @@ -1758,6 +2128,15 @@ version = "1.3.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "42703706b716c37f96a77aea830392ad231f44c9e9a67872fa5548707e11b11c" +[[package]] +name = "fsevent-sys" +version = "4.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "76ee7a02da4d231650c7cea31349b889be2f45ddb3ef3032d2ec8185f6313fd2" +dependencies = [ + "libc", +] + [[package]] name = "funty" version = "2.0.0" @@ -2726,6 +3105,17 @@ dependencies = [ "regex-syntax 0.8.4", ] +[[package]] +name = "globwalk" +version = "0.9.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0bf760ebf69878d9fd8f110c89703d90ce35095324d1f1edcb595c63945ee757" +dependencies = [ + "bitflags 2.6.0", + "ignore", + "walkdir", +] + [[package]] name = "good_lp" version = "1.8.1" @@ -2761,6 +3151,15 @@ version = "0.12.3" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "8a9ee70c43aaf417c914396645a0fa852624801b24ebb7ae78fe8272889ac888" +[[package]] +name = "hashbrown" +version = "0.13.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "43a3c133739dddd0d2990f9a4bdf8eb4b21ef50e4851ca85ab661199821d510e" +dependencies = [ + "ahash", +] + [[package]] name = "hashbrown" version = "0.14.5" @@ -3089,12 +3488,38 @@ dependencies = [ "unicode-width", ] +[[package]] +name = "indoc" +version = "1.0.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "bfa799dd5ed20a7e349f3b4639aa80d74549c81716d9ec4f994c9b5815598306" + [[package]] name = "indoc" version = "2.0.5" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "b248f5224d1d606005e02c97f5aa4e88eeb230488bcc03bc9ca4d7991399f2b5" +[[package]] +name = "inotify" +version = "0.9.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f8069d3ec154eb856955c1c0fbffefbf5f3c40a104ec912d4797314c1801abff" +dependencies = [ + "bitflags 1.3.2", + "inotify-sys", + "libc", +] + +[[package]] +name = "inotify-sys" +version = "0.1.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e05c02b5e89bff3b946cedeca278abc628fe811e604f027c45a8aa3cf793d0eb" +dependencies = [ + "libc", +] + [[package]] name = "inout" version = "0.1.3" @@ -3135,6 +3560,15 @@ version = "1.70.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "7943c866cc5cd64cbc25b2e01621d07fa8eb2a1a23160ee81ce38704e97b8ecf" +[[package]] +name = "itertools" +version = "0.10.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b0fd2260e829bddf4cb6ea802289de2f86d6a7a690192fbe91b3f46e0f2c8473" +dependencies = [ + "either", +] + [[package]] name = "itertools" version = "0.11.0" @@ -3194,21 +3628,41 @@ dependencies = [ ] [[package]] -name = "js-sys" -version = "0.3.70" +name = "js-sys" +version = "0.3.70" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1868808506b929d7b0cfa8f75951347aa71bb21144b7791bae35d9bccfcfe37a" +dependencies = [ + "wasm-bindgen", +] + +[[package]] +name = "keccak" +version = "0.1.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ecc2af9a1119c51f12a14607e783cb977bde58bc069ff0c3da1095e635d70654" +dependencies = [ + "cpufeatures", +] + +[[package]] +name = "kqueue" +version = "1.0.8" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "1868808506b929d7b0cfa8f75951347aa71bb21144b7791bae35d9bccfcfe37a" +checksum = "7447f1ca1b7b563588a205fe93dea8df60fd981423a768bc1c0ded35ed147d0c" dependencies = [ - "wasm-bindgen", + "kqueue-sys", + "libc", ] [[package]] -name = "keccak" -version = "0.1.5" +name = "kqueue-sys" +version = "1.0.4" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ecc2af9a1119c51f12a14607e783cb977bde58bc069ff0c3da1095e635d70654" +checksum = "ed9625ffda8729b85e45cf04090035ac368927b8cebc34898e7c120f52e4838b" dependencies = [ - "cpufeatures", + "bitflags 1.3.2", + "libc", ] [[package]] @@ -3278,6 +3732,9 @@ name = "lazy_static" version = "1.5.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "bbd2bcb4c963f2ddae06a2efc7e9f3591312473c50c6685e1f298068316e66fe" +dependencies = [ + "spin", +] [[package]] name = "libc" @@ -3348,6 +3805,15 @@ version = "0.4.22" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "a7a70ba024b9dc04c27ea2f0c0548feb474ec5c54bba33a7f72f873a39d07b24" +[[package]] +name = "lru" +version = "0.12.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "37ee39891760e7d94734f6f63fedc29a2e4a152f836120753a72503f09fcf904" +dependencies = [ + "hashbrown 0.14.5", +] + [[package]] name = "matchers" version = "0.1.0" @@ -3397,6 +3863,12 @@ dependencies = [ "sprs", ] +[[package]] +name = "minimal-lexical" +version = "0.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "68354c5c6bd36d73ff3feceb05efa59b6acb7626617f4962be322a825e61f79a" + [[package]] name = "miniz_oxide" version = "0.8.0" @@ -3406,6 +3878,18 @@ dependencies = [ "adler2", ] +[[package]] +name = "mio" +version = "0.8.11" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a4a650543ca06a924e8b371db273b2756685faae30f8487da1b56505a8f78b0c" +dependencies = [ + "libc", + "log", + "wasi", + "windows-sys 0.48.0", +] + [[package]] name = "mio" version = "1.0.2" @@ -3460,6 +3944,35 @@ version = "1.0.6" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "650eef8c711430f1a879fdd01d4745a7deea475becfb90269c06775983bbf086" +[[package]] +name = "nom" +version = "7.1.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d273983c5a657a70a3e8f2a01329822f3b8c8172b73826411a55751e404a0a4a" +dependencies = [ + "memchr", + "minimal-lexical", +] + +[[package]] +name = "notify" +version = "6.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6205bd8bb1e454ad2e27422015fb5e4f2bcc7e08fa8f27058670d208324a4d2d" +dependencies = [ + "bitflags 2.6.0", + "crossbeam-channel", + "filetime", + "fsevent-sys", + "inotify", + "kqueue", + "libc", + "log", + "mio 0.8.11", + "walkdir", + "windows-sys 0.48.0", +] + [[package]] name = "nu-ansi-term" version = "0.46.0" @@ -3478,6 +3991,7 @@ checksum = "a5e44f723f1133c9deac646763579fdb3ac745e418f2a7af9cd0c431da1f20b9" dependencies = [ "num-integer", "num-traits 0.2.19", + "rand", "serde", ] @@ -3506,6 +4020,33 @@ dependencies = [ "num-traits 0.2.19", ] +[[package]] +name = "num-modular" +version = "0.5.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "64a5fe11d4135c3bcdf3a95b18b194afa9608a5f6ff034f5d857bc9a27fb0119" +dependencies = [ + "num-bigint", + "num-integer", + "num-traits 0.2.19", +] + +[[package]] +name = "num-prime" +version = "0.4.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e238432a7881ec7164503ccc516c014bf009be7984cde1ba56837862543bdec3" +dependencies = [ + "bitvec", + "either", + "lru", + "num-bigint", + "num-integer", + "num-modular", + "num-traits 0.2.19", + "rand", +] + [[package]] name = "num-traits" version = "0.1.43" @@ -3709,6 +4250,23 @@ dependencies = [ "windows-targets 0.52.6", ] +[[package]] +name = "password-hash" +version = "0.4.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7676374caaee8a325c9e7a2ae557f216c5563a171d6997b0ef8a65af35147700" +dependencies = [ + "base64ct", + "rand_core", + "subtle", +] + +[[package]] +name = "paste" +version = "1.0.15" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "57c0d7b74b563b49d38dae00a0c37d4d6de9b432382b2892f0574ddcae73fd0a" + [[package]] name = "path-clean" version = "1.0.1" @@ -3740,6 +4298,9 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "83a0692ec44e4cf1ef28ca317f14f8f07da2d95ec3fa01f86e4467b725e60917" dependencies = [ "digest", + "hmac", + "password-hash", + "sha2", ] [[package]] @@ -3818,6 +4379,33 @@ version = "0.1.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "925383efa346730478fb4838dbe9137d2a47675ad789c546d150a6e1dd4ab31c" +[[package]] +name = "predicates" +version = "3.1.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7e9086cc7640c29a356d1a29fd134380bee9d8f79a17410aa76e7ad295f42c97" +dependencies = [ + "anstyle", + "difflib", + "predicates-core", +] + +[[package]] +name = "predicates-core" +version = "1.0.8" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ae8177bee8e75d6846599c6b9ff679ed51e882816914eec639944d7c9aa11931" + +[[package]] +name = "predicates-tree" +version = "1.0.11" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "41b740d195ed3166cd147c8047ec98db0e22ec019eb8eeb76d343b795304fb13" +dependencies = [ + "predicates-core", + "termtree", +] + [[package]] name = "pretty_assertions" version = "1.4.1" @@ -3964,6 +4552,26 @@ version = "0.2.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "60a357793950651c4ed0f3f52338f53b2f809f32d83a07f72909fa13e4c6c1e3" +[[package]] +name = "rayon" +version = "1.10.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b418a60154510ca1a002a752ca9714984e21e4241e804d32555251faf8b78ffa" +dependencies = [ + "either", + "rayon-core", +] + +[[package]] +name = "rayon-core" +version = "1.12.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1465873a3dfdaa8ae7cb14b4383657caab0b3e8a0aa9ae8e04b044854c8dfce2" +dependencies = [ + "crossbeam-deque", + "crossbeam-utils", +] + [[package]] name = "redb" version = "2.1.3" @@ -4135,6 +4743,16 @@ dependencies = [ "rustc-hex", ] +[[package]] +name = "rust_decimal" +version = "1.36.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b082d80e3e3cc52b2ed634388d436fe1f4de6af5786cc2de9ba9737527bdf555" +dependencies = [ + "arrayvec", + "num-traits 0.2.19", +] + [[package]] name = "rustc-demangle" version = "0.1.24" @@ -4153,6 +4771,15 @@ version = "2.1.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "3e75f6a532d0fd9f7f13144f392b6ad56a32696bfcd9c78f797f16bbb6f072d6" +[[package]] +name = "rustc_version" +version = "0.4.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cfcb3a22ef46e85b45de6ee7e79d063319ebb6594faafcf1c225ea92ab6e9b92" +dependencies = [ + "semver", +] + [[package]] name = "rustix" version = "0.38.37" @@ -4310,7 +4937,7 @@ dependencies = [ "glob", "ignore", "include_dir", - "indoc", + "indoc 2.0.5", "itertools 0.12.1", "libloading", "once_cell", @@ -4345,7 +4972,7 @@ dependencies = [ "which", "windows-sys 0.59.0", "zip", - "zstd", + "zstd 0.13.2", ] [[package]] @@ -4645,6 +5272,17 @@ dependencies = [ "serde", ] +[[package]] +name = "sha1" +version = "0.10.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e3bf829a2d51ab4a5ddf1352d8470c140cadc8301b2ae1789db023f01cedd6ba" +dependencies = [ + "cfg-if", + "cpufeatures", + "digest", +] + [[package]] name = "sha1_smol" version = "1.0.1" @@ -4778,7 +5416,7 @@ dependencies = [ "starknet-accounts", "starknet-contract", "starknet-core", - "starknet-crypto", + "starknet-crypto 0.7.2", "starknet-macros", "starknet-providers", "starknet-signers", @@ -4793,7 +5431,7 @@ dependencies = [ "async-trait", "auto_impl", "starknet-core", - "starknet-crypto", + "starknet-crypto 0.7.2", "starknet-providers", "starknet-signers", "thiserror", @@ -4829,10 +5467,30 @@ dependencies = [ "serde_json_pythonic", "serde_with", "sha3", - "starknet-crypto", + "starknet-crypto 0.7.2", "starknet-types-core", ] +[[package]] +name = "starknet-crypto" +version = "0.6.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2e2c30c01e8eb0fc913c4ee3cf676389fffc1d1182bfe5bb9670e4e72e968064" +dependencies = [ + "crypto-bigint", + "hex", + "hmac", + "num-bigint", + "num-integer", + "num-traits 0.2.19", + "rfc6979", + "sha2", + "starknet-crypto-codegen", + "starknet-curve 0.4.2", + "starknet-ff", + "zeroize", +] + [[package]] name = "starknet-crypto" version = "0.7.2" @@ -4847,11 +5505,31 @@ dependencies = [ "num-traits 0.2.19", "rfc6979", "sha2", - "starknet-curve", + "starknet-curve 0.5.1", "starknet-types-core", "zeroize", ] +[[package]] +name = "starknet-crypto-codegen" +version = "0.3.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "bbc159a1934c7be9761c237333a57febe060ace2bc9e3b337a59a37af206d19f" +dependencies = [ + "starknet-curve 0.4.2", + "starknet-ff", + "syn 2.0.77", +] + +[[package]] +name = "starknet-curve" +version = "0.4.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d1c383518bb312751e4be80f53e8644034aa99a0afb29d7ac41b89a997db875b" +dependencies = [ + "starknet-ff", +] + [[package]] name = "starknet-curve" version = "0.5.1" @@ -4861,6 +5539,18 @@ dependencies = [ "starknet-types-core", ] +[[package]] +name = "starknet-ff" +version = "0.3.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7abf1b44ec5b18d87c1ae5f54590ca9d0699ef4dd5b2ffa66fc97f24613ec585" +dependencies = [ + "ark-ff", + "crypto-bigint", + "getrandom", + "hex", +] + [[package]] name = "starknet-macros" version = "0.2.1" @@ -4905,7 +5595,7 @@ dependencies = [ "getrandom", "rand", "starknet-core", - "starknet-crypto", + "starknet-crypto 0.7.2", "thiserror", ] @@ -5064,6 +5754,34 @@ dependencies = [ "winapi", ] +[[package]] +name = "termtree" +version = "0.4.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3369f5ac52d5eb6ab48c6b4ffdc8efbcad6b89c765749064ba298f2c68a16a76" + +[[package]] +name = "test-log" +version = "0.2.16" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3dffced63c2b5c7be278154d76b479f9f9920ed34e7574201407f0b14e2bbb93" +dependencies = [ + "env_logger", + "test-log-macros", + "tracing-subscriber", +] + +[[package]] +name = "test-log-macros" +version = "0.2.16" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5999e24eaa32083191ba4e425deb75cdf25efefabe5aaccb7446dd0d4122a3f5" +dependencies = [ + "proc-macro2", + "quote", + "syn 2.0.77", +] + [[package]] name = "thiserror" version = "1.0.64" @@ -5084,6 +5802,26 @@ dependencies = [ "syn 2.0.77", ] +[[package]] +name = "thiserror-impl-no-std" +version = "2.0.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "58e6318948b519ba6dc2b442a6d0b904ebfb8d411a3ad3e07843615a72249758" +dependencies = [ + "proc-macro2", + "quote", + "syn 1.0.109", +] + +[[package]] +name = "thiserror-no-std" +version = "2.0.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a3ad459d94dd517257cc96add8a43190ee620011bb6e6cdc82dafd97dfafafea" +dependencies = [ + "thiserror-impl-no-std", +] + [[package]] name = "thread_local" version = "1.1.8" @@ -5160,7 +5898,7 @@ dependencies = [ "backtrace", "bytes", "libc", - "mio", + "mio 1.0.2", "pin-project-lite", "signal-hook-registry", "socket2", @@ -5284,6 +6022,17 @@ dependencies = [ "valuable", ] +[[package]] +name = "tracing-log" +version = "0.1.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f751112709b4e791d8ce53e32c4ed2d353565a795ce84da2285393f41557bdf2" +dependencies = [ + "log", + "once_cell", + "tracing-core", +] + [[package]] name = "tracing-log" version = "0.2.0" @@ -5322,7 +6071,7 @@ dependencies = [ "thread_local", "tracing", "tracing-core", - "tracing-log", + "tracing-log 0.2.0", "tracing-serde", ] @@ -5905,6 +6654,20 @@ name = "zeroize" version = "1.8.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "ced3678a2879b30306d323f4542626697a464a97c0a07c9aebf7ebca65cd4dde" +dependencies = [ + "zeroize_derive", +] + +[[package]] +name = "zeroize_derive" +version = "1.4.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ce36e65b0d2999d2aafac989fb249189a141aee1f53c612c1f37d72631959f69" +dependencies = [ + "proc-macro2", + "quote", + "syn 2.0.77", +] [[package]] name = "zip" @@ -5912,10 +6675,27 @@ version = "0.6.6" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "760394e246e4c28189f19d488c058bf16f564016aefac5d32bb1f3b51d5e9261" dependencies = [ + "aes", "byteorder", + "bzip2", + "constant_time_eq", "crc32fast", "crossbeam-utils", "flate2", + "hmac", + "pbkdf2", + "sha1", + "time", + "zstd 0.11.2+zstd.1.5.2", +] + +[[package]] +name = "zstd" +version = "0.11.2+zstd.1.5.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "20cc960326ece64f010d2d2107537f26dc589a6573a316bd5b1dba685fa5fde4" +dependencies = [ + "zstd-safe 5.0.2+zstd.1.5.2", ] [[package]] @@ -5924,7 +6704,17 @@ version = "0.13.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "fcf2b778a664581e31e389454a7072dab1647606d44f7feea22cd5abb9c9f3f9" dependencies = [ - "zstd-safe", + "zstd-safe 7.2.1", +] + +[[package]] +name = "zstd-safe" +version = "5.0.2+zstd.1.5.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1d2a5585e04f9eea4b2a3d1eca508c4dee9592a89ef6f450c11719da0726f4db" +dependencies = [ + "libc", + "zstd-sys", ] [[package]] diff --git a/Cargo.toml b/Cargo.toml index 3b0cc94..b9d63cd 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -2,8 +2,10 @@ resolver = "2" members = [ - "crates/abigen", + "bins/abigen", + "bins/demo-compiler", "crates/contracts", + "crates/compiler", "crates/types", ] @@ -21,9 +23,9 @@ inherits = "release" lto = "fat" [workspace.dependencies] -dojo-abigen = { path = "crates/abigen" } dojo-contracts = { path = "crates/contracts" } dojo-types = { path = "crates/types" } +dojo-compiler = { path = "crates/compiler" } anyhow = "1.0.80" assert_fs = "1.1" @@ -110,6 +112,7 @@ toml = "0.8" tower = "0.4.13" tower-http = "0.4.4" tracing = "0.1.34" +tracing-log = "0.1.3" tracing-subscriber = { version = "0.3.16", features = [ "env-filter", "json" ] } url = { version = "2.4.0", features = [ "serde" ] } walkdir = "2.5.0" diff --git a/README.md b/README.md new file mode 100644 index 0000000..7ea759e --- /dev/null +++ b/README.md @@ -0,0 +1,60 @@ +# Dojo core library. + +This repository contains the contracts and associated tooling for Dojo. + + +It includes the following crates: + +* `contracts`: the core contracts and logic for Dojo written in Cairo. +* `types`: the Rust types related to the core contracts. +* `compiler`: the Cairo compiler plugin for Dojo that generates the artifacts for the contracts and associated dojo manifests. + +Some binaries are also included: + +* `abigen`: a program that generates the Rust bindings for the contracts, which are written into the `types` crate. +* `demo-compiler`: a demo compiler that can `build`, `test` and `clean` a Dojo project. + +## Use the demo compiler. + +To not have to work with sozo, the demo compiler can be used to compile the contracts. +The primary goal of the demo compiler is to compile and test the dojo core contracts. + +```bash +cargo run -r -p demo-compiler build --manifest-path crates/contracts/Scarb.toml +cargo run -r -p demo-compiler test --manifest-path crates/contracts/Scarb.toml +cargo run -r -p demo-compiler clean --manifest-path crates/contracts/Scarb.toml +``` + +You can also compiles the examples by using the demo compiler, adjusting the path to the example `Scarb.toml` file. + +## Abigen + +Using [cainome](https://github.com/cartridge-gg/cainome) to generate the bindings from the Cairo ABI, the bindings must be maintained up to date with the contracts. + +/!\ The commands below will work when the compiler will newly generate the artifacts /!\ + +```bash +# Note, use `-r` to run the binary in release mode as Scarb is very slow in debug mode. + +# To generate the bindings. +cargo run -r -p dojo-abigen + +# To check if the bindings are up to date. +cargo run -r -p dojo-abigen -- --check +``` + +## Work in progress + +This repository is currently being built by extracting some parts of the [dojo](https://github.com/dojoengine/dojo) repo. + +Tasks: + +- [ ] Add back the artifacts and manifests generation. +- [ ] Add back all the types including `Ty` for introspection. +- [ ] [PR11](https://github.com/dojoengine/dojo-core/pull/11) to have `Event` as a new resource. +- [ ] [PR12](https://github.com/dojoengine/dojo-core/pull/12) for world events to have keys. +- [ ] Debug `2.8` panic that prevent the compiler from working with this Cairo version. +- [ ] Simplify the plugin by having the expanded code into files instead of plain strings. +- [ ] Add model extensibility (append only). +- [ ] Check if base contract can be removed to instead use a component to inject the world dispatcher. +- [ ] Check the possibility to remove warnings during compilation if the users wants to. diff --git a/crates/abigen/Cargo.toml b/bins/abigen/Cargo.toml similarity index 100% rename from crates/abigen/Cargo.toml rename to bins/abigen/Cargo.toml diff --git a/crates/abigen/src/main.rs b/bins/abigen/src/main.rs similarity index 100% rename from crates/abigen/src/main.rs rename to bins/abigen/src/main.rs diff --git a/bins/demo-compiler/Cargo.toml b/bins/demo-compiler/Cargo.toml new file mode 100644 index 0000000..7cf2356 --- /dev/null +++ b/bins/demo-compiler/Cargo.toml @@ -0,0 +1,30 @@ +[package] +edition.workspace = true +name = "demo-compiler" +version.workspace = true + +[dependencies] +anyhow.workspace = true +cairo-lang-compiler.workspace = true +cairo-lang-defs.workspace = true +cairo-lang-filesystem.workspace = true +cairo-lang-plugins.workspace = true +cairo-lang-project.workspace = true +cairo-lang-sierra.workspace = true +cairo-lang-sierra-to-casm.workspace = true +cairo-lang-starknet.workspace = true +cairo-lang-test-plugin.workspace = true +cairo-lang-test-runner.workspace = true +cairo-lang-utils.workspace = true +camino.workspace = true +clap.workspace = true +clap-verbosity-flag.workspace = true +clap_complete.workspace = true +dojo-compiler.workspace = true +notify = "6.0.1" +scarb.workspace = true +scarb-ui.workspace = true +smol_str.workspace = true +tracing.workspace = true +tracing-log.workspace = true +tracing-subscriber.workspace = true diff --git a/bins/demo-compiler/README.md b/bins/demo-compiler/README.md new file mode 100644 index 0000000..e69de29 diff --git a/bins/demo-compiler/src/args.rs b/bins/demo-compiler/src/args.rs new file mode 100644 index 0000000..12afa58 --- /dev/null +++ b/bins/demo-compiler/src/args.rs @@ -0,0 +1,97 @@ +use anyhow::Result; +use camino::Utf8PathBuf; +use clap::Parser; +use scarb::compiler::Profile; +use scarb_ui::Verbosity; +use smol_str::SmolStr; +use tracing::level_filters::LevelFilter; +use tracing_log::{AsTrace, LogTracer}; +use tracing_subscriber::FmtSubscriber; + +use crate::commands::Commands; + +#[derive(Parser, Debug)] +pub struct CompilerArgs { + /// Override path to a directory containing a Scarb.toml file. + #[arg( + short, + long, + global = true, + help = "Override path to a directory containing a Scarb.toml file." + )] + pub manifest_path: Option, + + /// Specify the profile to use, defaults to `dev`. + #[command(flatten)] + pub profile_spec: ProfileSpec, + + /// Logging verbosity. + #[command(flatten)] + pub verbose: clap_verbosity_flag::Verbosity, + + /// Run without accessing the network for scarb dependencies. + #[arg(short, long, help = "Run without accessing the network.")] + pub offline: bool, + + #[command(subcommand)] + pub command: Commands, +} + +impl CompilerArgs { + pub fn ui_verbosity(&self) -> Verbosity { + let filter = self.verbose.log_level_filter().as_trace(); + if filter >= LevelFilter::WARN { + Verbosity::Verbose + } else if filter > LevelFilter::OFF { + Verbosity::Normal + } else { + Verbosity::Quiet + } + } + + pub fn init_logging(&self) -> Result<(), Box> { + const DEFAULT_LOG_FILTER: &str = "info,hyper=off,scarb=off,salsa=off"; + + LogTracer::init()?; + + let subscriber = FmtSubscriber::builder() + .with_env_filter( + tracing_subscriber::EnvFilter::try_from_default_env() + .unwrap_or_else(|_| tracing_subscriber::EnvFilter::new(DEFAULT_LOG_FILTER)), + ) + .finish(); + + Ok(tracing::subscriber::set_global_default(subscriber)?) + } +} + +/// Profile specifier. +#[derive(Parser, Clone, Debug)] +#[group(multiple = false)] +pub struct ProfileSpec { + #[arg(short = 'P', long, global = true, group = "profiles")] + #[arg(help = "Specify profile to use by name.")] + pub profile: Option, + + #[arg(long, hide_short_help = true, global = true, group = "profiles")] + #[arg(help = "Use release profile.")] + pub release: bool, + + #[arg(long, hide_short_help = true, global = true, group = "profiles")] + #[arg(help = "Use dev profile.")] + pub dev: bool, +} + +impl ProfileSpec { + pub fn determine(&self) -> Result { + Ok(match &self { + Self { release: true, .. } => Profile::RELEASE, + Self { dev: true, .. } => Profile::DEV, + Self { + profile: Some(profile), + .. + } => Profile::new(profile.clone())?, + _ => Profile::default(), + }) + } +} diff --git a/bins/demo-compiler/src/commands/build.rs b/bins/demo-compiler/src/commands/build.rs new file mode 100644 index 0000000..c7a6d14 --- /dev/null +++ b/bins/demo-compiler/src/commands/build.rs @@ -0,0 +1,39 @@ +use anyhow::Result; +use clap::{Args, Parser}; +use dojo_compiler::compiler::DojoCompiler; +use scarb::core::Config; +use scarb_ui::args::{FeaturesSpec, PackagesFilter}; + +#[derive(Debug, Args)] +pub struct BuildArgs { + /// Specify the features to activate. + #[command(flatten)] + pub features: FeaturesSpec, + + /// Specify packages to build. + #[command(flatten)] + pub packages: Option, + + #[arg(long)] + #[arg(help = "Output the Sierra debug information for the compiled contracts.")] + pub output_debug_info: bool, +} + +impl BuildArgs { + pub fn run(self, config: &Config) -> Result<()> { + DojoCompiler::compile_workspace(config, self.packages, self.features) + } +} + +impl Default for BuildArgs { + fn default() -> Self { + // use the clap defaults + let features = FeaturesSpec::parse_from([""]); + + Self { + features, + packages: None, + output_debug_info: false, + } + } +} diff --git a/bins/demo-compiler/src/commands/clean.rs b/bins/demo-compiler/src/commands/clean.rs new file mode 100644 index 0000000..9909161 --- /dev/null +++ b/bins/demo-compiler/src/commands/clean.rs @@ -0,0 +1,94 @@ +use std::fs; + +use anyhow::{Context, Result}; +use camino::Utf8PathBuf; +use clap::Args; +use scarb::core::Config; +use scarb::ops; +use tracing::trace; + +// TODO when porting manifests. +const BASE_DIR: &str = "base"; +const MANIFESTS_DIR: &str = "manifests"; + +#[derive(Debug, Args)] +pub struct CleanArgs { + #[arg(long)] + #[arg( + help = "Removes all the generated files, including scarb artifacts and ALL the \ + manifests files." + )] + pub full: bool, + + #[arg(long)] + #[arg(help = "Clean all profiles.")] + pub all_profiles: bool, +} + +impl CleanArgs { + /// Cleans the manifests and abis files that are generated at build time. + /// + /// # Arguments + /// + /// * `profile_dir` - The directory where the profile files are located. + pub fn clean_manifests(profile_dir: &Utf8PathBuf) -> Result<()> { + trace!(?profile_dir, "Cleaning manifests."); + let dirs = vec![profile_dir.join(BASE_DIR)]; + + for d in dirs { + if d.exists() { + trace!(directory=?d, "Removing directory."); + fs::remove_dir_all(d)?; + } + } + + Ok(()) + } + + pub fn run(self, config: &Config) -> Result<()> { + let ws = scarb::ops::read_workspace(config.manifest_path(), config)?; + trace!(ws=?ws, "Workspace read successfully."); + + let profile_names = if self.all_profiles { + ws.profile_names() + } else { + vec![ws + .current_profile() + .expect("Scarb profile is expected at this point.") + .to_string()] + }; + + for profile_name in profile_names { + // Manifest path is always a file, we can unwrap safely to get the + // parent folder. + let manifest_dir = ws.manifest_path().parent().unwrap().to_path_buf(); + + // By default, this command cleans the build manifests and scarb artifacts. + trace!("Cleaning Scarb artifacts and build manifests."); + + { + // copied from scarb::ops::clean since scarb cleans build file of all the profiles + // we only want to clean build files for specified profile + // + // cleaning build files for all profiles would create inconsistency with the + // manifest files in `manifests` directory + let ws = ops::read_workspace(config.manifest_path(), config)?; + let path = ws.target_dir().path_unchecked().join(&profile_name); + if path.exists() { + fs::remove_dir_all(path).context("failed to clean generated artifacts")?; + } + } + + let profile_dir = manifest_dir.join(MANIFESTS_DIR).join(&profile_name); + + Self::clean_manifests(&profile_dir)?; + + if self.full && profile_dir.exists() { + trace!(?profile_dir, "Removing entire profile directory."); + fs::remove_dir_all(profile_dir)?; + } + } + + Ok(()) + } +} diff --git a/bins/demo-compiler/src/commands/dev.rs b/bins/demo-compiler/src/commands/dev.rs new file mode 100644 index 0000000..39fe805 --- /dev/null +++ b/bins/demo-compiler/src/commands/dev.rs @@ -0,0 +1,106 @@ +use std::sync::mpsc::channel; +use std::time::Duration; + +use anyhow::Result; +use clap::Args; +use notify::event::Event; +use notify::{EventKind, PollWatcher, RecursiveMode, Watcher}; +use scarb::core::Config; +use tracing::{error, info, trace}; + +use super::build::BuildArgs; + +#[derive(Debug, Args)] +pub struct DevArgs {} + +impl DevArgs { + /// Watches the `src` directory that is found at the same level of the `Scarb.toml` manifest + /// of the project into the provided [`Config`]. + /// + /// When a change is detected, it rebuilds the project and applies the migrations. + pub fn run(self, config: &Config) -> Result<()> { + let (tx, rx) = channel(); + + let watcher_config = notify::Config::default().with_poll_interval(Duration::from_secs(1)); + + let mut watcher = PollWatcher::new(tx, watcher_config)?; + + let watched_directory = config.manifest_path().parent().unwrap().join("src"); + + watcher + .watch(watched_directory.as_std_path(), RecursiveMode::Recursive) + .unwrap(); + + // Always build the project before starting the dev loop to make sure that the project is + // in a valid state. Devs may not use `build` anymore when using `dev`. + BuildArgs::default().run(config)?; + info!("Initial build completed, waiting for changes."); + + let mut e_handler = EventHandler; + + loop { + let is_rebuild_needed = match rx.recv() { + Ok(maybe_event) => match maybe_event { + Ok(event) => e_handler.process_event(event), + Err(error) => { + error!(?error, "Processing event."); + break; + } + }, + Err(error) => { + error!(?error, "Receiving event."); + break; + } + }; + + if is_rebuild_needed { + // Ignore the fails of those commands as the `run` function + // already logs the error. + let _ = BuildArgs::default().run(config); + } + } + + Ok(()) + } +} + +#[derive(Debug, Default)] +struct EventHandler; + +impl EventHandler { + /// Processes a debounced event and return true if a rebuild is needed. + /// Only considers Cairo file and the Scarb.toml manifest. + fn process_event(&mut self, event: Event) -> bool { + trace!(?event, "Processing event."); + + let paths = match event.kind { + EventKind::Modify(_) => event.paths, + EventKind::Remove(_) => event.paths, + EventKind::Create(_) => event.paths, + _ => vec![], + }; + + if paths.is_empty() { + return false; + } + + let mut is_rebuild_needed = false; + + for path in &paths { + if let Some(filename) = path.file_name() { + if filename == "Scarb.toml" { + info!("Rebuild to include Scarb.toml changes."); + is_rebuild_needed = true; + } else if let Some(extension) = path.extension() { + if extension == "cairo" { + let file = path.to_string_lossy().to_string(); + info!(file, "Rebuild from Cairo file change."); + is_rebuild_needed = true; + } + } + } + } + + is_rebuild_needed + } +} diff --git a/bins/demo-compiler/src/commands/mod.rs b/bins/demo-compiler/src/commands/mod.rs new file mode 100644 index 0000000..2f2c1a6 --- /dev/null +++ b/bins/demo-compiler/src/commands/mod.rs @@ -0,0 +1,56 @@ +use core::fmt; + +use anyhow::Result; +use clap::Subcommand; +use scarb::core::Config; + +pub(crate) mod build; +pub(crate) mod clean; +pub(crate) mod dev; +pub(crate) mod test; + +use build::BuildArgs; +use clean::CleanArgs; +use dev::DevArgs; +use test::TestArgs; + +use tracing::info_span; + +#[derive(Debug, Subcommand)] +pub enum Commands { + #[command(about = "Build the world, generating the necessary artifacts for deployment")] + Build(BuildArgs), + #[command(about = "Remove generated artifacts, manifests and abis")] + Clean(CleanArgs), + #[command(about = "Developer mode: watcher for building and migration")] + Dev(DevArgs), + #[command(about = "Test the project's smart contracts")] + Test(TestArgs), +} + +impl fmt::Display for Commands { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + match self { + Commands::Build(_) => write!(f, "Build"), + Commands::Clean(_) => write!(f, "Clean"), + Commands::Dev(_) => write!(f, "Dev"), + Commands::Test(_) => write!(f, "Test"), + } + } +} + +pub fn run(command: Commands, config: &Config) -> Result<()> { + let name = command.to_string(); + let span = info_span!("Subcommand", name); + let _span = span.enter(); + + // use `.map(|_| ())` to avoid returning a value here but still + // useful to write tests for each command. + + match command { + Commands::Clean(args) => args.run(config), + Commands::Test(args) => args.run(config), + Commands::Build(args) => args.run(config), + Commands::Dev(args) => args.run(config), + } +} diff --git a/bins/demo-compiler/src/commands/test.rs b/bins/demo-compiler/src/commands/test.rs new file mode 100644 index 0000000..72427fa --- /dev/null +++ b/bins/demo-compiler/src/commands/test.rs @@ -0,0 +1,250 @@ +//! Compiles and runs tests for a Dojo project. +use anyhow::{bail, Result}; +use cairo_lang_compiler::db::RootDatabase; +use cairo_lang_compiler::diagnostics::DiagnosticsReporter; +use cairo_lang_compiler::project::{ProjectConfig, ProjectConfigContent}; +use cairo_lang_filesystem::cfg::{Cfg, CfgSet}; +use cairo_lang_filesystem::ids::Directory; +use cairo_lang_starknet::starknet_plugin_suite; +use cairo_lang_test_plugin::test_plugin_suite; +use cairo_lang_test_runner::{CompiledTestRunner, RunProfilerConfig, TestCompiler, TestRunConfig}; +use clap::Args; +use dojo_compiler::compiler::compiler::{ + check_package_dojo_version, collect_core_crate_ids, collect_external_crate_ids, Props, +}; +use dojo_compiler::compiler::config::{CompilerConfig, DojoConfigLoader}; +use dojo_compiler::plugin::dojo_plugin_suite; +use dojo_compiler::scarb_internal::{cfg_set_from_component, crates_config_for_compilation_unit}; +use scarb::compiler::helpers::{collect_all_crate_ids, collect_main_crate_ids}; +use scarb::compiler::{CairoCompilationUnit, CompilationUnit, CompilationUnitAttributes}; +use scarb::core::{Config, Package, TargetKind}; +use scarb::ops::{self, CompileOpts}; +use scarb_ui::args::{FeaturesSpec, PackagesFilter}; +use tracing::trace; + +#[derive(Debug, Clone, PartialEq, clap::ValueEnum)] +pub enum ProfilerMode { + None, + Cairo, + Sierra, +} + +impl From for RunProfilerConfig { + fn from(mode: ProfilerMode) -> Self { + match mode { + ProfilerMode::None => RunProfilerConfig::None, + ProfilerMode::Cairo => RunProfilerConfig::Cairo, + ProfilerMode::Sierra => RunProfilerConfig::Sierra, + } + } +} + +/// Execute all unit tests of a local package. +#[derive(Debug, Args)] +pub struct TestArgs { + /// The filter for the tests, running only tests containing the filter string. + #[arg(short, long, default_value_t = String::default())] + filter: String, + /// Should we run ignored tests as well. + #[arg(long, default_value_t = false)] + include_ignored: bool, + /// Should we run only the ignored tests. + #[arg(long, default_value_t = false)] + ignored: bool, + /// Should we run the profiler and with what mode. + #[arg(long, default_value = "none")] + profiler_mode: ProfilerMode, + /// Should we run the tests with gas enabled. + #[arg(long, default_value_t = true)] + gas_enabled: bool, + /// Should we print the resource usage. + #[arg(long, default_value_t = false)] + print_resource_usage: bool, + /// Specify the features to activate. + #[command(flatten)] + features: FeaturesSpec, + /// Specify packages to test. + #[command(flatten)] + pub packages: Option, +} + +impl TestArgs { + // TODO: move this into the DojoCompiler. + pub fn run(self, config: &Config) -> anyhow::Result<()> { + let ws = ops::read_workspace(config.manifest_path(), config).unwrap_or_else(|err| { + eprintln!("error: {err}"); + std::process::exit(1); + }); + + let packages: Vec = if let Some(filter) = self.packages { + filter.match_many(&ws)?.into_iter().collect() + } else { + ws.members().collect() + }; + + for p in &packages { + check_package_dojo_version(&ws, p)?; + } + + let resolve = ops::resolve_workspace(&ws)?; + + let opts = CompileOpts { + include_target_kinds: vec![TargetKind::TEST], + exclude_target_kinds: vec![], + include_target_names: vec![], + features: self.features.try_into()?, + }; + + let compilation_units = ops::generate_compilation_units(&resolve, &opts.features, &ws)? + .into_iter() + .filter(|cu| { + let is_excluded = opts + .exclude_target_kinds + .contains(&cu.main_component().target_kind()); + let is_included = opts.include_target_kinds.is_empty() + || opts + .include_target_kinds + .contains(&cu.main_component().target_kind()); + let is_included = is_included + && (opts.include_target_names.is_empty() + || cu + .main_component() + .targets + .iter() + .any(|t| opts.include_target_names.contains(&t.name))); + + let is_selected = packages.iter().any(|p| p.id == cu.main_package_id()); + + let is_cairo_plugin = matches!(cu, CompilationUnit::ProcMacro(_)); + is_cairo_plugin || (is_included && is_selected && !is_excluded) + }) + .collect::>(); + + for unit in compilation_units { + let mut unit = if let CompilationUnit::Cairo(unit) = unit { + unit + } else { + continue; + }; + + config.ui().print(format!("testing {}", unit.name())); + + let compiler_config: CompilerConfig = + DojoConfigLoader::from_package(&unit.components[0].package, &ws)?; + + // For each component in the compilation unit (namely, the dependencies being + // compiled) we inject into the `CfgSet` the component name and + // namespace configuration. Doing this here ensures the parsing of + // of the manifest is done once at compile time, and not everytime + // the plugin is called. + for c in unit.components.iter_mut() { + c.cfg_set = Some(cfg_set_from_component( + c, + &compiler_config.namespace, + &config.ui(), + &ws, + )?); + + // As we override all the components CfgSet to ensure the namespace mapping + // is effective for all of them, we must also insert the "test" and "target" + // configs here to ensure correct testing configuration. + if let Some(cfg_set) = c.cfg_set.as_mut() { + cfg_set.insert(Cfg::name("test")); + cfg_set.insert(Cfg::kv("target", "test")); + } + } + + let props: Props = unit.main_component().target_props()?; + let db = build_root_database(&unit)?; + + if DiagnosticsReporter::stderr().allow_warnings().check(&db) { + bail!("failed to compile"); + } + + let mut main_crate_ids = collect_all_crate_ids(&unit, &db); + let test_crate_ids = collect_main_crate_ids(&unit, &db); + + if unit.main_package_id.name.to_string() != "dojo" { + let core_crate_ids = collect_core_crate_ids(&db); + main_crate_ids.extend(core_crate_ids); + } + + if let Some(external_contracts) = props.build_external_contracts { + main_crate_ids.extend(collect_external_crate_ids(&db, external_contracts)); + } + + let config = TestRunConfig { + filter: self.filter.clone(), + ignored: self.ignored, + include_ignored: self.include_ignored, + run_profiler: self.profiler_mode.clone().into(), + gas_enabled: self.gas_enabled, + print_resource_usage: self.print_resource_usage, + }; + + let compiler = TestCompiler { + db: db.snapshot(), + main_crate_ids, + test_crate_ids, + starknet: true, + }; + + let compiled = compiler.build()?; + let runner = CompiledTestRunner { compiled, config }; + + // Database is required here for the profiler to work. + runner.run(Some(&db))?; + + println!(); + } + + Ok(()) + } +} + +pub(crate) fn build_root_database(unit: &CairoCompilationUnit) -> Result { + let mut b = RootDatabase::builder(); + b.with_project_config(build_project_config(unit)?); + b.with_cfg(CfgSet::from_iter([ + Cfg::name("test"), + Cfg::kv("target", "test"), + ])); + + b.with_plugin_suite(test_plugin_suite()); + b.with_plugin_suite(dojo_plugin_suite()); + b.with_plugin_suite(starknet_plugin_suite()); + + b.build() +} + +fn build_project_config(unit: &CairoCompilationUnit) -> Result { + let crate_roots = unit + .components + .iter() + .filter(|c| !c.package.id.is_core()) + // NOTE: We're taking the first target of each compilation unit, which should always be the + // main package source root due to the order maintained by scarb. + .map(|c| (c.cairo_package_name(), c.targets[0].source_root().into())) + .collect(); + + let corelib = unit + .core_package_component() + .map(|c| Directory::Real(c.targets[0].source_root().into())); + + let crates_config = crates_config_for_compilation_unit(unit); + + let content = ProjectConfigContent { + crate_roots, + crates_config, + }; + + let project_config = ProjectConfig { + base_path: unit.main_component().package.root().into(), + corelib, + content, + }; + + trace!(?project_config, "Project config built."); + + Ok(project_config) +} diff --git a/bins/demo-compiler/src/main.rs b/bins/demo-compiler/src/main.rs new file mode 100644 index 0000000..938162d --- /dev/null +++ b/bins/demo-compiler/src/main.rs @@ -0,0 +1,62 @@ +use std::env; +use std::process::exit; + +use anyhow::Result; +use args::CompilerArgs; +use clap::Parser; +use dojo_compiler::compiler::{compiler, DojoCompiler}; +use dojo_compiler::plugin::CairoPluginRepository; +use scarb::compiler::CompilerRepository; +use scarb::core::Config; +use scarb_ui::{OutputFormat, Ui}; +use tracing::trace; + +use crate::commands::Commands; + +mod args; +mod commands; + +fn main() { + let args = CompilerArgs::parse(); + let _ = args.init_logging(); + let ui = Ui::new(args.ui_verbosity(), OutputFormat::Text); + + if let Err(err) = cli_main(args) { + ui.anyhow(&err); + exit(1); + } +} + +fn cli_main(args: CompilerArgs) -> Result<()> { + let mut compilers = CompilerRepository::std(); + let cairo_plugins = CairoPluginRepository::default(); + + match &args.command { + Commands::Build(args) => { + trace!("Adding DojoCompiler to compiler repository."); + compilers + .add(Box::new(DojoCompiler::new(args.output_debug_info))) + .unwrap() + } + Commands::Dev(_) | Commands::Clean(_) => { + trace!("Adding DojoCompiler to compiler repository."); + compilers.add(Box::new(DojoCompiler::default())).unwrap() + } + _ => {} + } + + let manifest_path = scarb::ops::find_manifest_path(args.manifest_path.as_deref())?; + + compiler::verify_cairo_version_compatibility(&manifest_path)?; + + let config = Config::builder(manifest_path.clone()) + .log_filter_directive(env::var_os("SCARB_LOG")) + .profile(args.profile_spec.determine()?) + .offline(args.offline) + .cairo_plugins(cairo_plugins.into()) + .ui_verbosity(args.ui_verbosity()) + .compilers(compilers) + .build()?; + + commands::run(args.command, &config) +} diff --git a/bins/demo-compiler/src/utils.rs b/bins/demo-compiler/src/utils.rs new file mode 100644 index 0000000..662076e --- /dev/null +++ b/bins/demo-compiler/src/utils.rs @@ -0,0 +1,136 @@ +use std::str::FromStr; + +use anyhow::{Error, Result}; +use camino::Utf8PathBuf; +use dojo_world::config::Environment; +use dojo_world::contracts::world::WorldContract; +use dojo_world::contracts::WorldContractReader; +use dojo_world::metadata::dojo_metadata_from_workspace; +use scarb::core::{Config, TomlManifest}; +use semver::Version; +use starknet::providers::jsonrpc::HttpTransport; +use starknet::providers::JsonRpcClient; + +use crate::commands::options::account::{AccountOptions, SozoAccount, WorldAddressOrName}; +use crate::commands::options::starknet::StarknetOptions; +use crate::commands::options::world::WorldOptions; + +/// Load metadata from the Scarb configuration. +/// +/// # Arguments +/// +/// * `config` - Scarb project configuration. +/// +/// # Returns +/// +/// A [`Environment`] on success. +pub fn load_metadata_from_config(config: &Config) -> Result, Error> { + let env_metadata = if config.manifest_path().exists() { + let ws = scarb::ops::read_workspace(config.manifest_path(), config)?; + let dojo_metadata = dojo_metadata_from_workspace(&ws)?; + + dojo_metadata.env().cloned() + } else { + None + }; + + Ok(env_metadata) +} + +/// Build a world contract from the provided environment. +/// +/// # Arguments +/// +/// * `world` - The world options such as the world address, +/// * `account` - The account options, +/// * `starknet` - The Starknet options such as the RPC url, +/// * `env_metadata` - Optional environment coming from Scarb configuration. +/// +/// # Returns +/// +/// A [`WorldContract`] on success. +pub async fn world_from_env_metadata( + world: WorldOptions, + account: AccountOptions, + starknet: &StarknetOptions, + env_metadata: &Option, + config: &Config, +) -> Result>>, Error> { + let env_metadata = env_metadata.as_ref(); + + let world_address = world.address(env_metadata)?; + let provider = starknet.provider(env_metadata)?; + let account = account + .account( + provider, + WorldAddressOrName::Address(world_address), + starknet, + env_metadata, + config, + ) + .await?; + + Ok(WorldContract::new(world_address, account)) +} + +/// Build a world contract reader from the provided environment. +/// +/// # Arguments +/// +/// * `world` - The world options such as the world address, +/// * `starknet` - The Starknet options such as the RPC url, +/// * `env_metadata` - Optional environment coming from Scarb configuration. +/// +/// # Returns +/// +/// A [`WorldContractReader`] on success. +pub async fn world_reader_from_env_metadata( + world: WorldOptions, + starknet: StarknetOptions, + env_metadata: &Option, +) -> Result>, Error> { + let world_address = world.address(env_metadata.as_ref())?; + let provider = starknet.provider(env_metadata.as_ref())?; + + Ok(WorldContractReader::new(world_address, provider)) +} + +pub fn verify_cairo_version_compatibility(manifest_path: &Utf8PathBuf) -> Result<()> { + let scarb_cairo_version = scarb::version::get().cairo; + // When manifest file doesn't exists ignore it. Would be the case during `sozo init` + let Ok(manifest) = TomlManifest::read_from_path(manifest_path) else { return Ok(()) }; + + // For any kind of error, like package not specified, cairo version not specified return + // without an error + let Some(package) = manifest.package else { return Ok(()) }; + + let Some(cairo_version) = package.cairo_version else { return Ok(()) }; + + // only when cairo version is found in manifest file confirm that it matches + let version_req = cairo_version.as_defined().unwrap(); + let version = Version::from_str(scarb_cairo_version.version).unwrap(); + if !version_req.matches(&version) { + anyhow::bail!( + "Specified cairo version not supported by dojo. Please verify and update dojo." + ); + }; + + Ok(()) +} + +pub fn generate_version() -> String { + const DOJO_VERSION: &str = env!("CARGO_PKG_VERSION"); + let scarb_version = scarb::version::get().version; + let scarb_sierra_version = scarb::version::get().sierra.version; + let scarb_cairo_version = scarb::version::get().cairo.version; + + let version_string = format!( + "{}\nscarb: {}\ncairo: {}\nsierra: {}", + DOJO_VERSION, scarb_version, scarb_cairo_version, scarb_sierra_version, + ); + version_string +} + +pub fn is_address(tag_or_address: &str) -> bool { + tag_or_address.starts_with("0x") +} diff --git a/crates/compiler/Cargo.toml b/crates/compiler/Cargo.toml new file mode 100644 index 0000000..4cd127e --- /dev/null +++ b/crates/compiler/Cargo.toml @@ -0,0 +1,54 @@ +[package] +description = "Cairo compiler plugin for Dojo." +edition.workspace = true +license-file.workspace = true +name = "dojo-compiler" +repository.workspace = true +version.workspace = true + +[features] +testing = [ ] + +[dependencies] +anyhow.workspace = true +cairo-lang-compiler.workspace = true +cairo-lang-defs.workspace = true +cairo-lang-diagnostics.workspace = true +cairo-lang-filesystem.workspace = true +cairo-lang-formatter.workspace = true +cairo-lang-plugins.workspace = true +cairo-lang-project.workspace = true +cairo-lang-semantic.workspace = true +cairo-lang-sierra-generator.workspace = true +cairo-lang-starknet.workspace = true +cairo-lang-starknet-classes.workspace = true +cairo-lang-syntax.workspace = true +cairo-lang-test-plugin.workspace = true +cairo-lang-utils.workspace = true +camino.workspace = true +convert_case.workspace = true +dojo-types.workspace = true +indoc.workspace = true +itertools.workspace = true +regex.workspace = true +scarb.workspace = true +scarb-ui.workspace = true +semver.workspace = true +serde.workspace = true +serde_json.workspace = true +smol_str.workspace = true +starknet.workspace = true +tempfile.workspace = true +toml.workspace = true +tracing.workspace = true +url.workspace = true + +[dev-dependencies] +assert_fs.workspace = true +cairo-lang-debug.workspace = true +cairo-lang-parser.workspace = true +cairo-lang-semantic.workspace = true +cairo-lang-test-utils.workspace = true +once_cell.workspace = true +salsa.workspace = true +test-log.workspace = true diff --git a/crates/compiler/README.md b/crates/compiler/README.md new file mode 100644 index 0000000..6c26088 --- /dev/null +++ b/crates/compiler/README.md @@ -0,0 +1,11 @@ +# Cairo compiler plugin for Dojo + +Cairo compiler plugin to compile Dojo specific macros. + +## Testing + +To regenerate the test data, set `CAIRO_FIX_TESTS=1`: + +``` +CAIRO_FIX_TESTS=1 cargo test -p dojo-compiler +``` diff --git a/crates/compiler/src/attribute_macros/contract.rs b/crates/compiler/src/attribute_macros/contract.rs new file mode 100644 index 0000000..e9000e5 --- /dev/null +++ b/crates/compiler/src/attribute_macros/contract.rs @@ -0,0 +1,777 @@ +use std::collections::HashMap; + +use cairo_lang_defs::patcher::{PatchBuilder, RewriteNode}; +use cairo_lang_defs::plugin::{ + DynGeneratedFileAuxData, MacroPluginMetadata, PluginDiagnostic, PluginGeneratedFile, + PluginResult, +}; +use cairo_lang_diagnostics::Severity; +use cairo_lang_plugins::plugins::HasItemsInCfgEx; +use cairo_lang_syntax::node::ast::{ + ArgClause, Expr, MaybeModuleBody, OptionArgListParenthesized, OptionReturnTypeClause, +}; +use cairo_lang_syntax::node::db::SyntaxGroup; +use cairo_lang_syntax::node::helpers::QueryAttrs; +use cairo_lang_syntax::node::{ast, ids, Terminal, TypedStablePtr, TypedSyntaxNode}; +use cairo_lang_utils::unordered_hash_map::UnorderedHashMap; +use dojo_types::naming; + +use crate::namespace_config::NamespaceConfig; +use crate::plugin::{ContractAuxData, DojoAuxData, DOJO_CONTRACT_ATTR}; +use crate::syntax::world_param::{self, WorldParamInjectionKind}; +use crate::syntax::{self_param, utils as syntax_utils}; + +const DOJO_INIT_FN: &str = "dojo_init"; +const CONTRACT_NAMESPACE: &str = "namespace"; +const CONTRACT_NOMAPPING: &str = "nomapping"; + +#[derive(Debug, Clone, Default)] +pub struct ContractParameters { + namespace: Option, + nomapping: bool, +} + +#[derive(Debug)] +pub struct DojoContract { + diagnostics: Vec, + systems: Vec, +} + +impl DojoContract { + pub fn from_module( + db: &dyn SyntaxGroup, + module_ast: &ast::ItemModule, + namespace_config: &NamespaceConfig, + metadata: &MacroPluginMetadata<'_>, + ) -> PluginResult { + let name = module_ast.name(db).text(db); + + let mut diagnostics = vec![]; + let parameters = get_parameters(db, module_ast, &mut diagnostics); + + let mut contract = DojoContract { + diagnostics, + systems: vec![], + }; + + let mut has_event = false; + let mut has_storage = false; + let mut has_init = false; + + let unmapped_namespace = parameters + .namespace + .unwrap_or(namespace_config.default.clone()); + + let contract_namespace = if parameters.nomapping { + unmapped_namespace + } else { + // Maps namespace from the tag to ensure higher precision on matching namespace + // mappings. + namespace_config.get_mapping(&naming::get_tag(&unmapped_namespace, &name)) + }; + + for (id, value) in [ + ("name", &name.to_string()), + ("namespace", &contract_namespace), + ] { + if !NamespaceConfig::is_name_valid(value) { + return PluginResult { + code: None, + diagnostics: vec![PluginDiagnostic { + stable_ptr: module_ast.stable_ptr().0, + message: format!( + "The contract {id} '{value}' can only contain characters (a-z/A-Z), \ + digits (0-9) and underscore (_)." + ), + severity: Severity::Error, + }], + remove_original_item: false, + }; + } + } + + let contract_tag = naming::get_tag(&contract_namespace, &name); + let contract_name_hash = naming::compute_bytearray_hash(&name); + let contract_namespace_hash = naming::compute_bytearray_hash(&contract_namespace); + let contract_selector = + naming::compute_selector_from_hashes(contract_namespace_hash, contract_name_hash); + + if let MaybeModuleBody::Some(body) = module_ast.body(db) { + let mut body_nodes: Vec<_> = body + .iter_items_in_cfg(db, metadata.cfg_set) + .flat_map(|el| { + if let ast::ModuleItem::Enum(ref enum_ast) = el { + if enum_ast.name(db).text(db).to_string() == "Event" { + has_event = true; + return contract.merge_event(db, enum_ast.clone()); + } + } else if let ast::ModuleItem::Struct(ref struct_ast) = el { + if struct_ast.name(db).text(db).to_string() == "Storage" { + has_storage = true; + return contract.merge_storage(db, struct_ast.clone()); + } + } else if let ast::ModuleItem::Impl(ref impl_ast) = el { + // If an implementation is not targetting the ContractState, + // the auto injection of self and world is not applied. + let trait_path = impl_ast.trait_path(db).node.get_text(db); + if trait_path.contains("") { + return contract.rewrite_impl(db, impl_ast.clone(), metadata); + } + } else if let ast::ModuleItem::FreeFunction(ref fn_ast) = el { + let fn_decl = fn_ast.declaration(db); + let fn_name = fn_decl.name(db).text(db); + + if fn_name == DOJO_INIT_FN { + has_init = true; + return contract.handle_init_fn(db, fn_ast); + } + } + + vec![RewriteNode::Copied(el.as_syntax_node())] + }) + .collect(); + + if !has_init { + let node = RewriteNode::interpolate_patched( + " + #[starknet::interface] + pub trait IDojoInit { + fn $init_name$(self: @ContractState); + } + + #[abi(embed_v0)] + pub impl IDojoInitImpl of IDojoInit { + fn $init_name$(self: @ContractState) { + if starknet::get_caller_address() != self.world().contract_address { + core::panics::panic_with_byte_array( + @format!(\"Only the world can init contract `{}`, but caller \ + is `{:?}`\", + self.tag(), + starknet::get_caller_address(), + )); + } + } + } + ", + &UnorderedHashMap::from([( + "init_name".to_string(), + RewriteNode::Text(DOJO_INIT_FN.to_string()), + )]), + ); + body_nodes.append(&mut vec![node]); + } + + if !has_event { + body_nodes.append(&mut contract.create_event()) + } + + if !has_storage { + body_nodes.append(&mut contract.create_storage()) + } + + let mut builder = PatchBuilder::new(db, module_ast); + builder.add_modified(RewriteNode::Mapped { + node: Box::new(RewriteNode::interpolate_patched( + " + #[starknet::contract] + pub mod $name$ { + use dojo::world; + use dojo::world::IWorldDispatcher; + use dojo::world::IWorldDispatcherTrait; + use dojo::world::IWorldProvider; + use dojo::contract::IContract; + use starknet::storage::{ + StorageMapReadAccess, StorageMapWriteAccess, StoragePointerReadAccess, \ + StoragePointerWriteAccess + }; + + component!(path: dojo::contract::upgradeable::upgradeable, storage: \ + upgradeable, event: UpgradeableEvent); + + #[abi(embed_v0)] + pub impl ContractImpl of IContract { + fn name(self: @ContractState) -> ByteArray { + \"$name$\" + } + + fn namespace(self: @ContractState) -> ByteArray { + \"$contract_namespace$\" + } + + fn tag(self: @ContractState) -> ByteArray { + \"$contract_tag$\" + } + + fn name_hash(self: @ContractState) -> felt252 { + $contract_name_hash$ + } + + fn namespace_hash(self: @ContractState) -> felt252 { + $contract_namespace_hash$ + } + + fn selector(self: @ContractState) -> felt252 { + $contract_selector$ + } + } + + #[abi(embed_v0)] + impl WorldProviderImpl of IWorldProvider { + fn world(self: @ContractState) -> IWorldDispatcher { + self.world_dispatcher.read() + } + } + + #[abi(embed_v0)] + impl UpgradableImpl = \ + dojo::contract::upgradeable::upgradeable::UpgradableImpl; + + $body$ + } + ", + &UnorderedHashMap::from([ + ("name".to_string(), RewriteNode::Text(name.to_string())), + ("body".to_string(), RewriteNode::new_modified(body_nodes)), + ( + "contract_namespace".to_string(), + RewriteNode::Text(contract_namespace.clone()), + ), + ( + "contract_name_hash".to_string(), + RewriteNode::Text(contract_name_hash.to_string()), + ), + ( + "contract_namespace_hash".to_string(), + RewriteNode::Text(contract_namespace_hash.to_string()), + ), + ( + "contract_selector".to_string(), + RewriteNode::Text(contract_selector.to_string()), + ), + ("contract_tag".to_string(), RewriteNode::Text(contract_tag)), + ]), + )), + origin: module_ast.as_syntax_node().span_without_trivia(db), + }); + + let (code, code_mappings) = builder.build(); + + return PluginResult { + code: Some(PluginGeneratedFile { + name: name.clone(), + content: code, + aux_data: Some(DynGeneratedFileAuxData::new(DojoAuxData { + models: vec![], + contracts: vec![ContractAuxData { + name, + namespace: contract_namespace.clone(), + systems: contract.systems.clone(), + }], + events: vec![], + })), + code_mappings, + }), + diagnostics: contract.diagnostics, + remove_original_item: true, + }; + } + + PluginResult::default() + } + + fn handle_init_fn( + &mut self, + db: &dyn SyntaxGroup, + fn_ast: &ast::FunctionWithBody, + ) -> Vec { + let fn_decl = fn_ast.declaration(db); + + if let OptionReturnTypeClause::ReturnTypeClause(_) = fn_decl.signature(db).ret_ty(db) { + self.diagnostics.push(PluginDiagnostic { + stable_ptr: fn_ast.stable_ptr().untyped(), + message: "The dojo_init function cannot have a return type.".to_string(), + severity: Severity::Error, + }); + } + + let (params_str, was_world_injected) = self.rewrite_parameters( + db, + fn_decl.signature(db).parameters(db), + fn_ast.stable_ptr().untyped(), + ); + + let trait_node = RewriteNode::interpolate_patched( + "#[starknet::interface] + pub trait IDojoInit { + fn $init_name$($params_str$); + } + ", + &UnorderedHashMap::from([ + ( + "init_name".to_string(), + RewriteNode::Text(DOJO_INIT_FN.to_string()), + ), + ( + "params_str".to_string(), + RewriteNode::Text(params_str.clone()), + ), + ]), + ); + + let impl_node = RewriteNode::Text( + " + #[abi(embed_v0)] + pub impl IDojoInitImpl of IDojoInit { + " + .to_string(), + ); + + let declaration_node = RewriteNode::Mapped { + node: Box::new(RewriteNode::Text(format!( + "fn {}({}) {{", + DOJO_INIT_FN, params_str + ))), + origin: fn_ast + .declaration(db) + .as_syntax_node() + .span_without_trivia(db), + }; + + let world_line_node = if was_world_injected { + RewriteNode::Text("let world = self.world_dispatcher.read();".to_string()) + } else { + RewriteNode::empty() + }; + + let assert_world_caller_node = RewriteNode::Text( + "if starknet::get_caller_address() != self.world().contract_address { \ + core::panics::panic_with_byte_array(@format!(\"Only the world can init contract \ + `{}`, but caller is `{:?}`\", self.tag(), starknet::get_caller_address())); }" + .to_string(), + ); + + let func_nodes = fn_ast + .body(db) + .statements(db) + .elements(db) + .iter() + .map(|e| RewriteNode::Mapped { + node: Box::new(RewriteNode::from(e.as_syntax_node())), + origin: e.as_syntax_node().span_without_trivia(db), + }) + .collect::>(); + + let mut nodes = vec![ + trait_node, + impl_node, + declaration_node, + world_line_node, + assert_world_caller_node, + ]; + nodes.extend(func_nodes); + // Close the init function + close the impl block. + nodes.push(RewriteNode::Text("}\n}".to_string())); + + nodes + } + + pub fn merge_event( + &mut self, + db: &dyn SyntaxGroup, + enum_ast: ast::ItemEnum, + ) -> Vec { + let mut rewrite_nodes = vec![]; + + let elements = enum_ast.variants(db).elements(db); + + let variants = elements + .iter() + .map(|e| e.as_syntax_node().get_text(db)) + .collect::>(); + let variants = variants.join(",\n"); + + rewrite_nodes.push(RewriteNode::interpolate_patched( + " + #[event] + #[derive(Drop, starknet::Event)] + enum Event { + UpgradeableEvent: dojo::contract::upgradeable::upgradeable::Event, + $variants$ + } + ", + &UnorderedHashMap::from([("variants".to_string(), RewriteNode::Text(variants))]), + )); + rewrite_nodes + } + + pub fn create_event(&mut self) -> Vec { + vec![RewriteNode::Text( + " + #[event] + #[derive(Drop, starknet::Event)] + enum Event { + UpgradeableEvent: dojo::contract::upgradeable::upgradeable::Event, + } + " + .to_string(), + )] + } + + pub fn merge_storage( + &mut self, + db: &dyn SyntaxGroup, + struct_ast: ast::ItemStruct, + ) -> Vec { + let mut rewrite_nodes = vec![]; + + let elements = struct_ast.members(db).elements(db); + + let members = elements + .iter() + .map(|e| e.as_syntax_node().get_text(db)) + .collect::>(); + let members = members.join(",\n"); + + rewrite_nodes.push(RewriteNode::interpolate_patched( + " + #[storage] + struct Storage { + world_dispatcher: IWorldDispatcher, + #[substorage(v0)] + upgradeable: dojo::contract::upgradeable::upgradeable::Storage, + $members$ + } + ", + &UnorderedHashMap::from([("members".to_string(), RewriteNode::Text(members))]), + )); + rewrite_nodes + } + + pub fn create_storage(&mut self) -> Vec { + vec![RewriteNode::Text( + " + #[storage] + struct Storage { + world_dispatcher: IWorldDispatcher, + #[substorage(v0)] + upgradeable: dojo::contract::upgradeable::upgradeable::Storage, + } + " + .to_string(), + )] + } + + /// Rewrites parameter list by: + /// * adding `self` parameter based on the `world` parameter mutability. If `world` is not + /// provided, a `View` is assumed. + /// * removing `world` if present as first parameter, as it will be read from the first + /// function statement. + /// + /// Reports an error in case of: + /// * `self` used explicitly, + /// * multiple world parameters, + /// * the `world` parameter is not the first parameter and named 'world'. + /// + /// Returns + /// * the list of parameters in a String. + /// * true if the world has to be injected (found as the first param). + pub fn rewrite_parameters( + &mut self, + db: &dyn SyntaxGroup, + param_list: ast::ParamList, + fn_diagnostic_item: ids::SyntaxStablePtrId, + ) -> (String, bool) { + let is_self_used = self_param::check_parameter(db, ¶m_list); + + let world_injection = world_param::parse_world_injection( + db, + param_list.clone(), + fn_diagnostic_item, + &mut self.diagnostics, + ); + + if is_self_used && world_injection != WorldParamInjectionKind::None { + self.diagnostics.push(PluginDiagnostic { + stable_ptr: fn_diagnostic_item, + message: "You cannot use `self` and `world` parameters together.".to_string(), + severity: Severity::Error, + }); + } + + let mut params = param_list + .elements(db) + .iter() + .filter_map(|param| { + let (name, _, param_type) = syntax_utils::get_parameter_info(db, param.clone()); + + // If the param is `IWorldDispatcher`, we don't need to keep it in the param list + // as it is flatten in the first statement. + if world_param::is_world_param(&name, ¶m_type) { + None + } else { + Some(param.as_syntax_node().get_text(db)) + } + }) + .collect::>(); + + match world_injection { + WorldParamInjectionKind::None => { + if !is_self_used { + params.insert(0, "self: @ContractState".to_string()); + } + } + WorldParamInjectionKind::View => { + params.insert(0, "self: @ContractState".to_string()); + } + WorldParamInjectionKind::External => { + params.insert(0, "ref self: ContractState".to_string()); + } + } + + ( + params.join(", "), + world_injection != WorldParamInjectionKind::None, + ) + } + + /// Rewrites function declaration by: + /// * adding `self` parameter if missing, + /// * removing `world` if present as first parameter (self excluded), + /// * adding `let world = self.world_dispatcher.read();` statement at the beginning of the + /// function to restore the removed `world` parameter. + /// * if `has_generate_trait` is true, the implementation containing the function has the + /// #[generate_trait] attribute. + pub fn rewrite_function( + &mut self, + db: &dyn SyntaxGroup, + fn_ast: ast::FunctionWithBody, + has_generate_trait: bool, + ) -> Vec { + let fn_name = fn_ast.declaration(db).name(db).text(db); + let return_type = fn_ast + .declaration(db) + .signature(db) + .ret_ty(db) + .as_syntax_node() + .get_text(db); + + // Consider the function as a system if no return type is specified. + if return_type.is_empty() { + self.systems.push(fn_name.to_string()); + } + + let (params_str, was_world_injected) = self.rewrite_parameters( + db, + fn_ast.declaration(db).signature(db).parameters(db), + fn_ast.stable_ptr().untyped(), + ); + + let declaration_node = RewriteNode::Mapped { + node: Box::new(RewriteNode::Text(format!( + "fn {}({}) {} {{", + fn_name, params_str, return_type + ))), + origin: fn_ast + .declaration(db) + .as_syntax_node() + .span_without_trivia(db), + }; + + let world_line_node = if was_world_injected { + RewriteNode::Text("let world = self.world_dispatcher.read();".to_string()) + } else { + RewriteNode::empty() + }; + + let func_nodes = fn_ast + .body(db) + .statements(db) + .elements(db) + .iter() + .map(|e| RewriteNode::Mapped { + node: Box::new(RewriteNode::from(e.as_syntax_node())), + origin: e.as_syntax_node().span_without_trivia(db), + }) + .collect::>(); + + if has_generate_trait && was_world_injected { + self.diagnostics.push(PluginDiagnostic { + stable_ptr: fn_ast.stable_ptr().untyped(), + message: "You cannot use `world` and `#[generate_trait]` together. Use `self` \ + instead." + .to_string(), + severity: Severity::Error, + }); + } + + let mut nodes = vec![declaration_node, world_line_node]; + nodes.extend(func_nodes); + nodes.push(RewriteNode::Text("}".to_string())); + + nodes + } + + /// Rewrites all the functions of a Impl block. + fn rewrite_impl( + &mut self, + db: &dyn SyntaxGroup, + impl_ast: ast::ItemImpl, + metadata: &MacroPluginMetadata<'_>, + ) -> Vec { + let generate_attrs = impl_ast.attributes(db).query_attr(db, "generate_trait"); + let has_generate_trait = !generate_attrs.is_empty(); + + if let ast::MaybeImplBody::Some(body) = impl_ast.body(db) { + // We shouldn't have generic param in the case of contract's endpoints. + let impl_node = RewriteNode::Mapped { + node: Box::new(RewriteNode::Text(format!( + "{} impl {} of {} {{", + impl_ast.attributes(db).as_syntax_node().get_text(db), + impl_ast.name(db).as_syntax_node().get_text(db), + impl_ast.trait_path(db).as_syntax_node().get_text(db), + ))), + origin: impl_ast.as_syntax_node().span_without_trivia(db), + }; + + let body_nodes: Vec<_> = body + .iter_items_in_cfg(db, metadata.cfg_set) + .flat_map(|el| { + if let ast::ImplItem::Function(ref fn_ast) = el { + return self.rewrite_function(db, fn_ast.clone(), has_generate_trait); + } + vec![RewriteNode::Copied(el.as_syntax_node())] + }) + .collect(); + + let body_node = RewriteNode::Mapped { + node: Box::new(RewriteNode::interpolate_patched( + "$body$", + &UnorderedHashMap::from([( + "body".to_string(), + RewriteNode::new_modified(body_nodes), + )]), + )), + origin: impl_ast.as_syntax_node().span_without_trivia(db), + }; + + return vec![impl_node, body_node, RewriteNode::Text("}".to_string())]; + } + + vec![RewriteNode::Copied(impl_ast.as_syntax_node())] + } +} + +/// Get the contract namespace from the `Expr` parameter. +fn get_contract_namespace( + db: &dyn SyntaxGroup, + arg_value: Expr, + diagnostics: &mut Vec, +) -> Option { + match arg_value { + Expr::ShortString(ss) => Some(ss.string_value(db).unwrap()), + Expr::String(s) => Some(s.string_value(db).unwrap()), + _ => { + diagnostics.push(PluginDiagnostic { + message: format!( + "The argument '{}' of dojo::contract must be a string", + CONTRACT_NAMESPACE + ), + stable_ptr: arg_value.stable_ptr().untyped(), + severity: Severity::Error, + }); + Option::None + } + } +} + +/// Get parameters of the dojo::contract attribute. +/// +/// Parameters: +/// * db: The semantic database. +/// * module_ast: The AST of the contract module. +/// * diagnostics: vector of compiler diagnostics. +/// +/// Returns: +/// * A [`ContractParameters`] object containing all the dojo::contract parameters with their +/// default values if not set in the code. +fn get_parameters( + db: &dyn SyntaxGroup, + module_ast: &ast::ItemModule, + diagnostics: &mut Vec, +) -> ContractParameters { + let mut parameters = ContractParameters::default(); + let mut processed_args: HashMap = HashMap::new(); + + if let OptionArgListParenthesized::ArgListParenthesized(arguments) = module_ast + .attributes(db) + .query_attr(db, DOJO_CONTRACT_ATTR) + .first() + .unwrap() + .arguments(db) + { + arguments + .arguments(db) + .elements(db) + .iter() + .for_each(|a| match a.arg_clause(db) { + ArgClause::Named(x) => { + let arg_name = x.name(db).text(db).to_string(); + let arg_value = x.value(db); + + if processed_args.contains_key(&arg_name) { + diagnostics.push(PluginDiagnostic { + message: format!( + "Too many '{}' attributes for dojo::contract", + arg_name + ), + stable_ptr: module_ast.stable_ptr().untyped(), + severity: Severity::Error, + }); + } else { + processed_args.insert(arg_name.clone(), true); + + match arg_name.as_str() { + CONTRACT_NAMESPACE => { + parameters.namespace = + get_contract_namespace(db, arg_value, diagnostics); + } + CONTRACT_NOMAPPING => { + parameters.nomapping = true; + } + _ => { + diagnostics.push(PluginDiagnostic { + message: format!( + "Unexpected argument '{}' for dojo::contract", + arg_name + ), + stable_ptr: x.stable_ptr().untyped(), + severity: Severity::Warning, + }); + } + } + } + } + ArgClause::Unnamed(arg) => { + let arg_name = arg.value(db).as_syntax_node().get_text(db); + + diagnostics.push(PluginDiagnostic { + message: format!("Unexpected argument '{}' for dojo::contract", arg_name), + stable_ptr: arg.stable_ptr().untyped(), + severity: Severity::Warning, + }); + } + ArgClause::FieldInitShorthand(x) => { + diagnostics.push(PluginDiagnostic { + message: format!( + "Unexpected argument '{}' for dojo::contract", + x.name(db).name(db).text(db).to_string() + ), + stable_ptr: x.stable_ptr().untyped(), + severity: Severity::Warning, + }); + } + }) + } + + parameters +} diff --git a/crates/compiler/src/attribute_macros/event.rs b/crates/compiler/src/attribute_macros/event.rs new file mode 100644 index 0000000..c292035 --- /dev/null +++ b/crates/compiler/src/attribute_macros/event.rs @@ -0,0 +1,197 @@ +use cairo_lang_defs::patcher::{ModifiedNode, RewriteNode}; +use cairo_lang_defs::plugin::PluginDiagnostic; +use cairo_lang_starknet::plugin::aux_data::StarkNetEventAuxData; +use cairo_lang_starknet::plugin::consts::{ + EVENT_TRAIT, EVENT_TYPE_NAME, KEY_ATTR, NESTED_ATTR, SERDE_ATTR, +}; +use cairo_lang_starknet::plugin::events::EventData; +use cairo_lang_starknet_classes::abi::EventFieldKind; +use cairo_lang_syntax::node::db::SyntaxGroup; +use cairo_lang_syntax::node::helpers::QueryAttrs; +use cairo_lang_syntax::node::{ast, Terminal, TypedStablePtr, TypedSyntaxNode}; +use indoc::formatdoc; + +use crate::plugin::DojoAuxData; + +// A custom implementation of the starknet::Event derivation path. +// We append the event selector directly within the append_keys_and_data function. +// Without the need of the enum for all event variants. + +// https://github.com/starkware-libs/cairo/blob/main/crates/cairo-lang-starknet/src/plugin/derive/event.rs + +pub fn handle_event_struct( + db: &dyn SyntaxGroup, + aux_data: &mut DojoAuxData, + struct_ast: ast::ItemStruct, +) -> (RewriteNode, Vec) { + let mut diagnostics = vec![]; + + // TODO(spapini): Support generics. + let generic_params = struct_ast.generic_params(db); + match generic_params { + ast::OptionWrappedGenericParamList::Empty(_) => {} + _ => { + diagnostics.push(PluginDiagnostic::error( + generic_params.stable_ptr().untyped(), + format!("{EVENT_TYPE_NAME} structs with generic arguments are unsupported"), + )); + } + } + + // Generate append_keys_and_data() code. + let mut append_members = vec![]; + let mut deserialize_members = vec![]; + let mut ctor = vec![]; + let mut members = vec![]; + for member in struct_ast.members(db).elements(db) { + let member_name = RewriteNode::new_trimmed(member.name(db).as_syntax_node()); + let member_kind = + get_field_kind_for_member(db, &mut diagnostics, &member, EventFieldKind::DataSerde); + members.push((member.name(db).text(db), member_kind)); + + let member_for_append = RewriteNode::interpolate_patched( + "self.$member_name$", + &[("member_name".to_string(), member_name.clone())].into(), + ); + let append_member = append_field(member_kind, member_for_append); + let deserialize_member = deserialize_field(member_kind, member_name.clone()); + append_members.push(append_member); + deserialize_members.push(deserialize_member); + ctor.push(RewriteNode::interpolate_patched( + "$member_name$, ", + &[("member_name".to_string(), member_name)].into(), + )); + } + let event_data = EventData::Struct { members }; + aux_data.events.push(StarkNetEventAuxData { event_data }); + + let append_members = RewriteNode::Modified(ModifiedNode { + children: Some(append_members), + }); + let deserialize_members = RewriteNode::Modified(ModifiedNode { + children: Some(deserialize_members), + }); + let ctor = RewriteNode::Modified(ModifiedNode { + children: Some(ctor), + }); + + // Add an implementation for `Event`. + let struct_name = RewriteNode::new_trimmed(struct_ast.name(db).as_syntax_node()); + ( + // Append the event selector using the struct_name for the selector + // and then append the members. + RewriteNode::interpolate_patched( + &formatdoc!( + " + impl $struct_name$IsEvent of {EVENT_TRAIT}<$struct_name$> {{ + fn append_keys_and_data( + self: @$struct_name$, ref keys: Array, ref data: Array + ) {{ + core::array::ArrayTrait::append(ref keys, \ + dojo::model::Model::<$struct_name$>::selector()); + $append_members$ + }} + fn deserialize( + ref keys: Span, ref data: Span, + ) -> Option<$struct_name$> {{$deserialize_members$ + Option::Some($struct_name$ {{$ctor$}}) + }} + }} + " + ), + &[ + ("struct_name".to_string(), struct_name), + ("append_members".to_string(), append_members), + ("deserialize_members".to_string(), deserialize_members), + ("ctor".to_string(), ctor), + ] + .into(), + ), + diagnostics, + ) +} + +/// Generates code to emit an event for a field +fn append_field(member_kind: EventFieldKind, field: RewriteNode) -> RewriteNode { + match member_kind { + EventFieldKind::Nested | EventFieldKind::Flat => RewriteNode::interpolate_patched( + &format!( + " + {EVENT_TRAIT}::append_keys_and_data( + $field$, ref keys, ref data + );" + ), + &[("field".to_string(), field)].into(), + ), + EventFieldKind::KeySerde => RewriteNode::interpolate_patched( + " + core::serde::Serde::serialize($field$, ref keys);", + &[("field".to_string(), field)].into(), + ), + EventFieldKind::DataSerde => RewriteNode::interpolate_patched( + " + core::serde::Serde::serialize($field$, ref data);", + &[("field".to_string(), field)].into(), + ), + } +} + +fn deserialize_field(member_kind: EventFieldKind, member_name: RewriteNode) -> RewriteNode { + RewriteNode::interpolate_patched( + match member_kind { + EventFieldKind::Nested | EventFieldKind::Flat => { + " + let $member_name$ = starknet::Event::deserialize( + ref keys, ref data + )?;" + } + EventFieldKind::KeySerde => { + " + let $member_name$ = core::serde::Serde::deserialize( + ref keys + )?;" + } + EventFieldKind::DataSerde => { + " + let $member_name$ = core::serde::Serde::deserialize( + ref data + )?;" + } + }, + &[("member_name".to_string(), member_name)].into(), + ) +} + +/// Retrieves the field kind for a given enum variant, +/// indicating how the field should be serialized. +/// See [EventFieldKind]. +fn get_field_kind_for_member( + db: &dyn SyntaxGroup, + diagnostics: &mut Vec, + member: &ast::Member, + default: EventFieldKind, +) -> EventFieldKind { + let is_nested = member.has_attr(db, NESTED_ATTR); + let is_key = member.has_attr(db, KEY_ATTR); + let is_serde = member.has_attr(db, SERDE_ATTR); + + // Currently, nested fields are unsupported. + if is_nested { + diagnostics.push(PluginDiagnostic::error( + member.stable_ptr().untyped(), + "Nested event fields are currently unsupported".to_string(), + )); + } + // Currently, serde fields are unsupported. + if is_serde { + diagnostics.push(PluginDiagnostic::error( + member.stable_ptr().untyped(), + "Serde event fields are currently unsupported".to_string(), + )); + } + + if is_key { + return EventFieldKind::KeySerde; + } + default +} diff --git a/crates/compiler/src/attribute_macros/interface.rs b/crates/compiler/src/attribute_macros/interface.rs new file mode 100644 index 0000000..77a5f29 --- /dev/null +++ b/crates/compiler/src/attribute_macros/interface.rs @@ -0,0 +1,179 @@ +use cairo_lang_defs::patcher::{PatchBuilder, RewriteNode}; +use cairo_lang_defs::plugin::{ + MacroPluginMetadata, PluginDiagnostic, PluginGeneratedFile, PluginResult, +}; +use cairo_lang_diagnostics::Severity; +use cairo_lang_plugins::plugins::HasItemsInCfgEx; +use cairo_lang_syntax::node::db::SyntaxGroup; +use cairo_lang_syntax::node::{ast, ids, Terminal, TypedStablePtr, TypedSyntaxNode}; +use cairo_lang_utils::unordered_hash_map::UnorderedHashMap; + +use crate::syntax::self_param; +use crate::syntax::world_param::{self, WorldParamInjectionKind}; + +#[derive(Debug)] +pub struct DojoInterface { + diagnostics: Vec, +} + +impl DojoInterface { + pub fn from_trait( + db: &dyn SyntaxGroup, + trait_ast: ast::ItemTrait, + metadata: &MacroPluginMetadata<'_>, + ) -> PluginResult { + let name = trait_ast.name(db).text(db); + let mut interface = DojoInterface { + diagnostics: vec![], + }; + let mut builder = PatchBuilder::new(db, &trait_ast); + + if let ast::MaybeTraitBody::Some(body) = trait_ast.body(db) { + let body_nodes: Vec<_> = body + .iter_items_in_cfg(db, metadata.cfg_set) + .flat_map(|el| { + if let ast::TraitItem::Function(ref fn_ast) = el { + return interface.rewrite_function(db, fn_ast.clone()); + } + + interface.diagnostics.push(PluginDiagnostic { + stable_ptr: el.stable_ptr().untyped(), + message: "Anything other than functions is not supported in a \ + dojo::interface" + .to_string(), + severity: Severity::Error, + }); + + vec![] + }) + .collect(); + + builder.add_modified(RewriteNode::Mapped { + node: Box::new(RewriteNode::interpolate_patched( + " + #[starknet::interface] + pub trait $name$ { + $body$ + } + ", + &UnorderedHashMap::from([ + ("name".to_string(), RewriteNode::Text(name.to_string())), + ("body".to_string(), RewriteNode::new_modified(body_nodes)), + ]), + )), + origin: trait_ast.as_syntax_node().span_without_trivia(db), + }); + } else { + // empty trait + builder.add_modified(RewriteNode::Mapped { + node: Box::new(RewriteNode::interpolate_patched( + " + #[starknet::interface] + pub trait $name$ {} + ", + &UnorderedHashMap::from([( + "name".to_string(), + RewriteNode::Text(name.to_string()), + )]), + )), + origin: trait_ast.as_syntax_node().span_without_trivia(db), + }); + } + + let (code, code_mappings) = builder.build(); + + PluginResult { + code: Some(PluginGeneratedFile { + name: name.clone(), + content: code, + aux_data: None, + code_mappings, + }), + diagnostics: interface.diagnostics, + remove_original_item: true, + } + } + + /// Rewrites parameter list by adding `self` parameter based on the `world` parameter. + pub fn rewrite_parameters( + &mut self, + db: &dyn SyntaxGroup, + param_list: ast::ParamList, + diagnostic_item: ids::SyntaxStablePtrId, + ) -> String { + let mut params = param_list + .elements(db) + .iter() + .map(|e| e.as_syntax_node().get_text(db)) + .collect::>(); + + let is_self_used = self_param::check_parameter(db, ¶m_list); + + let world_injection = world_param::parse_world_injection( + db, + param_list, + diagnostic_item, + &mut self.diagnostics, + ); + + if is_self_used && world_injection != WorldParamInjectionKind::None { + self.diagnostics.push(PluginDiagnostic { + stable_ptr: diagnostic_item, + message: "You cannot use `self` and `world` parameters together.".to_string(), + severity: Severity::Error, + }); + } + + match world_injection { + WorldParamInjectionKind::None => { + if !is_self_used { + params.insert(0, "self: @TContractState".to_string()); + } + } + WorldParamInjectionKind::View => { + params.remove(0); + params.insert(0, "self: @TContractState".to_string()); + } + WorldParamInjectionKind::External => { + params.remove(0); + params.insert(0, "ref self: TContractState".to_string()); + } + }; + + params.join(", ") + } + + /// Rewrites function declaration by adding `self` parameter if missing, + pub fn rewrite_function( + &mut self, + db: &dyn SyntaxGroup, + fn_ast: ast::TraitItemFunction, + ) -> Vec { + let fn_name = fn_ast.declaration(db).name(db).text(db); + let return_type = fn_ast + .declaration(db) + .signature(db) + .ret_ty(db) + .as_syntax_node() + .get_text(db); + + let params_str = self.rewrite_parameters( + db, + fn_ast.declaration(db).signature(db).parameters(db), + fn_ast.stable_ptr().untyped(), + ); + + let declaration_node = RewriteNode::Mapped { + node: Box::new(RewriteNode::Text(format!( + "fn {}({}) {};", + fn_name, params_str, return_type + ))), + origin: fn_ast + .declaration(db) + .as_syntax_node() + .span_without_trivia(db), + }; + + vec![declaration_node] + } +} diff --git a/crates/compiler/src/attribute_macros/mod.rs b/crates/compiler/src/attribute_macros/mod.rs new file mode 100644 index 0000000..fd1e638 --- /dev/null +++ b/crates/compiler/src/attribute_macros/mod.rs @@ -0,0 +1,4 @@ +pub mod contract; +pub mod event; +pub mod interface; +pub mod model; diff --git a/crates/compiler/src/attribute_macros/model.rs b/crates/compiler/src/attribute_macros/model.rs new file mode 100644 index 0000000..988d7ad --- /dev/null +++ b/crates/compiler/src/attribute_macros/model.rs @@ -0,0 +1,1036 @@ +use std::collections::HashMap; + +use cairo_lang_defs::patcher::RewriteNode; +use cairo_lang_defs::plugin::PluginDiagnostic; +use cairo_lang_diagnostics::Severity; +use cairo_lang_syntax::node::ast::{ + ArgClause, Expr, ItemStruct, Member as MemberAst, OptionArgListParenthesized, +}; +use cairo_lang_syntax::node::db::SyntaxGroup; +use cairo_lang_syntax::node::helpers::QueryAttrs; +use cairo_lang_syntax::node::{Terminal, TypedStablePtr, TypedSyntaxNode}; +use cairo_lang_utils::unordered_hash_map::UnorderedHashMap; +use convert_case::{Case, Casing}; +use dojo_types::naming; +use starknet::core::utils::get_selector_from_name; + +use crate::namespace_config::NamespaceConfig; +use crate::plugin::{DojoAuxData, Member, ModelAuxData, DOJO_MODEL_ATTR}; + +const DEFAULT_MODEL_VERSION: u8 = 1; + +const MODEL_VERSION_NAME: &str = "version"; +const MODEL_NAMESPACE: &str = "namespace"; +const MODEL_NOMAPPING: &str = "nomapping"; + +struct ModelParameters { + version: u8, + namespace: Option, + nomapping: bool, +} + +impl Default for ModelParameters { + fn default() -> ModelParameters { + ModelParameters { + version: DEFAULT_MODEL_VERSION, + namespace: Option::None, + nomapping: false, + } + } +} + +/// Get the model version from the `Expr` parameter. +fn get_model_version( + db: &dyn SyntaxGroup, + arg_value: Expr, + diagnostics: &mut Vec, +) -> u8 { + match arg_value { + Expr::Literal(ref value) => { + if let Ok(value) = value.text(db).parse::() { + if value <= DEFAULT_MODEL_VERSION { + value + } else { + diagnostics.push(PluginDiagnostic { + message: format!("dojo::model version {} not supported", value), + stable_ptr: arg_value.stable_ptr().untyped(), + severity: Severity::Error, + }); + DEFAULT_MODEL_VERSION + } + } else { + diagnostics.push(PluginDiagnostic { + message: format!( + "The argument '{}' of dojo::model must be an integer", + MODEL_VERSION_NAME + ), + stable_ptr: arg_value.stable_ptr().untyped(), + severity: Severity::Error, + }); + DEFAULT_MODEL_VERSION + } + } + _ => { + diagnostics.push(PluginDiagnostic { + message: format!( + "The argument '{}' of dojo::model must be an integer", + MODEL_VERSION_NAME + ), + stable_ptr: arg_value.stable_ptr().untyped(), + severity: Severity::Error, + }); + DEFAULT_MODEL_VERSION + } + } +} + +/// Get the model namespace from the `Expr` parameter. +fn get_model_namespace( + db: &dyn SyntaxGroup, + arg_value: Expr, + diagnostics: &mut Vec, +) -> Option { + match arg_value { + Expr::ShortString(ss) => Some(ss.string_value(db).unwrap()), + Expr::String(s) => Some(s.string_value(db).unwrap()), + _ => { + diagnostics.push(PluginDiagnostic { + message: format!( + "The argument '{}' of dojo::model must be a string", + MODEL_NAMESPACE + ), + stable_ptr: arg_value.stable_ptr().untyped(), + severity: Severity::Error, + }); + Option::None + } + } +} + +/// Get parameters of the dojo::model attribute. +/// +/// Note: dojo::model attribute has already been checked so there is one and only one attribute. +/// +/// Parameters: +/// * db: The semantic database. +/// * struct_ast: The AST of the model struct. +/// * diagnostics: vector of compiler diagnostics. +/// +/// Returns: +/// * A [`ModelParameters`] object containing all the dojo::model parameters with their default +/// values if not set in the code. +fn get_model_parameters( + db: &dyn SyntaxGroup, + struct_ast: ItemStruct, + diagnostics: &mut Vec, +) -> ModelParameters { + let mut parameters = ModelParameters::default(); + let mut processed_args: HashMap = HashMap::new(); + + if let OptionArgListParenthesized::ArgListParenthesized(arguments) = struct_ast + .attributes(db) + .query_attr(db, DOJO_MODEL_ATTR) + .first() + .unwrap() + .arguments(db) + { + arguments + .arguments(db) + .elements(db) + .iter() + .for_each(|a| match a.arg_clause(db) { + ArgClause::Named(x) => { + let arg_name = x.name(db).text(db).to_string(); + let arg_value = x.value(db); + + if processed_args.contains_key(&arg_name) { + diagnostics.push(PluginDiagnostic { + message: format!("Too many '{}' attributes for dojo::model", arg_name), + stable_ptr: struct_ast.stable_ptr().untyped(), + severity: Severity::Error, + }); + } else { + processed_args.insert(arg_name.clone(), true); + + match arg_name.as_str() { + MODEL_VERSION_NAME => { + parameters.version = get_model_version(db, arg_value, diagnostics); + } + MODEL_NAMESPACE => { + parameters.namespace = + get_model_namespace(db, arg_value, diagnostics); + } + MODEL_NOMAPPING => { + parameters.nomapping = true; + } + _ => { + diagnostics.push(PluginDiagnostic { + message: format!( + "Unexpected argument '{}' for dojo::model", + arg_name + ), + stable_ptr: x.stable_ptr().untyped(), + severity: Severity::Warning, + }); + } + } + } + } + ArgClause::Unnamed(x) => { + diagnostics.push(PluginDiagnostic { + message: format!( + "Unexpected argument '{}' for dojo::model", + x.as_syntax_node().get_text(db) + ), + stable_ptr: x.stable_ptr().untyped(), + severity: Severity::Warning, + }); + } + ArgClause::FieldInitShorthand(x) => { + diagnostics.push(PluginDiagnostic { + message: format!( + "Unexpected argument '{}' for dojo::model", + x.name(db).name(db).text(db).to_string() + ), + stable_ptr: x.stable_ptr().untyped(), + severity: Severity::Warning, + }); + } + }) + } + + parameters +} + +/// A handler for Dojo code that modifies a model struct. +/// Parameters: +/// * db: The semantic database. +/// * struct_ast: The AST of the model struct. +/// +/// Returns: +/// * A RewriteNode containing the generated code. +pub fn handle_model_struct( + db: &dyn SyntaxGroup, + aux_data: &mut DojoAuxData, + struct_ast: ItemStruct, + namespace_config: &NamespaceConfig, +) -> (RewriteNode, Vec) { + let mut diagnostics = vec![]; + + let parameters = get_model_parameters(db, struct_ast.clone(), &mut diagnostics); + + let model_name = struct_ast + .name(db) + .as_syntax_node() + .get_text(db) + .trim() + .to_string(); + let unmapped_namespace = parameters + .namespace + .unwrap_or(namespace_config.default.clone()); + + let model_namespace = if parameters.nomapping { + unmapped_namespace + } else { + // Maps namespace from the tag to ensure higher precision on matching namespace mappings. + namespace_config.get_mapping(&naming::get_tag(&unmapped_namespace, &model_name)) + }; + + for (id, value) in [("name", &model_name), ("namespace", &model_namespace)] { + if !NamespaceConfig::is_name_valid(value) { + return ( + RewriteNode::empty(), + vec![PluginDiagnostic { + stable_ptr: struct_ast.name(db).stable_ptr().0, + message: format!( + "The {id} '{value}' can only contain characters (a-z/A-Z), digits (0-9) \ + and underscore (_)." + ) + .to_string(), + severity: Severity::Error, + }], + ); + } + } + + let model_tag = naming::get_tag(&model_namespace, &model_name); + let model_name_hash = naming::compute_bytearray_hash(&model_name); + let model_namespace_hash = naming::compute_bytearray_hash(&model_namespace); + + let (model_version, model_selector) = match parameters.version { + 0 => ( + RewriteNode::Text("0".to_string()), + RewriteNode::Text(format!("\"{model_name}\"")), + ), + _ => ( + RewriteNode::Text(DEFAULT_MODEL_VERSION.to_string()), + RewriteNode::Text( + naming::compute_selector_from_hashes(model_namespace_hash, model_name_hash) + .to_string(), + ), + ), + }; + + let mut members: Vec = vec![]; + let mut members_values: Vec = vec![]; + let mut param_keys: Vec = vec![]; + let mut serialized_keys: Vec = vec![]; + let mut serialized_param_keys: Vec = vec![]; + let mut serialized_values: Vec = vec![]; + let mut field_accessors: Vec = vec![]; + let mut entity_field_accessors: Vec = vec![]; + let elements = struct_ast.members(db).elements(db); + + elements.iter().for_each(|member_ast| { + let member = Member { + name: member_ast.name(db).text(db).to_string(), + ty: member_ast + .type_clause(db) + .ty(db) + .as_syntax_node() + .get_text(db) + .trim() + .to_string(), + key: member_ast.has_attr(db, "key"), + }; + + if member.key { + validate_key_member(&member, db, member_ast, &mut diagnostics); + serialized_keys.push(serialize_member_ty(&member, true)); + serialized_param_keys.push(serialize_member_ty(&member, false)); + param_keys.push(format!("{}: {}", member.name, member.ty)); + } else { + serialized_values.push(serialize_member_ty(&member, true)); + members_values.push(RewriteNode::Text(format!( + "pub {}: {},\n", + member.name, member.ty + ))); + } + + members.push(member); + }); + let param_keys = param_keys.join(", "); + + members.iter().filter(|m| !m.key).for_each(|member| { + field_accessors.push(generate_field_accessors( + model_name.clone(), + param_keys.clone(), + serialized_param_keys.clone(), + member, + )); + entity_field_accessors.push(generate_entity_field_accessors(model_name.clone(), member)); + }); + + if serialized_keys.is_empty() { + diagnostics.push(PluginDiagnostic { + message: "Model must define at least one #[key] attribute".into(), + stable_ptr: struct_ast.name(db).stable_ptr().untyped(), + severity: Severity::Error, + }); + } + + if serialized_values.is_empty() { + diagnostics.push(PluginDiagnostic { + message: "Model must define at least one member that is not a key".into(), + stable_ptr: struct_ast.name(db).stable_ptr().untyped(), + severity: Severity::Error, + }); + } + + aux_data.models.push(ModelAuxData { + name: model_name.clone(), + namespace: model_namespace.clone(), + members, + }); + + ( + RewriteNode::interpolate_patched( + " +#[derive(Drop, Serde)] +pub struct $type_name$Entity { + __id: felt252, // private field + $members_values$ +} + +#[generate_trait] +pub impl $type_name$EntityStoreImpl of $type_name$EntityStore { + fn get(world: dojo::world::IWorldDispatcher, entity_id: felt252) -> $type_name$Entity { + $type_name$ModelEntityImpl::get(world, entity_id) + } + + fn update(self: @$type_name$Entity, world: dojo::world::IWorldDispatcher) { + dojo::model::ModelEntity::<$type_name$Entity>::update_entity(self, world); + } + + fn delete(self: @$type_name$Entity, world: dojo::world::IWorldDispatcher) { + dojo::model::ModelEntity::<$type_name$Entity>::delete_entity(self, world); + } + + $entity_field_accessors$ +} + +#[generate_trait] +pub impl $type_name$StoreImpl of $type_name$Store { + fn entity_id_from_keys($param_keys$) -> felt252 { + let mut serialized = core::array::ArrayTrait::new(); + $serialized_param_keys$ + core::poseidon::poseidon_hash_span(serialized.span()) + } + + fn from_values(ref keys: Span, ref values: Span) -> $type_name$ { + let mut serialized = core::array::ArrayTrait::new(); + serialized.append_span(keys); + serialized.append_span(values); + let mut serialized = core::array::ArrayTrait::span(@serialized); + + let entity = core::serde::Serde::<$type_name$>::deserialize(ref serialized); + + if core::option::OptionTrait::<$type_name$>::is_none(@entity) { + panic!( + \"Model `$type_name$`: deserialization failed. Ensure the length of the keys tuple \ + is matching the number of #[key] fields in the model struct.\" + ); + } + + core::option::OptionTrait::<$type_name$>::unwrap(entity) + } + + fn get(world: dojo::world::IWorldDispatcher, $param_keys$) -> $type_name$ { + let mut serialized = core::array::ArrayTrait::new(); + $serialized_param_keys$ + + dojo::model::Model::<$type_name$>::get(world, serialized.span()) + } + + fn set(self: @$type_name$, world: dojo::world::IWorldDispatcher) { + dojo::model::Model::<$type_name$>::set_model(self, world); + } + + fn delete(self: @$type_name$, world: dojo::world::IWorldDispatcher) { + dojo::model::Model::<$type_name$>::delete_model(self, world); + } + + $field_accessors$ +} + +pub impl $type_name$ModelEntityImpl of dojo::model::ModelEntity<$type_name$Entity> { + fn id(self: @$type_name$Entity) -> felt252 { + *self.__id + } + + fn values(self: @$type_name$Entity) -> Span { + let mut serialized = core::array::ArrayTrait::new(); + $serialized_values$ + core::array::ArrayTrait::span(@serialized) + } + + fn from_values(entity_id: felt252, ref values: Span) -> $type_name$Entity { + let mut serialized = array![entity_id]; + serialized.append_span(values); + let mut serialized = core::array::ArrayTrait::span(@serialized); + + let entity_values = core::serde::Serde::<$type_name$Entity>::deserialize(ref serialized); + if core::option::OptionTrait::<$type_name$Entity>::is_none(@entity_values) { + panic!( + \"ModelEntity `$type_name$Entity`: deserialization failed.\" + ); + } + core::option::OptionTrait::<$type_name$Entity>::unwrap(entity_values) + } + + fn get(world: dojo::world::IWorldDispatcher, entity_id: felt252) -> $type_name$Entity { + let mut values = dojo::world::IWorldDispatcherTrait::entity( + world, + dojo::model::Model::<$type_name$>::selector(), + dojo::model::ModelIndex::Id(entity_id), + dojo::model::Model::<$type_name$>::layout() + ); + Self::from_values(entity_id, ref values) + } + + fn update_entity(self: @$type_name$Entity, world: dojo::world::IWorldDispatcher) { + dojo::world::IWorldDispatcherTrait::set_entity( + world, + dojo::model::Model::<$type_name$>::selector(), + dojo::model::ModelIndex::Id(self.id()), + self.values(), + dojo::model::Model::<$type_name$>::layout() + ); + } + + fn delete_entity(self: @$type_name$Entity, world: dojo::world::IWorldDispatcher) { + dojo::world::IWorldDispatcherTrait::delete_entity( + world, + dojo::model::Model::<$type_name$>::selector(), + dojo::model::ModelIndex::Id(self.id()), + dojo::model::Model::<$type_name$>::layout() + ); + } + + fn get_member( + world: dojo::world::IWorldDispatcher, + entity_id: felt252, + member_id: felt252, + ) -> Span { + match dojo::utils::find_model_field_layout(dojo::model::Model::<$type_name$>::layout(), \ + member_id) { + Option::Some(field_layout) => { + dojo::world::IWorldDispatcherTrait::entity( + world, + dojo::model::Model::<$type_name$>::selector(), + dojo::model::ModelIndex::MemberId((entity_id, member_id)), + field_layout + ) + }, + Option::None => core::panic_with_felt252('bad member id') + } + } + + fn set_member( + self: @$type_name$Entity, + world: dojo::world::IWorldDispatcher, + member_id: felt252, + values: Span, + ) { + match dojo::utils::find_model_field_layout(dojo::model::Model::<$type_name$>::layout(), \ + member_id) { + Option::Some(field_layout) => { + dojo::world::IWorldDispatcherTrait::set_entity( + world, + dojo::model::Model::<$type_name$>::selector(), + dojo::model::ModelIndex::MemberId((self.id(), member_id)), + values, + field_layout + ) + }, + Option::None => core::panic_with_felt252('bad member id') + } + } +} + +#[cfg(target: \"test\")] +pub impl $type_name$ModelEntityTestImpl of dojo::model::ModelEntityTest<$type_name$Entity> { + fn update_test(self: @$type_name$Entity, world: dojo::world::IWorldDispatcher) { + let world_test = dojo::world::IWorldTestDispatcher { contract_address: \ + world.contract_address }; + + dojo::world::IWorldTestDispatcherTrait::set_entity_test( + world_test, + dojo::model::Model::<$type_name$>::selector(), + dojo::model::ModelIndex::Id(self.id()), + self.values(), + dojo::model::Model::<$type_name$>::layout() + ); + } + + fn delete_test(self: @$type_name$Entity, world: dojo::world::IWorldDispatcher) { + let world_test = dojo::world::IWorldTestDispatcher { contract_address: \ + world.contract_address }; + + dojo::world::IWorldTestDispatcherTrait::delete_entity_test( + world_test, + dojo::model::Model::<$type_name$>::selector(), + dojo::model::ModelIndex::Id(self.id()), + dojo::model::Model::<$type_name$>::layout() + ); + } +} + +pub impl $type_name$ModelImpl of dojo::model::Model<$type_name$> { + fn get(world: dojo::world::IWorldDispatcher, keys: Span) -> $type_name$ { + let mut values = dojo::world::IWorldDispatcherTrait::entity( + world, + Self::selector(), + dojo::model::ModelIndex::Keys(keys), + Self::layout() + ); + let mut _keys = keys; + + $type_name$Store::from_values(ref _keys, ref values) + } + + fn set_model( + self: @$type_name$, + world: dojo::world::IWorldDispatcher + ) { + dojo::world::IWorldDispatcherTrait::set_entity( + world, + Self::selector(), + dojo::model::ModelIndex::Keys(Self::keys(self)), + Self::values(self), + Self::layout() + ); + } + + fn delete_model( + self: @$type_name$, + world: dojo::world::IWorldDispatcher + ) { + dojo::world::IWorldDispatcherTrait::delete_entity( + world, + Self::selector(), + dojo::model::ModelIndex::Keys(Self::keys(self)), + Self::layout() + ); + } + + fn get_member( + world: dojo::world::IWorldDispatcher, + keys: Span, + member_id: felt252 + ) -> Span { + match dojo::utils::find_model_field_layout(Self::layout(), member_id) { + Option::Some(field_layout) => { + let entity_id = dojo::utils::entity_id_from_keys(keys); + dojo::world::IWorldDispatcherTrait::entity( + world, + Self::selector(), + dojo::model::ModelIndex::MemberId((entity_id, member_id)), + field_layout + ) + }, + Option::None => core::panic_with_felt252('bad member id') + } + } + + fn set_member( + self: @$type_name$, + world: dojo::world::IWorldDispatcher, + member_id: felt252, + values: Span + ) { + match dojo::utils::find_model_field_layout(Self::layout(), member_id) { + Option::Some(field_layout) => { + dojo::world::IWorldDispatcherTrait::set_entity( + world, + Self::selector(), + dojo::model::ModelIndex::MemberId((self.entity_id(), member_id)), + values, + field_layout + ) + }, + Option::None => core::panic_with_felt252('bad member id') + } + } + + #[inline(always)] + fn name() -> ByteArray { + \"$type_name$\" + } + + #[inline(always)] + fn namespace() -> ByteArray { + \"$model_namespace$\" + } + + #[inline(always)] + fn tag() -> ByteArray { + \"$model_tag$\" + } + + #[inline(always)] + fn version() -> u8 { + $model_version$ + } + + #[inline(always)] + fn selector() -> felt252 { + $model_selector$ + } + + #[inline(always)] + fn instance_selector(self: @$type_name$) -> felt252 { + Self::selector() + } + + #[inline(always)] + fn name_hash() -> felt252 { + $model_name_hash$ + } + + #[inline(always)] + fn namespace_hash() -> felt252 { + $model_namespace_hash$ + } + + #[inline(always)] + fn entity_id(self: @$type_name$) -> felt252 { + core::poseidon::poseidon_hash_span(self.keys()) + } + + #[inline(always)] + fn keys(self: @$type_name$) -> Span { + let mut serialized = core::array::ArrayTrait::new(); + $serialized_keys$ + core::array::ArrayTrait::span(@serialized) + } + + #[inline(always)] + fn values(self: @$type_name$) -> Span { + let mut serialized = core::array::ArrayTrait::new(); + $serialized_values$ + core::array::ArrayTrait::span(@serialized) + } + + #[inline(always)] + fn layout() -> dojo::model::Layout { + dojo::model::introspect::Introspect::<$type_name$>::layout() + } + + #[inline(always)] + fn instance_layout(self: @$type_name$) -> dojo::model::Layout { + Self::layout() + } + + #[inline(always)] + fn packed_size() -> Option { + dojo::model::layout::compute_packed_size(Self::layout()) + } +} + +#[cfg(target: \"test\")] +pub impl $type_name$ModelTestImpl of dojo::model::ModelTest<$type_name$> { + fn set_test( + self: @$type_name$, + world: dojo::world::IWorldDispatcher + ) { + let world_test = dojo::world::IWorldTestDispatcher { contract_address: \ + world.contract_address }; + + dojo::world::IWorldTestDispatcherTrait::set_entity_test( + world_test, + dojo::model::Model::<$type_name$>::selector(), + dojo::model::ModelIndex::Keys(dojo::model::Model::<$type_name$>::keys(self)), + dojo::model::Model::<$type_name$>::values(self), + dojo::model::Model::<$type_name$>::layout() + ); + } + + fn delete_test( + self: @$type_name$, + world: dojo::world::IWorldDispatcher + ) { + let world_test = dojo::world::IWorldTestDispatcher { contract_address: \ + world.contract_address }; + + dojo::world::IWorldTestDispatcherTrait::delete_entity_test( + world_test, + dojo::model::Model::<$type_name$>::selector(), + dojo::model::ModelIndex::Keys(dojo::model::Model::<$type_name$>::keys(self)), + dojo::model::Model::<$type_name$>::layout() + ); + } +} + +#[starknet::interface] +pub trait I$contract_name$ { + fn ensure_abi(self: @T, model: $type_name$); +} + +#[starknet::contract] +pub mod $contract_name$ { + use super::$type_name$; + use super::I$contract_name$; + + #[storage] + struct Storage {} + + #[abi(embed_v0)] + impl DojoModelImpl of dojo::model::IModel{ + fn name(self: @ContractState) -> ByteArray { + \"$type_name$\" + } + + fn namespace(self: @ContractState) -> ByteArray { + \"$model_namespace$\" + } + + fn tag(self: @ContractState) -> ByteArray { + \"$model_tag$\" + } + + fn version(self: @ContractState) -> u8 { + $model_version$ + } + + fn selector(self: @ContractState) -> felt252 { + $model_selector$ + } + + fn name_hash(self: @ContractState) -> felt252 { + $model_name_hash$ + } + + fn namespace_hash(self: @ContractState) -> felt252 { + $model_namespace_hash$ + } + + fn unpacked_size(self: @ContractState) -> Option { + dojo::model::introspect::Introspect::<$type_name$>::size() + } + + fn packed_size(self: @ContractState) -> Option { + dojo::model::Model::<$type_name$>::packed_size() + } + + fn layout(self: @ContractState) -> dojo::model::Layout { + dojo::model::Model::<$type_name$>::layout() + } + + fn schema(self: @ContractState) -> dojo::model::introspect::Ty { + dojo::model::introspect::Introspect::<$type_name$>::ty() + } + } + + #[abi(embed_v0)] + impl $contract_name$Impl of I$contract_name${ + fn ensure_abi(self: @ContractState, model: $type_name$) { + } + } +} +", + &UnorderedHashMap::from([ + ( + "contract_name".to_string(), + RewriteNode::Text(model_name.to_case(Case::Snake)), + ), + ("type_name".to_string(), RewriteNode::Text(model_name)), + ( + "namespace".to_string(), + RewriteNode::Text("namespace".to_string()), + ), + ( + "serialized_keys".to_string(), + RewriteNode::new_modified(serialized_keys), + ), + ( + "serialized_values".to_string(), + RewriteNode::new_modified(serialized_values), + ), + ("model_version".to_string(), model_version), + ("model_selector".to_string(), model_selector), + ( + "model_namespace".to_string(), + RewriteNode::Text(model_namespace.clone()), + ), + ( + "model_name_hash".to_string(), + RewriteNode::Text(model_name_hash.to_string()), + ), + ( + "model_namespace_hash".to_string(), + RewriteNode::Text(model_namespace_hash.to_string()), + ), + ( + "model_tag".to_string(), + RewriteNode::Text(model_tag.clone()), + ), + ( + "members_values".to_string(), + RewriteNode::new_modified(members_values), + ), + ("param_keys".to_string(), RewriteNode::Text(param_keys)), + ( + "serialized_param_keys".to_string(), + RewriteNode::new_modified(serialized_param_keys), + ), + ( + "field_accessors".to_string(), + RewriteNode::new_modified(field_accessors), + ), + ( + "entity_field_accessors".to_string(), + RewriteNode::new_modified(entity_field_accessors), + ), + ]), + ), + diagnostics, + ) +} + +/// Validates that the key member is valid. +/// # Arguments +/// +/// * member: The member to validate. +/// * diagnostics: The diagnostics to push to, if the member is an invalid key. +fn validate_key_member( + member: &Member, + db: &dyn SyntaxGroup, + member_ast: &MemberAst, + diagnostics: &mut Vec, +) { + if member.ty == "u256" { + diagnostics.push(PluginDiagnostic { + message: "Key is only supported for core types that are 1 felt long once serialized. \ + `u256` is a struct of 2 u128, hence not supported." + .into(), + stable_ptr: member_ast.name(db).stable_ptr().untyped(), + severity: Severity::Error, + }); + } +} + +/// Creates a [`RewriteNode`] for the member type serialization. +/// +/// # Arguments +/// +/// * member: The member to serialize. +fn serialize_member_ty(member: &Member, with_self: bool) -> RewriteNode { + match member.ty.as_str() { + "felt252" => RewriteNode::Text(format!( + "core::array::ArrayTrait::append(ref serialized, {}{});\n", + if with_self { "*self." } else { "" }, + member.name + )), + _ => RewriteNode::Text(format!( + "core::serde::Serde::serialize({}{}, ref serialized);\n", + if with_self { "self." } else { "@" }, + member.name + )), + } +} + +/// Generates field accessors (`get_[field_name]` and `set_[field_name]`) for every +/// fields of a model. +/// +/// # Arguments +/// +/// * `model_name` - the model name. +/// * `param_keys` - coma separated model keys with the format `KEY_NAME: KEY_TYPE`. +/// * `serialized_param_keys` - code to serialize model keys in a `serialized` felt252 array. +/// * `member` - information about the field for which to generate accessors. +/// +/// # Returns +/// A [`RewriteNode`] containing accessors code. +fn generate_field_accessors( + model_name: String, + param_keys: String, + serialized_param_keys: Vec, + member: &Member, +) -> RewriteNode { + RewriteNode::interpolate_patched( + " + fn get_$field_name$(world: dojo::world::IWorldDispatcher, $param_keys$) -> $field_type$ { + let mut serialized = core::array::ArrayTrait::new(); + $serialized_param_keys$ + + let mut values = dojo::model::Model::<$model_name$>::get_member( + world, + serialized.span(), + $field_selector$ + ); + + let field_value = core::serde::Serde::<$field_type$>::deserialize(ref values); + + if core::option::OptionTrait::<$field_type$>::is_none(@field_value) { + panic!( + \"Field `$model_name$::$field_name$`: deserialization failed.\" + ); + } + + core::option::OptionTrait::<$field_type$>::unwrap(field_value) + } + + fn set_$field_name$(self: @$model_name$, world: dojo::world::IWorldDispatcher, value: \ + $field_type$) { + let mut serialized = core::array::ArrayTrait::new(); + core::serde::Serde::serialize(@value, ref serialized); + + self.set_member( + world, + $field_selector$, + serialized.span() + ); + } + ", + &UnorderedHashMap::from([ + ("model_name".to_string(), RewriteNode::Text(model_name)), + ( + "field_selector".to_string(), + RewriteNode::Text( + get_selector_from_name(&member.name) + .expect("invalid member name") + .to_string(), + ), + ), + ( + "field_name".to_string(), + RewriteNode::Text(member.name.clone()), + ), + ( + "field_type".to_string(), + RewriteNode::Text(member.ty.clone()), + ), + ("param_keys".to_string(), RewriteNode::Text(param_keys)), + ( + "serialized_param_keys".to_string(), + RewriteNode::new_modified(serialized_param_keys), + ), + ]), + ) +} + +/// Generates field accessors (`get_[field_name]` and `set_[field_name]`) for every +/// fields of a model entity. +/// +/// # Arguments +/// +/// * `model_name` - the model name. +/// * `member` - information about the field for which to generate accessors. +/// +/// # Returns +/// A [`RewriteNode`] containing accessors code. +fn generate_entity_field_accessors(model_name: String, member: &Member) -> RewriteNode { + RewriteNode::interpolate_patched( + " + fn get_$field_name$(world: dojo::world::IWorldDispatcher, entity_id: felt252) -> $field_type$ \ + { + let mut values = dojo::model::ModelEntity::<$model_name$Entity>::get_member( + world, + entity_id, + $field_selector$ + ); + let field_value = core::serde::Serde::<$field_type$>::deserialize(ref values); + + if core::option::OptionTrait::<$field_type$>::is_none(@field_value) { + panic!( + \"Field `$model_name$::$field_name$`: deserialization failed.\" + ); + } + + core::option::OptionTrait::<$field_type$>::unwrap(field_value) + } + + fn set_$field_name$(self: @$model_name$Entity, world: dojo::world::IWorldDispatcher, value: \ + $field_type$) { + let mut serialized = core::array::ArrayTrait::new(); + core::serde::Serde::serialize(@value, ref serialized); + + self.set_member( + world, + $field_selector$, + serialized.span() + ); + } +", + &UnorderedHashMap::from([ + ("model_name".to_string(), RewriteNode::Text(model_name)), + ( + "field_selector".to_string(), + RewriteNode::Text( + get_selector_from_name(&member.name) + .expect("invalid member name") + .to_string(), + ), + ), + ( + "field_name".to_string(), + RewriteNode::Text(member.name.clone()), + ), + ( + "field_type".to_string(), + RewriteNode::Text(member.ty.clone()), + ), + ]), + ) +} diff --git a/crates/compiler/src/compiler/compiler b/crates/compiler/src/compiler/compiler new file mode 100644 index 0000000..e69de29 diff --git a/crates/compiler/src/compiler/compiler.rs b/crates/compiler/src/compiler/compiler.rs new file mode 100644 index 0000000..771bedb --- /dev/null +++ b/crates/compiler/src/compiler/compiler.rs @@ -0,0 +1,438 @@ +use std::collections::HashMap; +use std::rc::Rc; +use std::str::FromStr; + +use anyhow::{anyhow, Context, Result}; +use cairo_lang_compiler::db::RootDatabase; +use cairo_lang_defs::ids::NamedLanguageElementId; +use cairo_lang_filesystem::db::FilesGroup; +use cairo_lang_filesystem::ids::{CrateId, CrateLongId}; +use cairo_lang_semantic::db::SemanticGroup; +use cairo_lang_starknet::compile::compile_prepared_db; +use cairo_lang_starknet::contract::{find_contracts, ContractDeclaration}; +use cairo_lang_starknet_classes::allowed_libfuncs::{AllowedLibfuncsError, ListSelector}; +use cairo_lang_starknet_classes::contract_class::ContractClass; +use cairo_lang_utils::UpcastMut; +use camino::Utf8PathBuf; +use convert_case::{Case, Casing}; +use itertools::{izip, Itertools}; +use scarb::compiler::helpers::{build_compiler_config, collect_main_crate_ids}; +use scarb::compiler::{CairoCompilationUnit, CompilationUnitAttributes, Compiler}; +use scarb::core::{Config, Package, PackageName, TargetKind, TomlManifest, Workspace}; +use scarb::ops::CompileOpts; +use scarb_ui::args::{FeaturesSpec, PackagesFilter}; +use semver::Version; +use serde::{Deserialize, Serialize}; +use smol_str::SmolStr; +use starknet::core::types::contract::SierraClass; +use starknet::core::types::Felt; +use tracing::{debug, trace, trace_span}; + +use crate::scarb_internal::debug::SierraToCairoDebugInfo; + +#[derive(Debug, Clone)] +pub struct CompiledArtifact { + /// THe class hash of the Sierra contract. + pub class_hash: Felt, + /// The actual compiled Sierra contract class. + pub contract_class: Rc, + pub debug_info: Option>, +} + +/// A type alias for a map of compiled artifacts by their path. +type CompiledArtifactByPath = HashMap; + +const CAIRO_PATH_SEPARATOR: &str = "::"; + +pub(crate) const LOG_TARGET: &str = "dojo_lang::compiler"; + +#[cfg(test)] +#[path = "compiler_test.rs"] +mod test; + +#[derive(Debug, Default)] +pub struct DojoCompiler { + /// Output the debug information of the compiled Sierra contracts. + /// + /// Mainly used for the Walnut debugger integration. It is used + /// internally by Walnut to build the Dojo project with the Sierra + /// debug information. This flag has no use outside of that. + output_debug_info: bool, +} + +impl DojoCompiler { + pub fn new(output_debug_info: bool) -> Self { + Self { output_debug_info } + } + + pub fn compile_workspace( + config: &Config, + packages_filter: Option, + features: FeaturesSpec, + ) -> Result<()> { + let ws = scarb::ops::read_workspace(config.manifest_path(), config)?; + + let packages: Vec = if let Some(filter) = packages_filter { + filter.match_many(&ws)?.into_iter().collect() + } else { + ws.members().collect() + }; + + for p in &packages { + check_package_dojo_version(&ws, p)?; + } + + let _profile_name = ws + .current_profile() + .expect("Scarb profile is expected.") + .to_string(); + + // Manifest path is always a file, we can unwrap safely to get the parent folder. + let _manifest_dir = ws.manifest_path().parent().unwrap().to_path_buf(); + + // TODO: clean base manifests dir. + //let profile_dir = manifest_dir.join(MANIFESTS_DIR).join(profile_name); + //CleanArgs::clean_manifests(&profile_dir)?; + + trace!(?packages); + + let compile_info = crate::scarb_internal::compile_workspace( + config, + CompileOpts { + include_target_names: vec![], + include_target_kinds: vec![], + exclude_target_kinds: vec![TargetKind::TEST], + features: features.try_into()?, + }, + packages.iter().map(|p| p.id).collect(), + )?; + + trace!(?compile_info, "Compiled workspace."); + + Ok(()) + } +} + +/// Checks if the package has a compatible version of dojo-core. +/// In case of a workspace with multiple packages, each package is individually checked +/// and the workspace manifest path is returned in case of virtual workspace. +pub fn check_package_dojo_version(ws: &Workspace<'_>, package: &Package) -> anyhow::Result<()> { + if let Some(dojo_dep) = package + .manifest + .summary + .dependencies + .iter() + .find(|dep| dep.name.as_str() == "dojo") + { + let dojo_version = env!("CARGO_PKG_VERSION"); + + let dojo_dep_str = dojo_dep.to_string(); + + // Only in case of git dependency with an explicit tag, we check if the tag is the same as + // the current version. + if dojo_dep_str.contains("git+") + && dojo_dep_str.contains("tag=v") + && !dojo_dep_str.contains(dojo_version) + { + if let Ok(cp) = ws.current_package() { + let path = if cp.id == package.id { + package.manifest_path() + } else { + ws.manifest_path() + }; + + anyhow::bail!( + "Found dojo-core version mismatch: expected {}. Please verify your dojo \ + dependency in {}", + dojo_version, + path + ) + } else { + // Virtual workspace. + anyhow::bail!( + "Found dojo-core version mismatch: expected {}. Please verify your dojo \ + dependency in {}", + dojo_version, + ws.manifest_path() + ) + } + } + } + + Ok(()) +} + +pub fn generate_version() -> String { + const DOJO_VERSION: &str = env!("CARGO_PKG_VERSION"); + let scarb_version = scarb::version::get().version; + let scarb_sierra_version = scarb::version::get().sierra.version; + let scarb_cairo_version = scarb::version::get().cairo.version; + + let version_string = format!( + "{}\nscarb: {}\ncairo: {}\nsierra: {}", + DOJO_VERSION, scarb_version, scarb_cairo_version, scarb_sierra_version, + ); + version_string +} + +/// Verifies that the Cairo version specified in the manifest file is compatible with the current +/// version of Cairo used by Dojo. +pub fn verify_cairo_version_compatibility(manifest_path: &Utf8PathBuf) -> Result<()> { + let scarb_cairo_version = scarb::version::get().cairo; + + let Ok(manifest) = TomlManifest::read_from_path(manifest_path) else { + return Ok(()); + }; + let Some(package) = manifest.package else { + return Ok(()); + }; + let Some(cairo_version) = package.cairo_version else { + return Ok(()); + }; + + let version_req = cairo_version.as_defined().unwrap(); + let version = Version::from_str(scarb_cairo_version.version).unwrap(); + + trace!(version_req = %version_req, version = %version, "Cairo version compatibility."); + + if !version_req.matches(&version) { + anyhow::bail!( + "Cairo version `{version_req}` specified in the manifest file `{manifest_path}` is not supported by dojo, which is expecting `{version}`. \ + Please verify and update dojo or change the Cairo version in the manifest file.", + ); + }; + + Ok(()) +} + +#[derive(Debug, Default, Serialize, Deserialize)] +#[serde(rename_all = "kebab-case")] +pub struct Props { + pub build_external_contracts: Option>, +} + +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] +pub struct ContractSelector(String); + +impl ContractSelector { + fn package(&self) -> PackageName { + let parts = self + .0 + .split_once(CAIRO_PATH_SEPARATOR) + .unwrap_or((self.0.as_str(), "")); + PackageName::new(parts.0) + } + + /// Returns the path with the model name in snake case. + /// This is used to match the output of the `compile()` function and Dojo plugin naming for + /// models contracts. + fn path_with_model_snake_case(&self) -> String { + let (path, last_segment) = self + .0 + .rsplit_once(CAIRO_PATH_SEPARATOR) + .unwrap_or(("", &self.0)); + + // We don't want to snake case the whole path because some of names like `erc20` + // will be changed to `erc_20`, and leading to invalid paths. + // The model name has to be snaked case as it's how the Dojo plugin names the Model's + // contract. + format!( + "{}{}{}", + path, + CAIRO_PATH_SEPARATOR, + last_segment.to_case(Case::Snake) + ) + } +} + +impl Compiler for DojoCompiler { + fn target_kind(&self) -> TargetKind { + TargetKind::new("dojo") + } + + // TODO: refacto the main loop here, could be much more simpler and efficient. + fn compile( + &self, + unit: CairoCompilationUnit, + db: &mut RootDatabase, + ws: &Workspace<'_>, + ) -> Result<()> { + let props: Props = unit.main_component().target_props()?; + //let target_dir = unit.target_dir(ws); + + // TODO: if we want to output the manifests at the package level, + // we must iterate on the ws members, to find the location of the + // sole package with the `dojo` target. + // In this case, we can use this path to output the manifests. + + let mut main_crate_ids = collect_main_crate_ids(&unit, db); + let core_crate_ids: Vec = collect_core_crate_ids(db); + main_crate_ids.extend(core_crate_ids); + + let compiler_config = build_compiler_config(&unit, &main_crate_ids, ws); + + trace!(target: LOG_TARGET, unit = %unit.name(), ?props, "Compiling unit dojo compiler."); + + let contracts = find_project_contracts( + db.upcast_mut(), + main_crate_ids.clone(), + props.build_external_contracts.clone(), + )?; + + let contract_paths = contracts + .iter() + .map(|decl| decl.module_id().full_path(db.upcast_mut())) + .collect::>(); + trace!(target: LOG_TARGET, contracts = ?contract_paths); + + let contracts = contracts.iter().collect::>(); + + let classes = { + let _ = trace_span!("compile_starknet").enter(); + compile_prepared_db(db, &contracts, compiler_config)? + }; + + let debug_info_classes: Vec> = if self.output_debug_info { + let debug_classes = + crate::scarb_internal::debug::compile_prepared_db_to_debug_info(db, &contracts)?; + + debug_classes + .into_iter() + .map(|d| Some(crate::scarb_internal::debug::get_sierra_to_cairo_debug_info(&d, db))) + .collect() + } else { + vec![None; contracts.len()] + }; + + let mut compiled_classes: CompiledArtifactByPath = HashMap::new(); + let list_selector = ListSelector::default(); + + for (decl, contract_class, debug_info) in izip!(contracts, classes, debug_info_classes) { + let contract_name = decl.submodule_id.name(db.upcast_mut()); + // note that the qualified path is in snake case while + // the `full_path()` method of StructId uses the original struct name case. + // (see in `get_dojo_model_artifacts`) + let qualified_path = decl.module_id().full_path(db.upcast_mut()); + + match contract_class.validate_version_compatible(list_selector.clone()) { + Ok(()) => {} + Err(AllowedLibfuncsError::UnsupportedLibfunc { + invalid_libfunc, + allowed_libfuncs_list_name: _, + }) => { + let diagnostic = format! {r#" + Contract `{contract_name}` ({qualified_path}) includes `{invalid_libfunc}` function that is not allowed in the default libfuncs for public Starknet networks (mainnet, sepolia). + It will work on Katana, but don't forget to remove it before deploying on a public Starknet network. + "#}; + + ws.config().ui().warn(diagnostic); + } + Err(e) => { + return Err(e).with_context(|| { + format!( + "Failed to check allowed libfuncs for contract: {}", + contract_name + ) + }); + } + } + + let class_hash = + compute_class_hash_of_contract_class(&contract_class).with_context(|| { + format!( + "problem computing class hash for contract `{}`", + qualified_path.clone() + ) + })?; + + compiled_classes.insert( + qualified_path, + CompiledArtifact { + class_hash, + contract_class: Rc::new(contract_class), + debug_info: debug_info.map(Rc::new), + }, + ); + } + + Ok(()) + } +} + +fn compute_class_hash_of_contract_class(class: &ContractClass) -> Result { + let class_str = serde_json::to_string(&class)?; + let sierra_class = serde_json::from_str::(&class_str) + .map_err(|e| anyhow!("error parsing Sierra class: {e}"))?; + sierra_class + .class_hash() + .map_err(|e| anyhow!("problem hashing sierra contract: {e}")) +} + +fn find_project_contracts( + mut db: &dyn SemanticGroup, + main_crate_ids: Vec, + external_contracts: Option>, +) -> Result> { + let internal_contracts = { + let _ = trace_span!("find_internal_contracts").enter(); + find_contracts(db, &main_crate_ids) + }; + + let external_contracts = if let Some(external_contracts) = external_contracts { + let _ = trace_span!("find_external_contracts").enter(); + debug!(target: LOG_TARGET, external_contracts = ?external_contracts, "External contracts selectors."); + + let crate_ids = external_contracts + .iter() + .map(|selector| selector.package().into()) + .unique() + .map(|package_name: SmolStr| { + debug!(target: LOG_TARGET, %package_name, "Looking for internal crates."); + db.upcast_mut() + .intern_crate(CrateLongId::Real(package_name)) + }) + .collect::>(); + + find_contracts(db, crate_ids.as_ref()) + .into_iter() + .filter(|decl| { + let contract_path = decl.module_id().full_path(db.upcast()); + external_contracts + .iter() + .any(|selector| contract_path == selector.path_with_model_snake_case()) + }) + .collect::>() + } else { + debug!(target: LOG_TARGET, "No external contracts selected."); + Vec::new() + }; + + Ok(internal_contracts + .into_iter() + .chain(external_contracts) + .collect()) +} + +pub fn collect_core_crate_ids(db: &RootDatabase) -> Vec { + [ + ContractSelector("dojo::contract::base_contract::base".to_string()), + ContractSelector("dojo::world::world_contract::world".to_string()), + ] + .iter() + .map(|selector| selector.package().into()) + .unique() + .map(|package_name: SmolStr| db.intern_crate(CrateLongId::Real(package_name))) + .collect::>() +} + +pub fn collect_external_crate_ids( + db: &RootDatabase, + external_contracts: Vec, +) -> Vec { + external_contracts + .iter() + .map(|selector| selector.package().into()) + .unique() + .map(|package_name: SmolStr| db.intern_crate(CrateLongId::Real(package_name))) + .collect::>() +} diff --git a/crates/compiler/src/compiler/compiler_test.rs b/crates/compiler/src/compiler/compiler_test.rs new file mode 100644 index 0000000..4e4f402 --- /dev/null +++ b/crates/compiler/src/compiler/compiler_test.rs @@ -0,0 +1,76 @@ +use scarb::compiler::Profile; +use scarb::core::{PackageName, TargetKind}; +use scarb::ops::{CompileOpts, FeaturesOpts, FeaturesSelector}; + +use crate::compiler::compiler::ContractSelector; +use crate::compiler::test_utils::build_test_config; +use crate::scarb_internal; + +// Ignored as scarb takes too much time to compile in debug mode. +// It's anyway run in the CI in the `test` job. +#[test] +#[ignore] +fn test_compiler_cairo_features() { + let config = build_test_config( + "./src/manifest_test_data/compiler_cairo/Scarb.toml", + Profile::DEV, + ) + .unwrap(); + + let features_opts = FeaturesOpts { + features: FeaturesSelector::AllFeatures, + no_default_features: false, + }; + let ws = scarb::ops::read_workspace(config.manifest_path(), &config).unwrap(); + let packages: Vec = ws.members().map(|p| p.id).collect(); + + let compile_info = scarb_internal::compile_workspace( + &config, + CompileOpts { + include_target_names: vec![], + include_target_kinds: vec![], + exclude_target_kinds: vec![TargetKind::TEST], + features: features_opts, + }, + packages, + ) + .unwrap(); + + assert_eq!(compile_info.compile_error_units, Vec::::default()); +} + +#[test] +fn test_package() { + let selector = ContractSelector("my_package::my_contract".to_string()); + assert_eq!(selector.package(), PackageName::new("my_package")); + + let selector_no_separator = ContractSelector("my_package".to_string()); + assert_eq!( + selector_no_separator.package(), + PackageName::new("my_package") + ); +} + +#[test] +fn test_path_with_model_snake_case() { + let selector = ContractSelector("my_package::MyContract".to_string()); + assert_eq!( + selector.path_with_model_snake_case(), + "my_package::my_contract" + ); + + let selector_multiple_segments = + ContractSelector("my_package::sub_package::MyContract".to_string()); + assert_eq!( + selector_multiple_segments.path_with_model_snake_case(), + "my_package::sub_package::my_contract" + ); + + // In snake case, erc20 should be erc_20. This test ensures that the path is converted to snake + // case only for the model's name. + let selector_erc20 = ContractSelector("my_package::erc20::Token".to_string()); + assert_eq!( + selector_erc20.path_with_model_snake_case(), + "my_package::erc20::token" + ); +} diff --git a/crates/compiler/src/compiler/config.rs b/crates/compiler/src/compiler/config.rs new file mode 100644 index 0000000..20a1421 --- /dev/null +++ b/crates/compiler/src/compiler/config.rs @@ -0,0 +1,187 @@ +use anyhow::Result; +use camino::Utf8PathBuf; +use scarb::core::{Package, TargetKind, Workspace}; +use serde::Deserialize; +use tracing::trace; + +use crate::namespace_config::NamespaceConfig; + +/// Dojo compiler configuration file contents. +#[derive(Debug, Clone, Default, Deserialize)] +pub struct CompilerConfig { + pub namespace: NamespaceConfig, +} + +/// Loads the Dojo configuration for a given configuration type `T`. +/// +/// By having a generic type for the config, we can avoid having multiple configuration files, +/// and only extract the part that is relevant. +/// +/// For example, the compiler only relies on the `namespace` configuration. However, sozo +/// requires additional configurations, like `world`, `env`, etc. +pub struct DojoConfigLoader +where + T: serde::de::DeserializeOwned + Default, +{ + _phantom: std::marker::PhantomData, +} + +impl DojoConfigLoader +where + T: serde::de::DeserializeOwned + Default, +{ + /// Loads the Dojo configuration from the given package. + pub fn from_package(package: &Package, ws: &Workspace<'_>) -> Result { + // If it's a lib, we can try to extract dojo data. If failed -> then we can return default. + // But like so, if some metadata are here, we get them. + // [[target.dojo]] shouldn't be used with [lib] as no files will be deployed. + let is_lib = package.target(&TargetKind::new("lib")).is_some(); + let is_dojo = package.target(&TargetKind::new("dojo")).is_some(); + + if is_lib && is_dojo { + return Err(anyhow::anyhow!( + "[lib] package cannot have [[target.dojo]]." + )); + } + + let profile = ws.current_profile()?; + let manifest_dir = &Utf8PathBuf::from(package.manifest_path().parent().unwrap()); + let dev_config_path = manifest_dir.join("dojo_dev.toml"); + let config_path = manifest_dir.join(format!("dojo_{}.toml", profile.as_str())); + + trace!(package = ?package.id.name, manifest_dir = ?manifest_dir, profile = ?profile, "Loading dojo config."); + + if !dev_config_path.exists() { + return Ok(Default::default()); + } + + // If the profile file is not found, default to the dev config, if any. + let config_path = if !config_path.exists() { + dev_config_path + } else { + config_path + }; + + let content = std::fs::read_to_string(&config_path)?; + let config: T = toml::from_str(&content)?; + Ok(config) + } + + /// Loads the Dojo metadata from the workspace, where exactly one package with [[target.dojo]] is required. + pub fn from_workspace(ws: &Workspace<'_>) -> Result { + let dojo_packages: Vec = ws + .members() + .filter(|package| { + package.target(&TargetKind::new("dojo")).is_some() + && package.target(&TargetKind::new("lib")).is_none() + }) + .collect(); + + match dojo_packages.len() { + 0 => { + ws.config() + .ui() + .warn("No package with [[target.dojo]] found in workspace."); + Ok(Default::default()) + } + 1 => { + let dojo_package = dojo_packages + .into_iter() + .next() + .expect("Package must exist as len is 1."); + Ok(Self::from_package(&dojo_package, ws)?) + } + _ => { + let error_message = "Multiple packages with [[target.dojo]] found in workspace. Please specify a package \ + using --package option or maybe one of them must be declared as a [lib]."; + + ws.config().ui().error(error_message); + + Err(anyhow::anyhow!(error_message)) + } + } + } +} + +#[cfg(test)] +mod tests { + use super::*; + use scarb::core::Config; + use std::fs; + use tempfile::TempDir; + + /// Setups a default config for a given Scarb manifest path. + fn setup_default_config(manifest_path: &Utf8PathBuf) -> Config { + Config::builder(manifest_path).build().unwrap() + } + + #[test] + fn test_valid_config_from_workspace() { + let temp_dir = TempDir::new().unwrap(); + let temp_path = temp_dir.path(); + + let scarb_toml = + Utf8PathBuf::from(temp_path.join("Scarb.toml").to_string_lossy().to_string()); + let dojo_dev = Utf8PathBuf::from( + temp_path + .join("dojo_dev.toml") + .to_string_lossy() + .to_string(), + ); + + let scarb_toml_content = r#" +[package] +name = "test_package" +version = "0.1.0" + +[[target.dojo]] +"#; + fs::write(&scarb_toml, scarb_toml_content).unwrap(); + + let dojo_dev_content = r#" +[namespace] +default = "ns1" +"#; + fs::write(&dojo_dev, dojo_dev_content).unwrap(); + + let config = setup_default_config(&scarb_toml); + let workspace = scarb::ops::read_workspace(&scarb_toml, &config).unwrap(); + + let config: CompilerConfig = DojoConfigLoader::from_workspace(&workspace).unwrap(); + assert_eq!(config.namespace.default, "ns1"); + } + + #[test] + #[should_panic] + fn test_invalid_config_from_workspace() { + let temp_dir = TempDir::new().unwrap(); + let temp_path = temp_dir.path(); + + let scarb_toml = + Utf8PathBuf::from(temp_path.join("Scarb.toml").to_string_lossy().to_string()); + let dojo_dev = Utf8PathBuf::from( + temp_path + .join("dojo_dev.toml") + .to_string_lossy() + .to_string(), + ); + + let scarb_toml_content = r#" +[package] +name = "test_package" +version = "0.1.0" + +[[target.dojo]] +"#; + fs::write(&scarb_toml, scarb_toml_content).unwrap(); + + let dojo_dev_content = r#" +"#; + fs::write(&dojo_dev, dojo_dev_content).unwrap(); + + let config = setup_default_config(&scarb_toml); + let workspace = scarb::ops::read_workspace(&scarb_toml, &config).unwrap(); + + let _: CompilerConfig = DojoConfigLoader::from_workspace(&workspace).unwrap(); + } +} diff --git a/crates/compiler/src/compiler/mod.rs b/crates/compiler/src/compiler/mod.rs new file mode 100644 index 0000000..11df291 --- /dev/null +++ b/crates/compiler/src/compiler/mod.rs @@ -0,0 +1,6 @@ +pub mod compiler; +pub mod config; +#[cfg(test)] +pub mod test_utils; + +pub use compiler::DojoCompiler; diff --git a/crates/compiler/src/compiler/test_utils.rs b/crates/compiler/src/compiler/test_utils.rs new file mode 100644 index 0000000..5218b0b --- /dev/null +++ b/crates/compiler/src/compiler/test_utils.rs @@ -0,0 +1,430 @@ +use std::collections::HashMap; +use std::fs::File; +use std::io::Read; +use std::path::PathBuf; +use std::{env, fs, io}; + +use assert_fs::TempDir; +use camino::{Utf8Path, Utf8PathBuf}; +use scarb::compiler::{CompilationUnit, CompilerRepository, Profile}; +use scarb::core::{Config, TargetKind}; +use scarb::ops; +use scarb::ops::{CompileOpts, FeaturesOpts, FeaturesSelector}; +use scarb_ui::Verbosity; +use toml::{Table, Value}; + +use crate::compiler::DojoCompiler; +use crate::plugin::CairoPluginRepository; +use crate::scarb_internal::{compile_workspace, CompileInfo}; + +#[derive(Debug)] +pub struct CompilerTestSetup { + pub dir: Utf8PathBuf, + pub dojo_core: Utf8PathBuf, + pub manifests: HashMap, +} + +impl CompilerTestSetup { + pub fn from_examples(dojo_core: &str, example_path: &str) -> CompilerTestSetup { + let example_path = Utf8PathBuf::from(example_path); + + let packages: Vec = vec![ + example_path.join("spawn-and-move"), + example_path.join("game-lib"), + ]; + + let package_refs: Vec<&str> = packages.iter().map(|p| p.as_str()).collect(); + + Self::from_paths(dojo_core, &package_refs) + } + + pub fn from_paths(dojo_core: &str, packages: &[&str]) -> CompilerTestSetup { + let dojo_core = Utf8PathBuf::from(dojo_core); + let packages: Vec = packages.iter().map(Utf8PathBuf::from).collect(); + + let tmp_dir = Utf8PathBuf::from( + assert_fs::TempDir::new() + .unwrap() + .to_path_buf() + .to_string_lossy() + .to_string(), + ); + + let mut manifests = HashMap::new(); + + for package_source in &packages { + let package_name = package_source.file_name().unwrap(); + let package_tmp = tmp_dir.join(package_name); + fs::create_dir_all(&package_tmp).unwrap(); + + let package_manifest = package_tmp.join("Scarb.toml"); + + manifests.insert(package_name.to_string(), package_manifest); + + copy_project_temp(package_source, &package_tmp, &dojo_core, &[]).unwrap(); + } + + CompilerTestSetup { + dir: tmp_dir, + dojo_core, + manifests, + } + } + + pub fn build_test_config(&self, package_name: &str, profile: Profile) -> Config { + let manifest = self.manifests.get(package_name).unwrap(); + + build_test_config(manifest.as_ref(), profile) + .unwrap_or_else(|c| panic!("Error loading config: {c:?}")) + } +} + +/// Copies a directory into a temporary directory. +/// +/// # Returns +/// +/// A [`Utf8PathBuf`] object pointing to the copied directory. +pub fn copy_tmp_dir(source_dir: &Utf8PathBuf) -> Utf8PathBuf { + let temp_project_dir = Utf8PathBuf::from( + assert_fs::TempDir::new() + .unwrap() + .to_path_buf() + .to_string_lossy() + .to_string(), + ); + + fn copy_dir_recursively(src: &PathBuf, dst: &PathBuf) -> io::Result<()> { + if src.is_dir() { + fs::create_dir_all(dst)?; + for entry in fs::read_dir(src)? { + let entry = entry?; + let path = entry.path(); + let dst_path = dst.join(path.file_name().unwrap()); + if path.is_dir() { + copy_dir_recursively(&path, &dst_path)?; + } else { + fs::copy(&path, &dst_path)?; + } + } + } else { + fs::copy(src, dst)?; + } + Ok(()) + } + + copy_dir_recursively( + &source_dir.to_path_buf().into(), + &temp_project_dir.to_path_buf().into(), + ) + .unwrap_or_else(|e| panic!("Failed to copy directory: {}", e)); + + temp_project_dir +} + +/// Copies a project into a temporary directory and loads a config from the copied project. +/// +/// # Returns +/// +/// A [`Config`] object loaded from the spawn-and-moves Scarb.toml file. +pub fn copy_tmp_config( + source_project_dir: &Utf8PathBuf, + dojo_core_path: &Utf8PathBuf, + profile: Profile, +) -> Config { + let temp_project_dir = Utf8PathBuf::from( + assert_fs::TempDir::new() + .unwrap() + .to_path_buf() + .to_string_lossy() + .to_string(), + ); + + let temp_project_path = temp_project_dir + .join("Scarb") + .with_extension("toml") + .to_string(); + + // Copy all the files, including manifests. As we will not re-build, mostly only migrate. + copy_project_temp(source_project_dir, &temp_project_dir, dojo_core_path, &[]).unwrap(); + + build_test_config(&temp_project_path, profile) + .unwrap_or_else(|c| panic!("Error loading config: {c:?}")) +} + +/// Copies a project to a new location, excluding the manifests +/// and target directories, build the temporary project and +/// return the temporary project directory. +/// +/// # Arguments +/// +/// * `source_project_path` - The path to the source project to copy and build at the temporary +/// location. +/// * `do_build` - Whether to build the temporary project. Only use this if you want to build the +/// project again to re-generate all the artifacts. This is a slow operation on the CI (~70s), use +/// it wisely. +pub fn copy_build_project_temp( + source_project_path: &str, + dojo_core_path: &str, + do_build: bool, + profile: Profile, +) -> (Utf8PathBuf, Config, Option) { + let source_project_dir = Utf8PathBuf::from(source_project_path) + .parent() + .unwrap() + .to_path_buf(); + + let temp_project_dir = Utf8PathBuf::from( + assert_fs::TempDir::new() + .unwrap() + .to_path_buf() + .to_string_lossy() + .to_string(), + ); + + let temp_project_path = temp_project_dir + .join("Scarb") + .with_extension("toml") + .to_string(); + + let dojo_core_path = Utf8PathBuf::from(dojo_core_path); + // we don't ignore `manifests` because `overylays` are required for successful migration + let ignore_dirs = ["target"]; + + copy_project_temp( + &source_project_dir, + &temp_project_dir, + &dojo_core_path, + &ignore_dirs, + ) + .unwrap(); + + let config = build_test_config(&temp_project_path, profile).unwrap(); + + let features_opts = FeaturesOpts { + features: FeaturesSelector::AllFeatures, + no_default_features: false, + }; + let ws = scarb::ops::read_workspace(config.manifest_path(), &config).unwrap(); + + let packages: Vec = ws.members().map(|p| p.id).collect(); + + let compile_info = if do_build { + Some( + compile_workspace( + &config, + CompileOpts { + include_target_names: vec![], + include_target_kinds: vec![], + exclude_target_kinds: vec![TargetKind::TEST], + features: features_opts, + }, + packages, + ) + .unwrap(), + ) + } else { + None + }; + + (temp_project_dir, config, compile_info) +} + +/// Copies a project to a new location, excluding the manifests and target directories. +/// +/// # Arguments +/// +/// * `source_dir` - The source directory to copy from. +pub fn copy_project_temp( + source_dir: &Utf8PathBuf, + destination_dir: &Utf8PathBuf, + dojo_core_path: &Utf8PathBuf, + ignore_dirs: &[&str], +) -> io::Result<()> { + if !destination_dir.exists() { + fs::create_dir_all(destination_dir)?; + } + + for entry in fs::read_dir(source_dir)? { + let entry = entry?; + let path = entry.path(); + if path.is_dir() { + let dir_name = match entry.file_name().into_string() { + Ok(name) => name, + Err(_) => continue, // Skip non UTF8 dirs. + }; + + if ignore_dirs.contains(&dir_name.as_str()) { + continue; + } + + copy_project_temp( + &Utf8PathBuf::from_path_buf(path).unwrap(), + &destination_dir.join(dir_name), + dojo_core_path, + ignore_dirs, + )?; + } else { + let file_name = entry.file_name().to_string_lossy().to_string(); + let dest_path = destination_dir.join(&file_name); + + fs::copy(&path, &dest_path)?; + + // Replace in the Scarb.toml the path of dojo crate with the + // absolute path. + if file_name == "Scarb.toml" { + let mut contents = String::new(); + File::open(&dest_path) + .and_then(|mut file| file.read_to_string(&mut contents)) + .unwrap_or_else(|_| panic!("Failed to read {file_name}")); + + let mut table = contents + .parse::() + .expect("Failed to parse Scab.toml"); + + let dojo = if table.contains_key("workspace") { + table["workspace"]["dependencies"]["dojo"] + .as_table_mut() + .unwrap() + } else { + table["dependencies"]["dojo"].as_table_mut().unwrap() + }; + + if dojo.contains_key("path") { + dojo["path"] = Value::String( + fs::canonicalize(dojo_core_path) + .unwrap() + .to_string_lossy() + .to_string(), + ); + + fs::write(dest_path.to_path_buf(), table.to_string().as_bytes()) + .expect("Failed to write to Scab.toml"); + } + } + } + } + + Ok(()) +} + +/// Builds a test config with a temporary cache directory. +/// +/// As manifests files are not related to the target_dir, it is recommended +/// to use copy_build_project_temp to copy the project to a temporary location +/// and build the config from there. This ensures safe and non conflicting +/// manipulation of the artifacts and manifests. +/// +/// # Arguments +/// +/// * `path` - The path to the Scarb.toml file to build the config for. +/// * `profile` - The profile to use for the config. +pub fn build_test_config(path: &str, profile: Profile) -> anyhow::Result { + let mut compilers = CompilerRepository::empty(); + compilers.add(Box::new(DojoCompiler::default())).unwrap(); + + let cairo_plugins = CairoPluginRepository::default(); + + // If the cache_dir is not overriden, we can't run tests in parallel. + let cache_dir = TempDir::new().unwrap(); + + let path = Utf8PathBuf::from_path_buf(path.into()).unwrap(); + Config::builder(path.canonicalize_utf8().unwrap()) + .global_cache_dir_override(Some(Utf8Path::from_path(cache_dir.path()).unwrap())) + .ui_verbosity(Verbosity::Verbose) + .log_filter_directive(env::var_os("SCARB_LOG")) + .compilers(compilers) + .profile(profile) + .cairo_plugins(cairo_plugins.into()) + .build() +} + +pub fn corelib() -> PathBuf { + let config = build_test_config( + "./src/manifest_test_data/spawn-and-move/Scarb.toml", + Profile::DEV, + ) + .unwrap(); + let ws = ops::read_workspace(config.manifest_path(), &config).unwrap(); + let resolve = ops::resolve_workspace(&ws).unwrap(); + + let features_opts = FeaturesOpts { + features: FeaturesSelector::AllFeatures, + no_default_features: false, + }; + + let compilation_units = ops::generate_compilation_units(&resolve, &features_opts, &ws).unwrap(); + + if let CompilationUnit::Cairo(unit) = &compilation_units[0] { + unit.core_package_component() + .expect("should have component") + .targets[0] + .source_root() + .into() + } else { + panic!("should have cairo compilation unit") + } +} + +#[cfg(test)] +mod tests { + use std::fs::{self, File}; + use std::io::Write; + + use assert_fs::TempDir; + + use super::*; + + #[test] + fn test_copy_project() { + let temp_dir = TempDir::new().unwrap(); + let project_dir = temp_dir.path().join("project"); + let dest_dir = temp_dir.path().join("dest"); + + fs::create_dir(&project_dir).unwrap(); + fs::create_dir(&dest_dir).unwrap(); + + // Create a file in the project directory + let file_path = project_dir.join("file.txt"); + let mut file = File::create(file_path).unwrap(); + writeln!(file, "Hello, world!").unwrap(); + + // Create a subdirectory with a file in the project directory + let sub_dir = project_dir.join("subdir"); + fs::create_dir(&sub_dir).unwrap(); + let sub_file_path = sub_dir.join("subfile.txt"); + let mut sub_file = File::create(sub_file_path).unwrap(); + writeln!(sub_file, "Hello, from subdir!").unwrap(); + + // Create a subdir that should be ignored + let ignored_sub_dir = project_dir.join("manifests"); + fs::create_dir(&ignored_sub_dir).unwrap(); + let ignored_sub_file_path = ignored_sub_dir.join("ignored_file.txt"); + let mut ignored_sub_file = File::create(ignored_sub_file_path).unwrap(); + writeln!(ignored_sub_file, "This should be ignored!").unwrap(); + + let ignore_dirs = ["manifests", "target"]; + + copy_project_temp( + &Utf8PathBuf::from(&project_dir.to_string_lossy()), + &Utf8PathBuf::from(&dest_dir.to_string_lossy()), + &Utf8PathBuf::from("../dojo-core"), + &ignore_dirs, + ) + .unwrap(); + + // Check that the file exists in the destination directory + let dest_file_path = dest_dir.join("file.txt"); + assert!(dest_file_path.exists()); + + // Check that the subdirectory and its file exist in the destination directory + let dest_sub_dir = dest_dir.join("subdir"); + let dest_sub_file_path = dest_sub_dir.join("subfile.txt"); + let dest_ignored_sub_dir = dest_sub_dir.join("manifests"); + assert!(dest_sub_dir.exists()); + assert!(dest_sub_file_path.exists()); + assert!(!dest_ignored_sub_dir.exists()); + + // Clean up + temp_dir.close().unwrap(); + } +} diff --git a/crates/compiler/src/inline_macros/delete.rs b/crates/compiler/src/inline_macros/delete.rs new file mode 100644 index 0000000..093f03a --- /dev/null +++ b/crates/compiler/src/inline_macros/delete.rs @@ -0,0 +1,118 @@ +use cairo_lang_defs::patcher::PatchBuilder; +use cairo_lang_defs::plugin::{ + InlineMacroExprPlugin, InlinePluginResult, MacroPluginMetadata, NamedPlugin, PluginDiagnostic, + PluginGeneratedFile, +}; +use cairo_lang_defs::plugin_utils::unsupported_bracket_diagnostic; +use cairo_lang_diagnostics::Severity; +use cairo_lang_syntax::node::{ast, TypedStablePtr, TypedSyntaxNode}; + +use super::unsupported_arg_diagnostic; + +#[derive(Debug, Default)] +pub struct DeleteMacro; + +impl NamedPlugin for DeleteMacro { + const NAME: &'static str = "delete"; +} + +impl InlineMacroExprPlugin for DeleteMacro { + fn generate_code( + &self, + db: &dyn cairo_lang_syntax::node::db::SyntaxGroup, + syntax: &ast::ExprInlineMacro, + _metadata: &MacroPluginMetadata<'_>, + ) -> InlinePluginResult { + let ast::WrappedArgList::ParenthesizedArgList(arg_list) = syntax.arguments(db) else { + return unsupported_bracket_diagnostic(db, syntax); + }; + let mut builder = PatchBuilder::new(db, syntax); + builder.add_str("{"); + + let args = arg_list.arguments(db).elements(db); + + if args.len() != 2 { + return InlinePluginResult { + code: None, + diagnostics: vec![PluginDiagnostic { + stable_ptr: arg_list.arguments(db).stable_ptr().untyped(), + message: "Invalid arguments. Expected \"(world, (models,))\"".to_string(), + severity: Severity::Error, + }], + }; + } + + let world = &args[0]; + + let ast::ArgClause::Unnamed(models) = args[1].arg_clause(db) else { + return unsupported_arg_diagnostic(db, syntax); + }; + + let mut bundle = vec![]; + + match models.value(db) { + ast::Expr::Parenthesized(parens) => { + let syntax_node = parens.expr(db).as_syntax_node(); + bundle.push(syntax_node.get_text(db)); + } + ast::Expr::Tuple(list) => { + list.expressions(db) + .elements(db) + .into_iter() + .for_each(|expr| { + let syntax_node = expr.as_syntax_node(); + bundle.push(syntax_node.get_text(db)); + }) + } + ast::Expr::StructCtorCall(ctor) => { + let syntax_node = ctor.as_syntax_node(); + bundle.push(syntax_node.get_text(db)); + } + _ => { + return InlinePluginResult { + code: None, + diagnostics: vec![PluginDiagnostic { + message: "Invalid arguments. Expected \"(world, (models,))\"".to_string(), + stable_ptr: arg_list.arguments(db).stable_ptr().untyped(), + severity: Severity::Error, + }], + }; + } + } + + if bundle.is_empty() { + return InlinePluginResult { + code: None, + diagnostics: vec![PluginDiagnostic { + message: "Invalid arguments: No models provided.".to_string(), + stable_ptr: arg_list.arguments(db).stable_ptr().untyped(), + severity: Severity::Error, + }], + }; + } + + for entity in bundle { + builder.add_str(&format!( + " + let __delete_model_instance__ = {}; + dojo::model::Model::delete_model(@__delete_model_instance__, {}); + ", + entity, + world.as_syntax_node().get_text(db), + )); + } + builder.add_str("}"); + + let (code, code_mappings) = builder.build(); + + InlinePluginResult { + code: Some(PluginGeneratedFile { + name: "delete_inline_macro".into(), + content: code, + code_mappings, + aux_data: None, + }), + diagnostics: vec![], + } + } +} diff --git a/crates/compiler/src/inline_macros/emit.rs b/crates/compiler/src/inline_macros/emit.rs new file mode 100644 index 0000000..411ef01 --- /dev/null +++ b/crates/compiler/src/inline_macros/emit.rs @@ -0,0 +1,131 @@ +use cairo_lang_defs::patcher::PatchBuilder; +use cairo_lang_defs::plugin::{ + InlineMacroExprPlugin, InlinePluginResult, MacroPluginMetadata, NamedPlugin, PluginDiagnostic, + PluginGeneratedFile, +}; +use cairo_lang_defs::plugin_utils::unsupported_bracket_diagnostic; +use cairo_lang_diagnostics::Severity; +use cairo_lang_starknet::plugin::consts::EVENT_TRAIT; +use cairo_lang_syntax::node::{ast, TypedStablePtr, TypedSyntaxNode}; + +use crate::inline_macros::unsupported_arg_diagnostic; + +#[derive(Debug, Default)] +pub struct EmitMacro; + +impl NamedPlugin for EmitMacro { + const NAME: &'static str = "emit"; +} + +impl InlineMacroExprPlugin for EmitMacro { + fn generate_code( + &self, + db: &dyn cairo_lang_syntax::node::db::SyntaxGroup, + syntax: &ast::ExprInlineMacro, + _metadata: &MacroPluginMetadata<'_>, + ) -> InlinePluginResult { + let ast::WrappedArgList::ParenthesizedArgList(arg_list) = syntax.arguments(db) else { + return unsupported_bracket_diagnostic(db, syntax); + }; + let mut builder = PatchBuilder::new(db, syntax); + builder.add_str("{"); + + let args = arg_list.arguments(db).elements(db); + + if args.len() < 2 || args.len() > 3 { + return InlinePluginResult { + code: None, + diagnostics: vec![PluginDiagnostic { + stable_ptr: arg_list.arguments(db).stable_ptr().untyped(), + message: "Invalid arguments. Expected \"emit!(world, (events,))\"".to_string(), + severity: Severity::Error, + }], + }; + } + + let world = &args[0]; + + let ast::ArgClause::Unnamed(models) = args[1].arg_clause(db) else { + return unsupported_arg_diagnostic(db, syntax); + }; + + let mut bundle = vec![]; + + match models.value(db) { + ast::Expr::Parenthesized(parens) => { + let syntax_node = parens.expr(db).as_syntax_node(); + bundle.push((syntax_node.get_text(db), syntax_node)); + } + ast::Expr::Tuple(list) => { + list.expressions(db) + .elements(db) + .into_iter() + .for_each(|expr| { + let syntax_node = expr.as_syntax_node(); + bundle.push((syntax_node.get_text(db), syntax_node)); + }) + } + ast::Expr::StructCtorCall(ctor) => { + let syntax_node = ctor.as_syntax_node(); + bundle.push((syntax_node.get_text(db), syntax_node)); + } + _ => { + return InlinePluginResult { + code: None, + diagnostics: vec![PluginDiagnostic { + message: "Invalid arguments. Expected \"(world, (events,))\"".to_string(), + stable_ptr: arg_list.arguments(db).stable_ptr().untyped(), + severity: Severity::Error, + }], + }; + } + } + + if bundle.is_empty() { + return InlinePluginResult { + code: None, + diagnostics: vec![PluginDiagnostic { + message: "Invalid arguments: No models provided.".to_string(), + stable_ptr: arg_list.arguments(db).stable_ptr().untyped(), + severity: Severity::Error, + }], + }; + } + + for (event, _) in bundle { + builder.add_str("{"); + + builder.add_str( + " + let mut keys = Default::::default(); + let mut data = Default::::default();", + ); + + builder.add_str(&format!( + " + {EVENT_TRAIT}::append_keys_and_data(@{event}, ref keys, ref data);", + event = event + )); + + builder.add_str("\n "); + builder.add_node(world.as_syntax_node()); + builder.add_str(".emit(keys, data.span());"); + + builder.add_str("}"); + } + + builder.add_str("}"); + + let (code, code_mappings) = builder.build(); + + InlinePluginResult { + code: Some(PluginGeneratedFile { + name: "emit_inline_macro".into(), + content: code, + code_mappings, + aux_data: None, + }), + diagnostics: vec![], + } + } +} diff --git a/crates/compiler/src/inline_macros/get.rs b/crates/compiler/src/inline_macros/get.rs new file mode 100644 index 0000000..bf129ee --- /dev/null +++ b/crates/compiler/src/inline_macros/get.rs @@ -0,0 +1,119 @@ +use cairo_lang_defs::patcher::PatchBuilder; +use cairo_lang_defs::plugin::{ + InlineMacroExprPlugin, InlinePluginResult, MacroPluginMetadata, NamedPlugin, PluginDiagnostic, + PluginGeneratedFile, +}; +use cairo_lang_defs::plugin_utils::unsupported_bracket_diagnostic; +use cairo_lang_diagnostics::Severity; +use cairo_lang_syntax::node::ast::Expr; +use cairo_lang_syntax::node::{ast, TypedStablePtr, TypedSyntaxNode}; +use itertools::Itertools; + +use super::{extract_models, unsupported_arg_diagnostic, CAIRO_ERR_MSG_LEN}; + +#[derive(Debug, Default)] +pub struct GetMacro; + +impl NamedPlugin for GetMacro { + const NAME: &'static str = "get"; +} + +impl InlineMacroExprPlugin for GetMacro { + fn generate_code( + &self, + db: &dyn cairo_lang_syntax::node::db::SyntaxGroup, + syntax: &ast::ExprInlineMacro, + _metadata: &MacroPluginMetadata<'_>, + ) -> InlinePluginResult { + let ast::WrappedArgList::ParenthesizedArgList(arg_list) = syntax.arguments(db) else { + return unsupported_bracket_diagnostic(db, syntax); + }; + let mut builder = PatchBuilder::new(db, syntax); + builder.add_str( + "{ + let mut __get_macro_keys__ = core::array::ArrayTrait::new();\n", + ); + + let args = arg_list.arguments(db).elements(db); + + if args.len() != 3 { + return InlinePluginResult { + code: None, + diagnostics: vec![PluginDiagnostic { + stable_ptr: syntax.stable_ptr().untyped(), + message: "Invalid arguments. Expected \"get!(world, keys, (models,))\"" + .to_string(), + severity: Severity::Error, + }], + }; + } + + let world = &args[0]; + + let ast::ArgClause::Unnamed(keys) = args[1].arg_clause(db) else { + return unsupported_arg_diagnostic(db, syntax); + }; + + let ast::ArgClause::Unnamed(models) = args[2].arg_clause(db) else { + return unsupported_arg_diagnostic(db, syntax); + }; + let models = match extract_models(db, &models.value(db)) { + Ok(models) => models, + Err(diagnostic) => { + return InlinePluginResult { + code: None, + diagnostics: vec![diagnostic], + }; + } + }; + + if models.is_empty() { + return InlinePluginResult { + code: None, + diagnostics: vec![PluginDiagnostic { + stable_ptr: syntax.stable_ptr().untyped(), + message: "Model types cannot be empty".to_string(), + severity: Severity::Error, + }], + }; + } + + let args = match keys.value(db) { + Expr::Literal(literal) => format!("({})", literal.as_syntax_node().get_text(db)), + _ => keys.as_syntax_node().get_text(db), + }; + + builder.add_str(&format!( + "core::serde::Serde::serialize(@{args}, ref __get_macro_keys__); + let __get_macro_keys__ = core::array::ArrayTrait::span(@__get_macro_keys__);\n" + )); + + for model in &models { + let mut lookup_err_msg = format!("{} not found", model.to_string()); + lookup_err_msg.truncate(CAIRO_ERR_MSG_LEN); + + builder.add_str(&format!( + "\n + let __{model}: {model} = dojo::model::Model::get({}, __get_macro_keys__);\n", + world.as_syntax_node().get_text(db), + )); + } + builder.add_str(&format!( + "({}) + }}", + models.iter().map(|c| format!("__{c}")).join(",") + )); + + let (code, code_mappings) = builder.build(); + + InlinePluginResult { + code: Some(PluginGeneratedFile { + name: "get_inline_macro".into(), + content: code, + code_mappings, + aux_data: None, + }), + diagnostics: vec![], + } + } +} diff --git a/crates/compiler/src/inline_macros/get_models_test_class_hashes.rs b/crates/compiler/src/inline_macros/get_models_test_class_hashes.rs new file mode 100644 index 0000000..a9a8c9a --- /dev/null +++ b/crates/compiler/src/inline_macros/get_models_test_class_hashes.rs @@ -0,0 +1,109 @@ +use cairo_lang_defs::patcher::PatchBuilder; +use cairo_lang_defs::plugin::{ + InlineMacroExprPlugin, InlinePluginResult, MacroPluginMetadata, NamedPlugin, PluginDiagnostic, + PluginGeneratedFile, +}; +use cairo_lang_defs::plugin_utils::unsupported_bracket_diagnostic; +use cairo_lang_diagnostics::Severity; +use cairo_lang_syntax::node::{ast, TypedStablePtr, TypedSyntaxNode}; + +use super::unsupported_arg_diagnostic; +use super::utils::extract_namespaces; + +#[derive(Debug, Default)] +pub struct GetModelsTestClassHashes; + +impl NamedPlugin for GetModelsTestClassHashes { + const NAME: &'static str = "get_models_test_class_hashes"; +} + +impl InlineMacroExprPlugin for GetModelsTestClassHashes { + fn generate_code( + &self, + db: &dyn cairo_lang_syntax::node::db::SyntaxGroup, + syntax: &ast::ExprInlineMacro, + _metadata: &MacroPluginMetadata<'_>, + ) -> InlinePluginResult { + let ast::WrappedArgList::ParenthesizedArgList(arg_list) = syntax.arguments(db) else { + return unsupported_bracket_diagnostic(db, syntax); + }; + + let args = arg_list.arguments(db).elements(db); + + if args.len() > 1 { + return InlinePluginResult { + code: None, + diagnostics: vec![PluginDiagnostic { + stable_ptr: syntax.stable_ptr().untyped(), + message: "Invalid arguments. Expected \ + \"get_models_test_class_hashes!([\"ns1\", \"ns2\")]\" or \ + \"get_models_test_class_hashes!()\"." + .to_string(), + severity: Severity::Error, + }], + }; + } + + let _whitelisted_namespaces = if args.len() == 1 { + let ast::ArgClause::Unnamed(expected_array) = args[0].arg_clause(db) else { + return unsupported_arg_diagnostic(db, syntax); + }; + + match extract_namespaces(db, &expected_array.value(db)) { + Ok(namespaces) => namespaces, + Err(e) => { + return InlinePluginResult { + code: None, + diagnostics: vec![e], + }; + } + } + } else { + vec![] + }; + + let models: &[String] = &[]; + + /* let (_namespaces, models) = + match load_manifest_models_and_namespaces(metadata.cfg_set, &whitelisted_namespaces) { + Ok((namespaces, models)) => (namespaces, models), + Err(_e) => { + return InlinePluginResult { + code: None, + diagnostics: vec![PluginDiagnostic { + stable_ptr: syntax.stable_ptr().untyped(), + message: "Failed to load models and namespaces, ensure you have run \ + `sozo build` first." + .to_string(), + severity: Severity::Error, + }], + }; + } + }; + */ + let mut builder = PatchBuilder::new(db, syntax); + + // Use the TEST_CLASS_HASH for each model, which is already a qualified path, no `use` + // required. + builder.add_str(&format!( + "[{}].span()", + models + .iter() + .map(|m| format!("{}::TEST_CLASS_HASH", m)) + .collect::>() + .join(", ") + )); + + let (code, code_mappings) = builder.build(); + + InlinePluginResult { + code: Some(PluginGeneratedFile { + name: "get_models_test_class_hashes_macro".into(), + content: code, + code_mappings, + aux_data: None, + }), + diagnostics: vec![], + } + } +} diff --git a/crates/compiler/src/inline_macros/mod.rs b/crates/compiler/src/inline_macros/mod.rs new file mode 100644 index 0000000..5c90d35 --- /dev/null +++ b/crates/compiler/src/inline_macros/mod.rs @@ -0,0 +1,99 @@ +use cairo_lang_defs::plugin::{InlinePluginResult, PluginDiagnostic}; +use cairo_lang_diagnostics::Severity; +use cairo_lang_syntax::node::db::SyntaxGroup; +use cairo_lang_syntax::node::{ast, Terminal, TypedStablePtr, TypedSyntaxNode}; +use smol_str::SmolStr; + +pub mod delete; +pub mod emit; +pub mod get; +pub mod get_models_test_class_hashes; +pub mod selector_from_tag; +pub mod set; +pub mod spawn_test_world; +pub mod utils; + +const CAIRO_ERR_MSG_LEN: usize = 31; + +pub fn extract_models( + db: &dyn SyntaxGroup, + expression: &ast::Expr, +) -> Result, PluginDiagnostic> { + let mut models = vec![]; + match expression { + ast::Expr::Tuple(tuple) => { + for element in tuple.expressions(db).elements(db) { + match extract_models(db, &element) { + Ok(mut element_models) => models.append(&mut element_models), + Err(diagnostic) => return Err(diagnostic), + } + } + } + ast::Expr::Parenthesized(parenthesized) => { + match extract_models(db, &parenthesized.expr(db)) { + Ok(mut parenthesized_models) => models.append(&mut parenthesized_models), + Err(diagnostic) => return Err(diagnostic), + } + } + ast::Expr::Path(path) => match path.elements(db).last().unwrap() { + ast::PathSegment::WithGenericArgs(segment) => { + let generic = segment.generic_args(db); + + for param in generic.generic_args(db).elements(db) { + let ast::GenericArg::Unnamed(unnamed) = param else { + return Err(PluginDiagnostic { + stable_ptr: param.stable_ptr().untyped(), + message: "Should be an unnamed argument".to_string(), + severity: Severity::Error, + }); + }; + + let ast::GenericArgValue::Expr(expr) = unnamed.value(db) else { + return Err(PluginDiagnostic { + stable_ptr: unnamed.stable_ptr().untyped(), + message: "Should be an expression".to_string(), + severity: Severity::Error, + }); + }; + + match extract_models(db, &expr.expr(db)) { + Ok(mut expr_models) => models.append(&mut expr_models), + Err(diagnostic) => return Err(diagnostic), + } + } + } + ast::PathSegment::Simple(segment) => { + models.push(segment.ident(db).text(db)); + } + }, + _ => { + return Err(PluginDiagnostic { + stable_ptr: expression.stable_ptr().untyped(), + message: format!( + "Unsupported expression type: {}", + expression.as_syntax_node().get_text(db) + ), + severity: Severity::Error, + }); + } + } + + Ok(models) +} + +pub fn unsupported_arg_diagnostic( + db: &dyn SyntaxGroup, + macro_ast: &ast::ExprInlineMacro, +) -> InlinePluginResult { + InlinePluginResult { + code: None, + diagnostics: vec![PluginDiagnostic { + stable_ptr: macro_ast.stable_ptr().untyped(), + message: format!( + "Macro {} does not support this arg type", + macro_ast.path(db).as_syntax_node().get_text(db) + ), + severity: Severity::Error, + }], + } +} diff --git a/crates/compiler/src/inline_macros/selector_from_tag.rs b/crates/compiler/src/inline_macros/selector_from_tag.rs new file mode 100644 index 0000000..4145100 --- /dev/null +++ b/crates/compiler/src/inline_macros/selector_from_tag.rs @@ -0,0 +1,74 @@ +use cairo_lang_defs::patcher::PatchBuilder; +use cairo_lang_defs::plugin::{ + InlineMacroExprPlugin, InlinePluginResult, MacroPluginMetadata, NamedPlugin, PluginDiagnostic, + PluginGeneratedFile, +}; +use cairo_lang_defs::plugin_utils::unsupported_bracket_diagnostic; +use cairo_lang_diagnostics::Severity; +use cairo_lang_syntax::node::{ast, TypedStablePtr, TypedSyntaxNode}; +use dojo_types::naming; + +#[derive(Debug, Default)] +pub struct SelectorFromTagMacro; + +impl NamedPlugin for SelectorFromTagMacro { + const NAME: &'static str = "selector_from_tag"; +} + +impl InlineMacroExprPlugin for SelectorFromTagMacro { + fn generate_code( + &self, + db: &dyn cairo_lang_syntax::node::db::SyntaxGroup, + syntax: &ast::ExprInlineMacro, + _metadata: &MacroPluginMetadata<'_>, + ) -> InlinePluginResult { + let ast::WrappedArgList::ParenthesizedArgList(arg_list) = syntax.arguments(db) else { + return unsupported_bracket_diagnostic(db, syntax); + }; + + let args = arg_list.arguments(db).elements(db); + + if args.len() != 1 { + return InlinePluginResult { + code: None, + diagnostics: vec![PluginDiagnostic { + stable_ptr: syntax.stable_ptr().untyped(), + message: "Invalid arguments. Expected \"selector_from_tag!(\"tag\")\"" + .to_string(), + severity: Severity::Error, + }], + }; + } + + let tag = &args[0].as_syntax_node().get_text(db).replace('\"', ""); + + if !naming::is_valid_tag(tag) { + return InlinePluginResult { + code: None, + diagnostics: vec![PluginDiagnostic { + stable_ptr: syntax.stable_ptr().untyped(), + message: "Invalid tag. Tag must be in the format of `namespace-name`." + .to_string(), + severity: Severity::Error, + }], + }; + } + + let selector = naming::compute_selector_from_tag(tag); + + let mut builder = PatchBuilder::new(db, syntax); + builder.add_str(&format!("{:#64x}", selector)); + + let (code, code_mappings) = builder.build(); + + InlinePluginResult { + code: Some(PluginGeneratedFile { + name: "selector_from_tag_macro".into(), + content: code, + code_mappings, + aux_data: None, + }), + diagnostics: vec![], + } + } +} diff --git a/crates/compiler/src/inline_macros/set.rs b/crates/compiler/src/inline_macros/set.rs new file mode 100644 index 0000000..9b83d77 --- /dev/null +++ b/crates/compiler/src/inline_macros/set.rs @@ -0,0 +1,132 @@ +use cairo_lang_defs::patcher::PatchBuilder; +use cairo_lang_defs::plugin::{ + InlineMacroExprPlugin, InlinePluginResult, MacroPluginMetadata, NamedPlugin, PluginDiagnostic, + PluginGeneratedFile, +}; +use cairo_lang_defs::plugin_utils::unsupported_bracket_diagnostic; +use cairo_lang_diagnostics::Severity; +use cairo_lang_syntax::node::{ast, TypedStablePtr, TypedSyntaxNode}; + +use super::unsupported_arg_diagnostic; + +#[derive(Debug, Default)] +pub struct SetMacro; + +impl NamedPlugin for SetMacro { + const NAME: &'static str = "set"; + // Parents of set!() + // ----------------- + // StatementExpr + // StatementList + // ExprBlock + // FunctionWithBody + // ImplItemList + // ImplBody + // ItemImpl + // ItemList + // ModuleBody + // ItemModule + // ItemList + // SyntaxFile +} + +impl InlineMacroExprPlugin for SetMacro { + fn generate_code( + &self, + db: &dyn cairo_lang_syntax::node::db::SyntaxGroup, + syntax: &ast::ExprInlineMacro, + _metadata: &MacroPluginMetadata<'_>, + ) -> InlinePluginResult { + let ast::WrappedArgList::ParenthesizedArgList(arg_list) = syntax.arguments(db) else { + return unsupported_bracket_diagnostic(db, syntax); + }; + let mut builder = PatchBuilder::new(db, syntax); + builder.add_str("{"); + + let args = arg_list.arguments(db).elements(db); + + if args.len() != 2 { + return InlinePluginResult { + code: None, + diagnostics: vec![PluginDiagnostic { + stable_ptr: arg_list.arguments(db).stable_ptr().untyped(), + message: "Invalid arguments. Expected \"(world, (models,))\"".to_string(), + severity: Severity::Error, + }], + }; + } + + let world = &args[0]; + + let ast::ArgClause::Unnamed(models) = args[1].arg_clause(db) else { + return unsupported_arg_diagnostic(db, syntax); + }; + + let mut bundle = vec![]; + + match models.value(db) { + ast::Expr::Parenthesized(parens) => { + let syntax_node = parens.expr(db).as_syntax_node(); + bundle.push(syntax_node.get_text(db)); + } + ast::Expr::Tuple(list) => { + list.expressions(db) + .elements(db) + .into_iter() + .for_each(|expr| { + let syntax_node = expr.as_syntax_node(); + bundle.push(syntax_node.get_text(db)); + }) + } + ast::Expr::StructCtorCall(ctor) => { + let syntax_node = ctor.as_syntax_node(); + bundle.push(syntax_node.get_text(db)); + } + _ => { + return InlinePluginResult { + code: None, + diagnostics: vec![PluginDiagnostic { + message: "Invalid arguments. Expected \"(world, (models,))\"".to_string(), + stable_ptr: arg_list.arguments(db).stable_ptr().untyped(), + severity: Severity::Error, + }], + }; + } + } + + if bundle.is_empty() { + return InlinePluginResult { + code: None, + diagnostics: vec![PluginDiagnostic { + message: "Invalid arguments: No models provided.".to_string(), + stable_ptr: arg_list.arguments(db).stable_ptr().untyped(), + severity: Severity::Error, + }], + }; + } + + for entity in bundle { + builder.add_str(&format!( + " + let __set_model_instance__ = {}; + dojo::model::Model::set_model(@__set_model_instance__, {}); + ", + entity, + world.as_syntax_node().get_text(db), + )); + } + builder.add_str("}"); + + let (code, code_mappings) = builder.build(); + + InlinePluginResult { + code: Some(PluginGeneratedFile { + name: "set_inline_macro".into(), + content: code, + code_mappings, + aux_data: None, + }), + diagnostics: vec![], + } + } +} diff --git a/crates/compiler/src/inline_macros/spawn_test_world.rs b/crates/compiler/src/inline_macros/spawn_test_world.rs new file mode 100644 index 0000000..4255848 --- /dev/null +++ b/crates/compiler/src/inline_macros/spawn_test_world.rs @@ -0,0 +1,111 @@ +use cairo_lang_defs::patcher::PatchBuilder; +use cairo_lang_defs::plugin::{ + InlineMacroExprPlugin, InlinePluginResult, MacroPluginMetadata, NamedPlugin, PluginDiagnostic, + PluginGeneratedFile, +}; +use cairo_lang_defs::plugin_utils::unsupported_bracket_diagnostic; +use cairo_lang_diagnostics::Severity; +use cairo_lang_syntax::node::{ast, TypedStablePtr, TypedSyntaxNode}; + +use super::unsupported_arg_diagnostic; +use super::utils::extract_namespaces; + +#[derive(Debug, Default)] +pub struct SpawnTestWorld; + +impl NamedPlugin for SpawnTestWorld { + const NAME: &'static str = "spawn_test_world"; +} + +impl InlineMacroExprPlugin for SpawnTestWorld { + fn generate_code( + &self, + db: &dyn cairo_lang_syntax::node::db::SyntaxGroup, + syntax: &ast::ExprInlineMacro, + _metadata: &MacroPluginMetadata<'_>, + ) -> InlinePluginResult { + let ast::WrappedArgList::ParenthesizedArgList(arg_list) = syntax.arguments(db) else { + return unsupported_bracket_diagnostic(db, syntax); + }; + + let args = arg_list.arguments(db).elements(db); + + if args.len() > 1 { + return InlinePluginResult { + code: None, + diagnostics: vec![PluginDiagnostic { + stable_ptr: syntax.stable_ptr().untyped(), + message: "Invalid arguments. Expected \"spawn_test_world!()\" or \ + \"spawn_test_world!([\"ns1\"])" + .to_string(), + severity: Severity::Error, + }], + }; + } + + let _whitelisted_namespaces = if args.len() == 1 { + let ast::ArgClause::Unnamed(expected_array) = args[0].arg_clause(db) else { + return unsupported_arg_diagnostic(db, syntax); + }; + + match extract_namespaces(db, &expected_array.value(db)) { + Ok(namespaces) => namespaces, + Err(e) => { + return InlinePluginResult { + code: None, + diagnostics: vec![e], + }; + } + } + } else { + vec![] + }; + + let namespaces: &[String] = &[]; + let models: &[String] = &[]; + /* let (namespaces, models) = + match load_manifest_models_and_namespaces(metadata.cfg_set, &whitelisted_namespaces) { + ok((namespaces, models)) => (namespaces, models), + err(_e) => { + return inlinepluginresult { + code: none, + diagnostics: vec![plugindiagnostic { + stable_ptr: syntax.stable_ptr().untyped(), + message: "failed to load models and namespaces, ensure you have run \ + `sozo build` first." + .to_string(), + severity: severity::error, + }], + }; + } + }; */ + + let mut builder = PatchBuilder::new(db, syntax); + + builder.add_str(&format!( + "dojo::utils::test::spawn_test_world([{}].span(), [{}].span())", + namespaces + .iter() + .map(|n| format!("\"{}\"", n)) + .collect::>() + .join(", "), + models + .iter() + .map(|m| format!("{}::TEST_CLASS_HASH", m)) + .collect::>() + .join(", ") + )); + + let (code, code_mappings) = builder.build(); + + InlinePluginResult { + code: Some(PluginGeneratedFile { + name: "spawn_test_world_macro".into(), + content: code, + code_mappings, + aux_data: None, + }), + diagnostics: vec![], + } + } +} diff --git a/crates/compiler/src/inline_macros/utils.rs b/crates/compiler/src/inline_macros/utils.rs new file mode 100644 index 0000000..f84120d --- /dev/null +++ b/crates/compiler/src/inline_macros/utils.rs @@ -0,0 +1,112 @@ +use cairo_lang_defs::plugin::PluginDiagnostic; +use cairo_lang_diagnostics::Severity; +use cairo_lang_filesystem::cfg::CfgSet; +use cairo_lang_syntax::node::ast::{self, ExprPath, ExprStructCtorCall}; +use cairo_lang_syntax::node::db::SyntaxGroup; +use cairo_lang_syntax::node::kind::SyntaxKind; +use cairo_lang_syntax::node::{SyntaxNode, TypedStablePtr, TypedSyntaxNode}; +use camino::Utf8PathBuf; + +use crate::namespace_config::DOJO_MANIFESTS_DIR_CFG_KEY; + +#[derive(Debug)] +pub enum SystemRWOpRecord { + StructCtor(ExprStructCtorCall), + Path(ExprPath), +} + +pub fn parent_of_kind( + db: &dyn cairo_lang_syntax::node::db::SyntaxGroup, + target: &SyntaxNode, + kind: SyntaxKind, +) -> Option { + let mut new_target = target.clone(); + while let Some(parent) = new_target.parent() { + if kind == parent.kind(db) { + return Some(parent); + } + new_target = parent; + } + None +} + +/// Reads all the models and namespaces from base manifests files. +/* pub fn load_manifest_models_and_namespaces( + cfg_set: &CfgSet, + whitelisted_namespaces: &[String], +) -> anyhow::Result<(Vec, Vec)> { + let dojo_manifests_dir = get_dojo_manifests_dir(cfg_set.clone())?; + + let base_dir = dojo_manifests_dir.join("base"); + let base_abstract_manifest = BaseManifest::load_from_path(&base_dir)?; + + let mut models = HashSet::new(); + let mut namespaces = HashSet::new(); + + for model in base_abstract_manifest.models { + let qualified_path = model.inner.qualified_path; + let namespace = naming::split_tag(&model.inner.tag)?.0; + + if !whitelisted_namespaces.is_empty() && !whitelisted_namespaces.contains(&namespace) { + continue; + } + + models.insert(qualified_path); + namespaces.insert(namespace); + } + + let models_vec: Vec = models.into_iter().collect(); + let namespaces_vec: Vec = namespaces.into_iter().collect(); + + Ok((namespaces_vec, models_vec)) +} + */ +/// Gets the dojo_manifests_dir from the cfg_set. +pub fn get_dojo_manifests_dir(cfg_set: CfgSet) -> anyhow::Result { + for cfg in cfg_set.into_iter() { + if cfg.key == DOJO_MANIFESTS_DIR_CFG_KEY { + return Ok(Utf8PathBuf::from(cfg.value.unwrap().as_str().to_string())); + } + } + + Err(anyhow::anyhow!("dojo_manifests_dir not found")) +} + +/// Extracts the namespaces from a fixed size array of strings. +pub fn extract_namespaces( + db: &dyn SyntaxGroup, + expression: &ast::Expr, +) -> Result, PluginDiagnostic> { + let mut namespaces = vec![]; + + match expression { + ast::Expr::FixedSizeArray(array) => { + for element in array.exprs(db).elements(db) { + if let ast::Expr::String(string_literal) = element { + namespaces.push( + string_literal + .as_syntax_node() + .get_text(db) + .replace('\"', ""), + ); + } else { + return Err(PluginDiagnostic { + stable_ptr: element.stable_ptr().untyped(), + message: "Expected a string literal".to_string(), + severity: Severity::Error, + }); + } + } + } + _ => { + return Err(PluginDiagnostic { + stable_ptr: expression.stable_ptr().untyped(), + message: "The list of namespaces should be a fixed size array of strings." + .to_string(), + severity: Severity::Error, + }); + } + } + + Ok(namespaces) +} diff --git a/crates/compiler/src/introspect/layout.rs b/crates/compiler/src/introspect/layout.rs new file mode 100644 index 0000000..d9238e4 --- /dev/null +++ b/crates/compiler/src/introspect/layout.rs @@ -0,0 +1,388 @@ +use cairo_lang_defs::plugin::PluginDiagnostic; +use cairo_lang_diagnostics::Severity; +use cairo_lang_syntax::node::ast::{Expr, ItemEnum, ItemStruct, OptionTypeClause, TypeClause}; +use cairo_lang_syntax::node::db::SyntaxGroup; +use cairo_lang_syntax::node::helpers::QueryAttrs; +use cairo_lang_syntax::node::{ids, Terminal, TypedSyntaxNode}; +use starknet::core::utils::get_selector_from_name; + +use super::utils::{ + get_array_item_type, get_tuple_item_types, is_array, is_byte_array, is_tuple, + is_unsupported_option_type, primitive_type_introspection, +}; + +/// build the full layout for every field in the Struct. +pub fn build_field_layouts( + db: &dyn SyntaxGroup, + diagnostics: &mut Vec, + struct_ast: &ItemStruct, +) -> String { + struct_ast + .members(db) + .elements(db) + .iter() + .filter_map(|m| { + if m.has_attr(db, "key") { + return None; + } + + let field_name = m.name(db).text(db); + let field_selector = get_selector_from_name(&field_name.to_string()).unwrap(); + let field_layout = get_layout_from_type_clause(db, diagnostics, &m.type_clause(db)); + Some(format!( + "dojo::model::FieldLayout {{ + selector: {field_selector}, + layout: {field_layout} + }}" + )) + }) + .collect::>() + .join(",\n") +} + +/// build the full layout for every variant in the Enum. +/// Note that every variant may have a different associated data type. +pub fn build_variant_layouts( + db: &dyn SyntaxGroup, + diagnostics: &mut Vec, + enum_ast: &ItemEnum, +) -> String { + enum_ast + .variants(db) + .elements(db) + .iter() + .enumerate() + .map(|(i, v)| { + let selector = format!("{i}"); + + let variant_layout = match v.type_clause(db) { + OptionTypeClause::Empty(_) => { + "dojo::model::Layout::Fixed(array![].span())".to_string() + } + OptionTypeClause::TypeClause(type_clause) => { + get_layout_from_type_clause(db, diagnostics, &type_clause) + } + }; + + format!( + "dojo::model::FieldLayout {{ + selector: {selector}, + layout: {variant_layout} + }}" + ) + }) + .collect::>() + .join(",\n") +} + +/// Build a field layout describing the provided type clause. +pub fn get_layout_from_type_clause( + db: &dyn SyntaxGroup, + diagnostics: &mut Vec, + type_clause: &TypeClause, +) -> String { + match type_clause.ty(db) { + Expr::Path(path) => { + let path_type = path.as_syntax_node().get_text(db); + build_item_layout_from_type(diagnostics, type_clause.stable_ptr().0, &path_type) + } + Expr::Tuple(expr) => { + let tuple_type = expr.as_syntax_node().get_text(db); + build_tuple_layout_from_type(diagnostics, type_clause.stable_ptr().0, &tuple_type) + } + _ => { + diagnostics.push(PluginDiagnostic { + stable_ptr: type_clause.stable_ptr().0, + message: "Unexpected expression for variant data type.".to_string(), + severity: Severity::Error, + }); + "ERROR".to_string() + } + } +} + +/// Build the array layout describing the provided array type. +/// item_type could be something like Array for example. +pub fn build_array_layout_from_type( + diagnostics: &mut Vec, + diagnostic_item: ids::SyntaxStablePtrId, + item_type: &str, +) -> String { + let array_item_type = get_array_item_type(item_type); + + if is_tuple(&array_item_type) { + format!( + "dojo::model::Layout::Array( + array![ + {} + ].span() + )", + build_item_layout_from_type(diagnostics, diagnostic_item, &array_item_type) + ) + } else if is_array(&array_item_type) { + format!( + "dojo::model::Layout::Array( + array![ + {} + ].span() + )", + build_array_layout_from_type(diagnostics, diagnostic_item, &array_item_type) + ) + } else { + format!( + "dojo::model::introspect::Introspect::<{}>::layout()", + item_type + ) + } +} + +/// Build the tuple layout describing the provided tuple type. +/// item_type could be something like (u8, u32, u128) for example. +pub fn build_tuple_layout_from_type( + diagnostics: &mut Vec, + diagnostic_item: ids::SyntaxStablePtrId, + item_type: &str, +) -> String { + let tuple_items = get_tuple_item_types(item_type) + .iter() + .map(|x| build_item_layout_from_type(diagnostics, diagnostic_item, x)) + .collect::>() + .join(",\n"); + format!( + "dojo::model::Layout::Tuple( + array![ + {} + ].span() + )", + tuple_items + ) +} + +/// Build the layout describing the provided type. +/// item_type could be any type (array, tuple, struct, ...) +pub fn build_item_layout_from_type( + diagnostics: &mut Vec, + diagnostic_item: ids::SyntaxStablePtrId, + item_type: &str, +) -> String { + if is_array(item_type) { + build_array_layout_from_type(diagnostics, diagnostic_item, item_type) + } else if is_tuple(item_type) { + build_tuple_layout_from_type(diagnostics, diagnostic_item, item_type) + } else { + // For Option, T cannot be a tuple + if is_unsupported_option_type(item_type) { + diagnostics.push(PluginDiagnostic { + stable_ptr: diagnostic_item, + message: "Option cannot be used with tuples. Prefer using a struct.".into(), + severity: Severity::Error, + }); + } + + format!( + "dojo::model::introspect::Introspect::<{}>::layout()", + item_type + ) + } +} + +pub fn is_custom_layout(layout: &str) -> bool { + layout.starts_with("dojo::model::introspect::Introspect::") +} + +pub fn build_packed_struct_layout( + db: &dyn SyntaxGroup, + diagnostics: &mut Vec, + struct_ast: &ItemStruct, +) -> String { + let layouts = struct_ast + .members(db) + .elements(db) + .iter() + .filter_map(|m| { + if m.has_attr(db, "key") { + return None; + } + + Some(get_packed_field_layout_from_type_clause( + db, + diagnostics, + &m.type_clause(db), + )) + }) + .flatten() + .collect::>(); + + if layouts.iter().any(|v| is_custom_layout(v.as_str())) { + generate_cairo_code_for_fixed_layout_with_custom_types(&layouts) + } else { + format!( + "dojo::model::Layout::Fixed( + array![ + {} + ].span() + )", + layouts.join(",") + ) + } +} + +pub fn generate_cairo_code_for_fixed_layout_with_custom_types(layouts: &[String]) -> String { + let layouts_repr = layouts + .iter() + .map(|l| { + if is_custom_layout(l) { + l.to_string() + } else { + format!("dojo::model::Layout::Fixed(array![{l}].span())") + } + }) + .collect::>() + .join(",\n"); + + format!( + "let mut layouts = array![ + {layouts_repr} + ]; + let mut merged_layout = ArrayTrait::::new(); + + loop {{ + match ArrayTrait::pop_front(ref layouts) {{ + Option::Some(mut layout) => {{ + match layout {{ + dojo::model::Layout::Fixed(mut l) => {{ + loop {{ + match SpanTrait::pop_front(ref l) {{ + Option::Some(x) => merged_layout.append(*x), + Option::None(_) => {{ break; }} + }}; + }}; + }}, + _ => panic!(\"A packed model layout must contain Fixed layouts only.\"), + }}; + }}, + Option::None(_) => {{ break; }} + }}; + }}; + + dojo::model::Layout::Fixed(merged_layout.span()) + ", + ) +} + +// +pub fn build_packed_enum_layout( + db: &dyn SyntaxGroup, + diagnostics: &mut Vec, + enum_ast: &ItemEnum, +) -> String { + // to be packable, all variants data must have the same size. + // as this point has already been checked before calling `build_packed_enum_layout`, + // just use the first variant to generate the fixed layout. + let elements = enum_ast.variants(db).elements(db); + let mut variant_layout = if elements.is_empty() { + vec![] + } else { + match elements.first().unwrap().type_clause(db) { + OptionTypeClause::Empty(_) => vec![], + OptionTypeClause::TypeClause(type_clause) => { + get_packed_field_layout_from_type_clause(db, diagnostics, &type_clause) + } + } + }; + + // don't forget the store the variant value + variant_layout.insert(0, "8".to_string()); + + if variant_layout.iter().any(|v| is_custom_layout(v.as_str())) { + generate_cairo_code_for_fixed_layout_with_custom_types(&variant_layout) + } else { + format!( + "dojo::model::Layout::Fixed( + array![ + {} + ].span() + )", + variant_layout.join(",") + ) + } +} + +// +pub fn get_packed_field_layout_from_type_clause( + db: &dyn SyntaxGroup, + diagnostics: &mut Vec, + type_clause: &TypeClause, +) -> Vec { + match type_clause.ty(db) { + Expr::Path(path) => { + let path_type = path.as_syntax_node().get_text(db); + get_packed_item_layout_from_type( + diagnostics, + type_clause.stable_ptr().0, + path_type.trim(), + ) + } + Expr::Tuple(expr) => { + let tuple_type = expr.as_syntax_node().get_text(db); + get_packed_tuple_layout_from_type(diagnostics, type_clause.stable_ptr().0, &tuple_type) + } + _ => { + diagnostics.push(PluginDiagnostic { + stable_ptr: type_clause.stable_ptr().0, + message: "Unexpected expression for variant data type.".to_string(), + severity: Severity::Error, + }); + vec!["ERROR".to_string()] + } + } +} + +// +pub fn get_packed_item_layout_from_type( + diagnostics: &mut Vec, + diagnostic_item: ids::SyntaxStablePtrId, + item_type: &str, +) -> Vec { + if is_array(item_type) || is_byte_array(item_type) { + diagnostics.push(PluginDiagnostic { + stable_ptr: diagnostic_item, + message: "Array field cannot be packed.".into(), + severity: Severity::Error, + }); + vec!["ERROR".to_string()] + } else if is_tuple(item_type) { + get_packed_tuple_layout_from_type(diagnostics, diagnostic_item, item_type) + } else { + let primitives = primitive_type_introspection(); + + if let Some(p) = primitives.get(item_type) { + vec![p + .1 + .iter() + .map(|x| x.to_string()) + .collect::>() + .join(",")] + } else { + // as we cannot verify that an enum/struct custom type is packable, + // we suppose it is and let the user verify this. + // If it's not the case, the Dojo model layout function will panic. + vec![format!( + "dojo::model::introspect::Introspect::<{}>::layout()", + item_type + )] + } + } +} + +// +pub fn get_packed_tuple_layout_from_type( + diagnostics: &mut Vec, + diagnostic_item: ids::SyntaxStablePtrId, + item_type: &str, +) -> Vec { + get_tuple_item_types(item_type) + .iter() + .flat_map(|x| get_packed_item_layout_from_type(diagnostics, diagnostic_item, x)) + .collect::>() +} diff --git a/crates/compiler/src/introspect/mod.rs b/crates/compiler/src/introspect/mod.rs new file mode 100644 index 0000000..f18e04e --- /dev/null +++ b/crates/compiler/src/introspect/mod.rs @@ -0,0 +1,166 @@ +use cairo_lang_defs::patcher::RewriteNode; +use cairo_lang_defs::plugin::PluginDiagnostic; +use cairo_lang_diagnostics::Severity; +use cairo_lang_syntax::node::ast::{ + GenericParam, ItemEnum, ItemStruct, OptionWrappedGenericParamList, +}; +use cairo_lang_syntax::node::db::SyntaxGroup; +use cairo_lang_syntax::node::{Terminal, TypedSyntaxNode}; +use cairo_lang_utils::unordered_hash_map::UnorderedHashMap; + +mod layout; +mod size; +mod ty; +mod utils; + +/// Generate the introspect of a Struct +pub fn handle_introspect_struct( + db: &dyn SyntaxGroup, + diagnostics: &mut Vec, + struct_ast: ItemStruct, + packed: bool, +) -> RewriteNode { + let struct_name = struct_ast.name(db).text(db).into(); + let struct_size = size::compute_struct_layout_size(db, &struct_ast, packed); + let ty = ty::build_struct_ty(db, &struct_name, &struct_ast); + + let layout = if packed { + layout::build_packed_struct_layout(db, diagnostics, &struct_ast) + } else { + format!( + "dojo::model::Layout::Struct( + array![ + {} + ].span() + )", + layout::build_field_layouts(db, diagnostics, &struct_ast) + ) + }; + + let (gen_types, gen_impls) = build_generic_types_and_impls(db, struct_ast.generic_params(db)); + + generate_introspect( + &struct_name, + &struct_size, + &gen_types, + gen_impls, + &layout, + &ty, + ) +} + +/// Generate the introspect of a Enum +pub fn handle_introspect_enum( + db: &dyn SyntaxGroup, + diagnostics: &mut Vec, + enum_ast: ItemEnum, + packed: bool, +) -> RewriteNode { + let enum_name = enum_ast.name(db).text(db).into(); + let variant_sizes = size::compute_enum_variant_sizes(db, &enum_ast); + + let layout = if packed { + if size::is_enum_packable(&variant_sizes) { + layout::build_packed_enum_layout(db, diagnostics, &enum_ast) + } else { + diagnostics.push(PluginDiagnostic { + stable_ptr: enum_ast.name(db).stable_ptr().0, + message: "To be packed, all variants must have fixed layout of same size." + .to_string(), + severity: Severity::Error, + }); + "ERROR".to_string() + } + } else { + format!( + "dojo::model::Layout::Enum( + array![ + {} + ].span() + )", + layout::build_variant_layouts(db, diagnostics, &enum_ast) + ) + }; + + let (gen_types, gen_impls) = build_generic_types_and_impls(db, enum_ast.generic_params(db)); + let enum_size = size::compute_enum_layout_size(&variant_sizes, packed); + let ty = ty::build_enum_ty(db, &enum_name, &enum_ast); + + generate_introspect(&enum_name, &enum_size, &gen_types, gen_impls, &layout, &ty) +} + +/// Generate the introspect impl for a Struct or an Enum, +/// based on its name, size, layout and Ty. +fn generate_introspect( + name: &String, + size: &String, + generic_types: &[String], + generic_impls: String, + layout: &String, + ty: &String, +) -> RewriteNode { + RewriteNode::interpolate_patched( + " +impl $name$Introspect<$generics$> of dojo::model::introspect::Introspect<$name$<$generics_types$>> \ + { + #[inline(always)] + fn size() -> Option { + $size$ + } + + fn layout() -> dojo::model::Layout { + $layout$ + } + + #[inline(always)] + fn ty() -> dojo::model::introspect::Ty { + $ty$ + } +} + ", + &UnorderedHashMap::from([ + ("name".to_string(), RewriteNode::Text(name.to_string())), + ("generics".to_string(), RewriteNode::Text(generic_impls)), + ( + "generics_types".to_string(), + RewriteNode::Text(generic_types.join(", ")), + ), + ("size".to_string(), RewriteNode::Text(size.to_string())), + ("layout".to_string(), RewriteNode::Text(layout.to_string())), + ("ty".to_string(), RewriteNode::Text(ty.to_string())), + ]), + ) +} + +// Extract generic type information and build the +// type and impl information to add to the generated introspect +fn build_generic_types_and_impls( + db: &dyn SyntaxGroup, + generic_params: OptionWrappedGenericParamList, +) -> (Vec, String) { + let generic_types = + if let OptionWrappedGenericParamList::WrappedGenericParamList(params) = generic_params { + params + .generic_params(db) + .elements(db) + .iter() + .filter_map(|el| { + if let GenericParam::Type(typ) = el { + Some(typ.name(db).text(db).to_string()) + } else { + None + } + }) + .collect::>() + } else { + vec![] + }; + + let generic_impls = generic_types + .iter() + .map(|g| format!("{g}, impl {g}Introspect: dojo::model::introspect::Introspect<{g}>")) + .collect::>() + .join(", "); + + (generic_types, generic_impls) +} diff --git a/crates/compiler/src/introspect/size.rs b/crates/compiler/src/introspect/size.rs new file mode 100644 index 0000000..3fe9c5c --- /dev/null +++ b/crates/compiler/src/introspect/size.rs @@ -0,0 +1,204 @@ +use cairo_lang_syntax::node::ast::{Expr, ItemEnum, ItemStruct, OptionTypeClause, TypeClause}; +use cairo_lang_syntax::node::db::SyntaxGroup; +use cairo_lang_syntax::node::helpers::QueryAttrs; +use cairo_lang_syntax::node::TypedSyntaxNode; + +use super::utils::{ + get_tuple_item_types, is_array, is_byte_array, is_tuple, primitive_type_introspection, +}; + +pub fn compute_struct_layout_size( + db: &dyn SyntaxGroup, + struct_ast: &ItemStruct, + is_packed: bool, +) -> String { + let mut cumulated_sizes = 0; + let mut is_dynamic_size = false; + + let mut sizes = struct_ast + .members(db) + .elements(db) + .into_iter() + .filter_map(|m| { + if m.has_attr(db, "key") { + return None; + } + + let (sizes, cumulated, is_dynamic) = + get_field_size_from_type_clause(db, &m.type_clause(db)); + + cumulated_sizes += cumulated; + is_dynamic_size |= is_dynamic; + Some(sizes) + }) + .flatten() + .collect::>(); + build_size_function_body(&mut sizes, cumulated_sizes, is_dynamic_size, is_packed) +} + +pub fn compute_enum_variant_sizes( + db: &dyn SyntaxGroup, + enum_ast: &ItemEnum, +) -> Vec<(Vec, u32, bool)> { + enum_ast + .variants(db) + .elements(db) + .iter() + .map(|v| match v.type_clause(db) { + OptionTypeClause::Empty(_) => (vec![], 0, false), + OptionTypeClause::TypeClause(type_clause) => { + get_field_size_from_type_clause(db, &type_clause) + } + }) + .collect::>() +} + +pub fn is_enum_packable(variant_sizes: &[(Vec, u32, bool)]) -> bool { + if variant_sizes.is_empty() { + return true; + } + + let v0_sizes = variant_sizes[0].0.clone(); + let v0_fixed_size = variant_sizes[0].1; + + variant_sizes.iter().all(|vs| { + vs.0.len() == v0_sizes.len() + && vs.0.iter().zip(v0_sizes.iter()).all(|(a, b)| a == b) + && vs.1 == v0_fixed_size + && !vs.2 + }) +} + +pub fn compute_enum_layout_size( + variant_sizes: &[(Vec, u32, bool)], + is_packed: bool, +) -> String { + if variant_sizes.is_empty() { + return "Option::None".to_string(); + } + + let v0 = variant_sizes[0].clone(); + let identical_variants = variant_sizes + .iter() + .all(|vs| vs.0 == v0.0 && vs.1 == v0.1 && vs.2 == v0.2); + + if identical_variants { + let (mut sizes, mut cumulated_sizes, is_dynamic_size) = v0; + + // add one felt252 to store the variant identifier + cumulated_sizes += 1; + + build_size_function_body(&mut sizes, cumulated_sizes, is_dynamic_size, is_packed) + } else { + "Option::None".to_string() + } +} + +pub fn build_size_function_body( + sizes: &mut Vec, + cumulated_sizes: u32, + is_dynamic_size: bool, + is_packed: bool, +) -> String { + if is_dynamic_size { + return "Option::None".to_string(); + } + + if cumulated_sizes > 0 { + sizes.push(format!("Option::Some({})", cumulated_sizes)); + } + + match sizes.len() { + 0 => "Option::None".to_string(), + 1 => sizes[0].clone(), + _ => { + let none_check = if is_packed { + "" + } else { + "if dojo::utils::any_none(@sizes) { + return Option::None; + }" + }; + + format!( + "let sizes : Array> = array![ + {} + ]; + + {none_check} + Option::Some(dojo::utils::sum(sizes)) + ", + sizes.join(",\n") + ) + } + } +} + +pub fn get_field_size_from_type_clause( + db: &dyn SyntaxGroup, + type_clause: &TypeClause, +) -> (Vec, u32, bool) { + let mut cumulated_sizes = 0; + let mut is_dynamic_size = false; + + let field_sizes = match type_clause.ty(db) { + Expr::Path(path) => { + let path_type = path.as_syntax_node().get_text(db).trim().to_string(); + compute_item_size_from_type(&path_type) + } + Expr::Tuple(expr) => { + let tuple_type = expr.as_syntax_node().get_text(db).trim().to_string(); + compute_tuple_size_from_type(&tuple_type) + } + _ => { + // field type already checked while building the layout + vec!["ERROR".to_string()] + } + }; + + let sizes = field_sizes + .into_iter() + .filter_map(|s| match s.parse::() { + Ok(v) => { + cumulated_sizes += v; + None + } + Err(_) => { + if s.eq("Option::None") { + is_dynamic_size = true; + None + } else { + Some(s) + } + } + }) + .collect::>(); + + (sizes, cumulated_sizes, is_dynamic_size) +} + +pub fn compute_item_size_from_type(item_type: &String) -> Vec { + if is_array(item_type) || is_byte_array(item_type) { + vec!["Option::None".to_string()] + } else if is_tuple(item_type) { + compute_tuple_size_from_type(item_type) + } else { + let primitives = primitive_type_introspection(); + + if let Some(p) = primitives.get(item_type) { + vec![p.0.to_string()] + } else { + vec![format!( + "dojo::model::introspect::Introspect::<{}>::size()", + item_type + )] + } + } +} + +pub fn compute_tuple_size_from_type(tuple_type: &str) -> Vec { + get_tuple_item_types(tuple_type) + .iter() + .flat_map(compute_item_size_from_type) + .collect::>() +} diff --git a/crates/compiler/src/introspect/ty.rs b/crates/compiler/src/introspect/ty.rs new file mode 100644 index 0000000..adefa6d --- /dev/null +++ b/crates/compiler/src/introspect/ty.rs @@ -0,0 +1,144 @@ +use cairo_lang_syntax::node::ast::{ + Expr, ItemEnum, ItemStruct, Member, OptionTypeClause, TypeClause, Variant, +}; +use cairo_lang_syntax::node::db::SyntaxGroup; +use cairo_lang_syntax::node::helpers::QueryAttrs; +use cairo_lang_syntax::node::{Terminal, TypedSyntaxNode}; + +use super::utils::{get_array_item_type, get_tuple_item_types, is_array, is_byte_array, is_tuple}; + +pub fn build_struct_ty(db: &dyn SyntaxGroup, name: &String, struct_ast: &ItemStruct) -> String { + let members_ty = struct_ast + .members(db) + .elements(db) + .iter() + .map(|m| build_member_ty(db, m)) + .collect::>(); + + format!( + "dojo::model::introspect::Ty::Struct( + dojo::model::introspect::Struct {{ + name: '{name}', + attrs: array![].span(), + children: array![ + {}\n + ].span() + }} + )", + members_ty.join(",\n") + ) +} + +pub fn build_enum_ty(db: &dyn SyntaxGroup, name: &String, enum_ast: &ItemEnum) -> String { + let variants = enum_ast.variants(db).elements(db); + + let variants_ty = if variants.is_empty() { + "".to_string() + } else { + variants + .iter() + .map(|v| build_variant_ty(db, v)) + .collect::>() + .join(",\n") + }; + + format!( + "dojo::model::introspect::Ty::Enum( + dojo::model::introspect::Enum {{ + name: '{name}', + attrs: array![].span(), + children: array![ + {variants_ty}\n + ].span() + }} + )" + ) +} + +pub fn build_member_ty(db: &dyn SyntaxGroup, member: &Member) -> String { + let name = member.name(db).text(db).to_string(); + let attrs = if member.has_attr(db, "key") { + vec!["'key'"] + } else { + vec![] + }; + + format!( + "dojo::model::introspect::Member {{ + name: '{name}', + attrs: array![{}].span(), + ty: {} + }}", + attrs.join(","), + build_ty_from_type_clause(db, &member.type_clause(db)) + ) +} + +pub fn build_variant_ty(db: &dyn SyntaxGroup, variant: &Variant) -> String { + let name = variant.name(db).text(db).to_string(); + match variant.type_clause(db) { + OptionTypeClause::Empty(_) => { + // use an empty tuple if the variant has no data + format!("('{name}', dojo::model::introspect::Ty::Tuple(array![].span()))") + } + OptionTypeClause::TypeClause(type_clause) => { + format!( + "('{name}', {})", + build_ty_from_type_clause(db, &type_clause) + ) + } + } +} + +pub fn build_ty_from_type_clause(db: &dyn SyntaxGroup, type_clause: &TypeClause) -> String { + match type_clause.ty(db) { + Expr::Path(path) => { + let path_type = path.as_syntax_node().get_text(db).trim().to_string(); + build_item_ty_from_type(&path_type) + } + Expr::Tuple(expr) => { + let tuple_type = expr.as_syntax_node().get_text(db).trim().to_string(); + build_tuple_ty_from_type(&tuple_type) + } + _ => { + // diagnostic message already handled in layout building + "ERROR".to_string() + } + } +} + +pub fn build_item_ty_from_type(item_type: &String) -> String { + if is_array(item_type) { + let array_item_type = get_array_item_type(item_type); + format!( + "dojo::model::introspect::Ty::Array( + array![ + {} + ].span() + )", + build_item_ty_from_type(&array_item_type) + ) + } else if is_byte_array(item_type) { + "dojo::model::introspect::Ty::ByteArray".to_string() + } else if is_tuple(item_type) { + build_tuple_ty_from_type(item_type) + } else { + format!("dojo::model::introspect::Introspect::<{}>::ty()", item_type) + } +} + +pub fn build_tuple_ty_from_type(item_type: &str) -> String { + let tuple_items = get_tuple_item_types(item_type) + .iter() + .map(build_item_ty_from_type) + .collect::>() + .join(",\n"); + format!( + "dojo::model::introspect::Ty::Tuple( + array![ + {} + ].span() + )", + tuple_items + ) +} diff --git a/crates/compiler/src/introspect/utils.rs b/crates/compiler/src/introspect/utils.rs new file mode 100644 index 0000000..f2f586c --- /dev/null +++ b/crates/compiler/src/introspect/utils.rs @@ -0,0 +1,148 @@ +use std::collections::HashMap; + +#[derive(Clone, Default, Debug)] +pub struct TypeIntrospection(pub usize, pub Vec); + +// Provides type introspection information for primitive types +pub fn primitive_type_introspection() -> HashMap { + HashMap::from([ + ("felt252".into(), TypeIntrospection(1, vec![251])), + ("bool".into(), TypeIntrospection(1, vec![1])), + ("u8".into(), TypeIntrospection(1, vec![8])), + ("u16".into(), TypeIntrospection(1, vec![16])), + ("u32".into(), TypeIntrospection(1, vec![32])), + ("u64".into(), TypeIntrospection(1, vec![64])), + ("u128".into(), TypeIntrospection(1, vec![128])), + ("u256".into(), TypeIntrospection(2, vec![128, 128])), + ("usize".into(), TypeIntrospection(1, vec![32])), + ("ContractAddress".into(), TypeIntrospection(1, vec![251])), + ("ClassHash".into(), TypeIntrospection(1, vec![251])), + ]) +} + +/// Check if the provided type is an unsupported Option, +/// because tuples are not supported with Option. +pub fn is_unsupported_option_type(ty: &str) -> bool { + ty.starts_with("Option<(") +} + +pub fn is_byte_array(ty: &str) -> bool { + ty.eq("ByteArray") +} + +pub fn is_array(ty: &str) -> bool { + ty.starts_with("Array<") || ty.starts_with("Span<") +} + +pub fn is_tuple(ty: &str) -> bool { + ty.starts_with('(') +} + +pub fn get_array_item_type(ty: &str) -> String { + if ty.starts_with("Array<") { + ty.trim() + .strip_prefix("Array<") + .unwrap() + .strip_suffix('>') + .unwrap() + .to_string() + } else { + ty.trim() + .strip_prefix("Span<") + .unwrap() + .strip_suffix('>') + .unwrap() + .to_string() + } +} + +/// split a tuple in array of items (nested tuples are not splitted). +/// example (u8, (u16, u32), u128) -> ["u8", "(u16, u32)", "u128"] +pub fn get_tuple_item_types(ty: &str) -> Vec { + let tuple_str = ty + .trim() + .strip_prefix('(') + .unwrap() + .strip_suffix(')') + .unwrap() + .to_string() + .replace(' ', ""); + let mut items = vec![]; + let mut current_item = "".to_string(); + let mut level = 0; + + for c in tuple_str.chars() { + if c == ',' { + if level > 0 { + current_item.push(c); + } + + if level == 0 && !current_item.is_empty() { + items.push(current_item); + current_item = "".to_string(); + } + } else { + current_item.push(c); + + if c == '(' { + level += 1; + } + if c == ')' { + level -= 1; + } + } + } + + if !current_item.is_empty() { + items.push(current_item); + } + + items +} + +#[test] +pub fn test_get_tuple_item_types() { + pub fn assert_array(got: Vec, expected: Vec) { + pub fn format_array(arr: Vec) -> String { + format!("[{}]", arr.join(", ")) + } + + assert!( + got.len() == expected.len(), + "arrays have not the same length (got: {}, expected: {})", + format_array(got), + format_array(expected) + ); + + for i in 0..got.len() { + assert!( + got[i] == expected[i], + "unexpected array item: (got: {} expected: {})", + got[i], + expected[i] + ) + } + } + + let test_cases = vec![ + ("(u8,)", vec!["u8"]), + ("(u8, u16, u32)", vec!["u8", "u16", "u32"]), + ("(u8, (u16,), u32)", vec!["u8", "(u16,)", "u32"]), + ("(u8, (u16, (u8, u16)))", vec!["u8", "(u16,(u8,u16))"]), + ( + "(Array<(Points, Damage)>, ((u16,),)))", + vec!["Array<(Points,Damage)>", "((u16,),))"], + ), + ( + "(u8, (u16, (u8, u16), Array<(Points, Damage)>), ((u16,),)))", + vec!["u8", "(u16,(u8,u16),Array<(Points,Damage)>)", "((u16,),))"], + ), + ]; + + for (value, expected) in test_cases { + assert_array( + get_tuple_item_types(value), + expected.iter().map(|x| x.to_string()).collect::>(), + ) + } +} diff --git a/crates/compiler/src/lib.rs b/crates/compiler/src/lib.rs new file mode 100644 index 0000000..db26c16 --- /dev/null +++ b/crates/compiler/src/lib.rs @@ -0,0 +1,18 @@ +//! Dojo compiler. +//! +//! This crate contains the Dojo compiler, with a cairo plugin for the Cairo language. +pub mod attribute_macros; +pub mod compiler; +pub mod inline_macros; +pub mod introspect; +pub mod namespace_config; +pub mod plugin; +pub mod print; +pub mod semantics; +pub mod syntax; +pub mod utils; +pub(crate) mod version; + +// Copy of non pub functions from scarb + extension. +// Also used by `sozo`. +pub mod scarb_internal; diff --git a/crates/compiler/src/manifest_test_data/cairo_v240 b/crates/compiler/src/manifest_test_data/cairo_v240 new file mode 100644 index 0000000..acedda3 --- /dev/null +++ b/crates/compiler/src/manifest_test_data/cairo_v240 @@ -0,0 +1,993 @@ +//! > Test for cairo v2.4.0 compatibility + +//! > test_runner_name +test_compiler_cairo_v240 + +//! > expected_manifest_file +{ + "world": { + "name": "dojo::world::world", + "address": null, + "class_hash": "0x2206663eed57fb406a3557c3dbe650451af6f271af4acdcb5cb2e2279249f66", + "abi": [ + { + "type": "impl", + "name": "World", + "interface_name": "dojo::world::IWorld" + }, + { + "type": "struct", + "name": "core::array::Span::", + "members": [ + { + "name": "snapshot", + "type": "@core::array::Array::" + } + ] + }, + { + "type": "struct", + "name": "dojo::model::resource_metadata::ResourceMetadata", + "members": [ + { + "name": "resource_id", + "type": "core::felt252" + }, + { + "name": "metadata_uri", + "type": "core::array::Span::" + } + ] + }, + { + "type": "struct", + "name": "core::array::Span::", + "members": [ + { + "name": "snapshot", + "type": "@core::array::Array::" + } + ] + }, + { + "type": "enum", + "name": "core::bool", + "variants": [ + { + "name": "False", + "type": "()" + }, + { + "name": "True", + "type": "()" + } + ] + }, + { + "type": "interface", + "name": "dojo::world::IWorld", + "items": [ + { + "type": "function", + "name": "metadata", + "inputs": [ + { + "name": "resource_id", + "type": "core::felt252" + } + ], + "outputs": [ + { + "type": "dojo::model::resource_metadata::ResourceMetadata" + } + ], + "state_mutability": "view" + }, + { + "type": "function", + "name": "set_metadata", + "inputs": [ + { + "name": "metadata", + "type": "dojo::model::resource_metadata::ResourceMetadata" + } + ], + "outputs": [], + "state_mutability": "external" + }, + { + "type": "function", + "name": "model", + "inputs": [ + { + "name": "selector", + "type": "core::felt252" + } + ], + "outputs": [ + { + "type": "(core::starknet::class_hash::ClassHash, core::starknet::contract_address::ContractAddress)" + } + ], + "state_mutability": "view" + }, + { + "type": "function", + "name": "register_model", + "inputs": [ + { + "name": "class_hash", + "type": "core::starknet::class_hash::ClassHash" + } + ], + "outputs": [], + "state_mutability": "external" + }, + { + "type": "function", + "name": "deploy_contract", + "inputs": [ + { + "name": "salt", + "type": "core::felt252" + }, + { + "name": "class_hash", + "type": "core::starknet::class_hash::ClassHash" + } + ], + "outputs": [ + { + "type": "core::starknet::contract_address::ContractAddress" + } + ], + "state_mutability": "external" + }, + { + "type": "function", + "name": "upgrade_contract", + "inputs": [ + { + "name": "address", + "type": "core::starknet::contract_address::ContractAddress" + }, + { + "name": "class_hash", + "type": "core::starknet::class_hash::ClassHash" + } + ], + "outputs": [ + { + "type": "core::starknet::class_hash::ClassHash" + } + ], + "state_mutability": "external" + }, + { + "type": "function", + "name": "uuid", + "inputs": [], + "outputs": [ + { + "type": "core::integer::u32" + } + ], + "state_mutability": "external" + }, + { + "type": "function", + "name": "emit", + "inputs": [ + { + "name": "keys", + "type": "core::array::Array::" + }, + { + "name": "values", + "type": "core::array::Span::" + } + ], + "outputs": [], + "state_mutability": "view" + }, + { + "type": "function", + "name": "entity", + "inputs": [ + { + "name": "model", + "type": "core::felt252" + }, + { + "name": "keys", + "type": "core::array::Span::" + }, + { + "name": "layout", + "type": "core::array::Span::" + } + ], + "outputs": [ + { + "type": "core::array::Span::" + } + ], + "state_mutability": "view" + }, + { + "type": "function", + "name": "set_entity", + "inputs": [ + { + "name": "model", + "type": "core::felt252" + }, + { + "name": "keys", + "type": "core::array::Span::" + }, + { + "name": "values", + "type": "core::array::Span::" + }, + { + "name": "layout", + "type": "core::array::Span::" + } + ], + "outputs": [], + "state_mutability": "external" + }, + { + "type": "function", + "name": "base", + "inputs": [], + "outputs": [ + { + "type": "core::starknet::class_hash::ClassHash" + } + ], + "state_mutability": "view" + }, + { + "type": "function", + "name": "delete_entity", + "inputs": [ + { + "name": "model", + "type": "core::felt252" + }, + { + "name": "keys", + "type": "core::array::Span::" + }, + { + "name": "layout", + "type": "core::array::Span::" + } + ], + "outputs": [], + "state_mutability": "external" + }, + { + "type": "function", + "name": "is_owner", + "inputs": [ + { + "name": "address", + "type": "core::starknet::contract_address::ContractAddress" + }, + { + "name": "resource", + "type": "core::felt252" + } + ], + "outputs": [ + { + "type": "core::bool" + } + ], + "state_mutability": "view" + }, + { + "type": "function", + "name": "grant_owner", + "inputs": [ + { + "name": "address", + "type": "core::starknet::contract_address::ContractAddress" + }, + { + "name": "resource", + "type": "core::felt252" + } + ], + "outputs": [], + "state_mutability": "external" + }, + { + "type": "function", + "name": "revoke_owner", + "inputs": [ + { + "name": "address", + "type": "core::starknet::contract_address::ContractAddress" + }, + { + "name": "resource", + "type": "core::felt252" + } + ], + "outputs": [], + "state_mutability": "external" + }, + { + "type": "function", + "name": "is_writer", + "inputs": [ + { + "name": "model", + "type": "core::felt252" + }, + { + "name": "contract", + "type": "core::starknet::contract_address::ContractAddress" + } + ], + "outputs": [ + { + "type": "core::bool" + } + ], + "state_mutability": "view" + }, + { + "type": "function", + "name": "grant_writer", + "inputs": [ + { + "name": "model", + "type": "core::felt252" + }, + { + "name": "contract", + "type": "core::starknet::contract_address::ContractAddress" + } + ], + "outputs": [], + "state_mutability": "external" + }, + { + "type": "function", + "name": "revoke_writer", + "inputs": [ + { + "name": "model", + "type": "core::felt252" + }, + { + "name": "contract", + "type": "core::starknet::contract_address::ContractAddress" + } + ], + "outputs": [], + "state_mutability": "external" + } + ] + }, + { + "type": "impl", + "name": "UpgradeableWorld", + "interface_name": "dojo::world::IUpgradeableWorld" + }, + { + "type": "interface", + "name": "dojo::world::IUpgradeableWorld", + "items": [ + { + "type": "function", + "name": "upgrade", + "inputs": [ + { + "name": "new_class_hash", + "type": "core::starknet::class_hash::ClassHash" + } + ], + "outputs": [], + "state_mutability": "external" + } + ] + }, + { + "type": "constructor", + "name": "constructor", + "inputs": [ + { + "name": "contract_base", + "type": "core::starknet::class_hash::ClassHash" + } + ] + }, + { + "type": "event", + "name": "dojo::world::world::WorldSpawned", + "kind": "struct", + "members": [ + { + "name": "address", + "type": "core::starknet::contract_address::ContractAddress", + "kind": "data" + }, + { + "name": "creator", + "type": "core::starknet::contract_address::ContractAddress", + "kind": "data" + } + ] + }, + { + "type": "event", + "name": "dojo::world::world::ContractDeployed", + "kind": "struct", + "members": [ + { + "name": "salt", + "type": "core::felt252", + "kind": "data" + }, + { + "name": "class_hash", + "type": "core::starknet::class_hash::ClassHash", + "kind": "data" + }, + { + "name": "address", + "type": "core::starknet::contract_address::ContractAddress", + "kind": "data" + } + ] + }, + { + "type": "event", + "name": "dojo::world::world::ContractUpgraded", + "kind": "struct", + "members": [ + { + "name": "class_hash", + "type": "core::starknet::class_hash::ClassHash", + "kind": "data" + }, + { + "name": "address", + "type": "core::starknet::contract_address::ContractAddress", + "kind": "data" + } + ] + }, + { + "type": "event", + "name": "dojo::world::world::WorldUpgraded", + "kind": "struct", + "members": [ + { + "name": "class_hash", + "type": "core::starknet::class_hash::ClassHash", + "kind": "data" + } + ] + }, + { + "type": "event", + "name": "dojo::world::world::MetadataUpdate", + "kind": "struct", + "members": [ + { + "name": "resource", + "type": "core::felt252", + "kind": "data" + }, + { + "name": "uri", + "type": "core::array::Span::", + "kind": "data" + } + ] + }, + { + "type": "event", + "name": "dojo::world::world::ModelRegistered", + "kind": "struct", + "members": [ + { + "name": "selector", + "type": "core::felt252", + "kind": "data" + }, + { + "name": "class_hash", + "type": "core::starknet::class_hash::ClassHash", + "kind": "data" + }, + { + "name": "prev_class_hash", + "type": "core::starknet::class_hash::ClassHash", + "kind": "data" + }, + { + "name": "address", + "type": "core::starknet::contract_address::ContractAddress", + "kind": "data" + }, + { + "name": "prev_address", + "type": "core::starknet::contract_address::ContractAddress", + "kind": "data" + } + ] + }, + { + "type": "event", + "name": "dojo::world::world::StoreSetRecord", + "kind": "struct", + "members": [ + { + "name": "table", + "type": "core::felt252", + "kind": "data" + }, + { + "name": "keys", + "type": "core::array::Span::", + "kind": "data" + }, + { + "name": "values", + "type": "core::array::Span::", + "kind": "data" + } + ] + }, + { + "type": "event", + "name": "dojo::world::world::StoreDelRecord", + "kind": "struct", + "members": [ + { + "name": "table", + "type": "core::felt252", + "kind": "data" + }, + { + "name": "keys", + "type": "core::array::Span::", + "kind": "data" + } + ] + }, + { + "type": "event", + "name": "dojo::world::world::WriterUpdated", + "kind": "struct", + "members": [ + { + "name": "model", + "type": "core::felt252", + "kind": "data" + }, + { + "name": "contract", + "type": "core::starknet::contract_address::ContractAddress", + "kind": "data" + }, + { + "name": "value", + "type": "core::bool", + "kind": "data" + } + ] + }, + { + "type": "event", + "name": "dojo::world::world::OwnerUpdated", + "kind": "struct", + "members": [ + { + "name": "address", + "type": "core::starknet::contract_address::ContractAddress", + "kind": "data" + }, + { + "name": "resource", + "type": "core::felt252", + "kind": "data" + }, + { + "name": "value", + "type": "core::bool", + "kind": "data" + } + ] + }, + { + "type": "event", + "name": "dojo::world::world::Event", + "kind": "enum", + "variants": [ + { + "name": "WorldSpawned", + "type": "dojo::world::world::WorldSpawned", + "kind": "nested" + }, + { + "name": "ContractDeployed", + "type": "dojo::world::world::ContractDeployed", + "kind": "nested" + }, + { + "name": "ContractUpgraded", + "type": "dojo::world::world::ContractUpgraded", + "kind": "nested" + }, + { + "name": "WorldUpgraded", + "type": "dojo::world::world::WorldUpgraded", + "kind": "nested" + }, + { + "name": "MetadataUpdate", + "type": "dojo::world::world::MetadataUpdate", + "kind": "nested" + }, + { + "name": "ModelRegistered", + "type": "dojo::world::world::ModelRegistered", + "kind": "nested" + }, + { + "name": "StoreSetRecord", + "type": "dojo::world::world::StoreSetRecord", + "kind": "nested" + }, + { + "name": "StoreDelRecord", + "type": "dojo::world::world::StoreDelRecord", + "kind": "nested" + }, + { + "name": "WriterUpdated", + "type": "dojo::world::world::WriterUpdated", + "kind": "nested" + }, + { + "name": "OwnerUpdated", + "type": "dojo::world::world::OwnerUpdated", + "kind": "nested" + } + ] + } + ], + "reads": [], + "writes": [], + "computed": [] + }, + "base": { + "name": "dojo::base::base", + "class_hash": "0x794d5ed2f7eb970f92e0ed9be8f73bbbdf18f7db2a9a296fa12c2d9c33e6ab3", + "abi": [ + { + "type": "impl", + "name": "WorldProviderImpl", + "interface_name": "dojo::world::IWorldProvider" + }, + { + "type": "struct", + "name": "dojo::world::IWorldDispatcher", + "members": [ + { + "name": "contract_address", + "type": "core::starknet::contract_address::ContractAddress" + } + ] + }, + { + "type": "interface", + "name": "dojo::world::IWorldProvider", + "items": [ + { + "type": "function", + "name": "world", + "inputs": [], + "outputs": [ + { + "type": "dojo::world::IWorldDispatcher" + } + ], + "state_mutability": "view" + } + ] + }, + { + "type": "impl", + "name": "UpgradableImpl", + "interface_name": "dojo::contract::upgradeable::IUpgradeable" + }, + { + "type": "interface", + "name": "dojo::contract::upgradeable::IUpgradeable", + "items": [ + { + "type": "function", + "name": "upgrade", + "inputs": [ + { + "name": "new_class_hash", + "type": "core::starknet::class_hash::ClassHash" + } + ], + "outputs": [], + "state_mutability": "external" + } + ] + }, + { + "type": "constructor", + "name": "constructor", + "inputs": [] + }, + { + "type": "event", + "name": "dojo::contract::upgradeable::upgradeable::Upgraded", + "kind": "struct", + "members": [ + { + "name": "class_hash", + "type": "core::starknet::class_hash::ClassHash", + "kind": "data" + } + ] + }, + { + "type": "event", + "name": "dojo::contract::upgradeable::upgradeable::Event", + "kind": "enum", + "variants": [ + { + "name": "Upgraded", + "type": "dojo::contract::upgradeable::upgradeable::Upgraded", + "kind": "nested" + } + ] + }, + { + "type": "event", + "name": "dojo::base::base::Event", + "kind": "enum", + "variants": [ + { + "name": "UpgradeableEvent", + "type": "dojo::contract::upgradeable::upgradeable::Event", + "kind": "nested" + } + ] + } + ] + }, + "resource_metadata": { + "name": "dojo::model::resource_metadata::resource_metadata", + "address": null, + "class_hash": "0x6a2f06cde4aad60e0b6dd595edebe8dca1fbefe5b36cfc2f46a1d1159757df9", + "abi": [ + { + "type": "function", + "name": "name", + "inputs": [], + "outputs": [ + { + "type": "core::felt252" + } + ], + "state_mutability": "view" + }, + { + "type": "function", + "name": "unpacked_size", + "inputs": [], + "outputs": [ + { + "type": "core::integer::u32" + } + ], + "state_mutability": "view" + }, + { + "type": "function", + "name": "packed_size", + "inputs": [], + "outputs": [ + { + "type": "core::integer::u32" + } + ], + "state_mutability": "view" + }, + { + "type": "struct", + "name": "core::array::Span::", + "members": [ + { + "name": "snapshot", + "type": "@core::array::Array::" + } + ] + }, + { + "type": "function", + "name": "layout", + "inputs": [], + "outputs": [ + { + "type": "core::array::Span::" + } + ], + "state_mutability": "view" + }, + { + "type": "struct", + "name": "core::array::Span::", + "members": [ + { + "name": "snapshot", + "type": "@core::array::Array::" + } + ] + }, + { + "type": "struct", + "name": "core::array::Span::>", + "members": [ + { + "name": "snapshot", + "type": "@core::array::Array::>" + } + ] + }, + { + "type": "struct", + "name": "dojo::model::introspect::Struct", + "members": [ + { + "name": "name", + "type": "core::felt252" + }, + { + "name": "attrs", + "type": "core::array::Span::" + }, + { + "name": "children", + "type": "core::array::Span::>" + } + ] + }, + { + "type": "struct", + "name": "core::array::Span::<(core::felt252, core::array::Span::)>", + "members": [ + { + "name": "snapshot", + "type": "@core::array::Array::<(core::felt252, core::array::Span::)>" + } + ] + }, + { + "type": "struct", + "name": "dojo::model::introspect::Enum", + "members": [ + { + "name": "name", + "type": "core::felt252" + }, + { + "name": "attrs", + "type": "core::array::Span::" + }, + { + "name": "children", + "type": "core::array::Span::<(core::felt252, core::array::Span::)>" + } + ] + }, + { + "type": "enum", + "name": "dojo::model::introspect::Ty", + "variants": [ + { + "name": "Primitive", + "type": "core::felt252" + }, + { + "name": "Struct", + "type": "dojo::model::introspect::Struct" + }, + { + "name": "Enum", + "type": "dojo::model::introspect::Enum" + }, + { + "name": "Tuple", + "type": "core::array::Span::>" + }, + { + "name": "Array", + "type": "core::integer::u32" + } + ] + }, + { + "type": "function", + "name": "schema", + "inputs": [], + "outputs": [ + { + "type": "dojo::model::introspect::Ty" + } + ], + "state_mutability": "view" + }, + { + "type": "struct", + "name": "dojo::model::resource_metadata::ResourceMetadata", + "members": [ + { + "name": "resource_id", + "type": "core::felt252" + }, + { + "name": "metadata_uri", + "type": "core::array::Span::" + } + ] + }, + { + "type": "function", + "name": "ensure_abi", + "inputs": [ + { + "name": "model", + "type": "dojo::model::resource_metadata::ResourceMetadata" + } + ], + "outputs": [], + "state_mutability": "view" + }, + { + "type": "event", + "name": "dojo::model::resource_metadata::resource_metadata::Event", + "kind": "enum", + "variants": [] + } + ], + "reads": [], + "writes": [], + "computed": [] + }, + "contracts": [ + { + "name": "cairo_v240::cairo_v240", + "address": null, + "class_hash": "0x6517f8b97f269ae354fabcafe7428eda4ce60efbecc55dad8ac662144b8f469", + "abi": [ + { + "type": "event", + "name": "cairo_v240::cairo_v240::Event", + "kind": "enum", + "variants": [] + } + ], + "reads": [], + "writes": [], + "computed": [] + } + ], + "models": [] +} diff --git a/crates/compiler/src/manifest_test_data/compiler_cairo/.gitignore b/crates/compiler/src/manifest_test_data/compiler_cairo/.gitignore new file mode 100644 index 0000000..eb5a316 --- /dev/null +++ b/crates/compiler/src/manifest_test_data/compiler_cairo/.gitignore @@ -0,0 +1 @@ +target diff --git a/crates/compiler/src/manifest_test_data/compiler_cairo/Scarb.lock b/crates/compiler/src/manifest_test_data/compiler_cairo/Scarb.lock new file mode 100644 index 0000000..16e1680 --- /dev/null +++ b/crates/compiler/src/manifest_test_data/compiler_cairo/Scarb.lock @@ -0,0 +1,13 @@ +# Code generated by scarb DO NOT EDIT. +version = 1 + +[[package]] +name = "compiler_cairo" +version = "0.1.0" +dependencies = [ + "dojo", +] + +[[package]] +name = "dojo" +version = "1.0.0-alpha.4" diff --git a/crates/compiler/src/manifest_test_data/compiler_cairo/Scarb.toml b/crates/compiler/src/manifest_test_data/compiler_cairo/Scarb.toml new file mode 100644 index 0000000..5f63e29 --- /dev/null +++ b/crates/compiler/src/manifest_test_data/compiler_cairo/Scarb.toml @@ -0,0 +1,16 @@ +[package] +name = "compiler_cairo" +version = "0.1.0" +edition = "2024_07" +cairo-version = "2.7.0" + +# See more keys and their definitions at https://docs.swmansion.com/scarb/docs/reference/manifest.html + +[cairo] +sierra-replace-ids = true + +[dependencies] +dojo = { path = "../../../../dojo-core" } + +[[target.dojo]] +build-external-contracts = [ ] diff --git a/crates/compiler/src/manifest_test_data/compiler_cairo/dojo_dev.toml b/crates/compiler/src/manifest_test_data/compiler_cairo/dojo_dev.toml new file mode 100644 index 0000000..e3776ae --- /dev/null +++ b/crates/compiler/src/manifest_test_data/compiler_cairo/dojo_dev.toml @@ -0,0 +1,10 @@ +[world] +description = "Cairo compiler features" +name = "compiler_cairo_features" +seed = "compiler_cairo_features" + +[namespace] +default = "ccf" + +[env] +rpc_url = "http://localhost:5050/" diff --git a/crates/compiler/src/manifest_test_data/compiler_cairo/src/cairo_24.cairo b/crates/compiler/src/manifest_test_data/compiler_cairo/src/cairo_24.cairo new file mode 100644 index 0000000..0235b49 --- /dev/null +++ b/crates/compiler/src/manifest_test_data/compiler_cairo/src/cairo_24.cairo @@ -0,0 +1,57 @@ +//! Cairo 2.4.0 feature testing. +#[starknet::contract] +mod cairo_v240 { + use core::fmt::Formatter; + + #[storage] + struct Storage {} + + fn byte_array(self: @ContractState) -> ByteArray { + let mut ba: ByteArray = ""; + ba.append_word('ABCDEFGHIJKLMNOPQRSTUVWXYZ12345', 31); + ba.append_byte(0x65); + + let mut bc: ByteArray = ""; + bc.append(@ba); + + bc + } + + fn formatter(self: @ContractState) { + let var = 5; + let mut formatter: Formatter = Default::default(); + write!(formatter, "test").unwrap(); + write!(formatter, "{var:?}").unwrap(); + println!("{}", formatter.buffer); //prints test5 + } + + fn format(self: @ContractState) { + let var1 = 5; + let var2: ByteArray = "hello"; + let var3 = 5_u32; + let _ba = format!("{},{},{}", var1, var2, var3); + let _ba = format!("{var1}{var2}{var3}"); + let _ba = format!("{var1:?}{var2:?}{var3:?}"); + } + + fn long_panic(self: @ContractState) { + panic!("this should not be reached, but at least I'm not limited to 31 characters anymore") + } + + #[derive(Drop, Debug, PartialEq)] + struct MyStruct { + a: u8, + b: u8 + } + + fn asserts(self: @ContractState) { + let var1 = 5; + let var2 = 6; + assert!(var1 != var2, "should not be equal"); + assert!(var1 != var2, "{},{} should not be equal", var1, var2); + + let first = MyStruct { a: 1, b: 2 }; + let second = MyStruct { a: 1, b: 2 }; + assert!(first == second, "should be equal"); + } +} diff --git a/crates/compiler/src/manifest_test_data/compiler_cairo/src/cairo_26.cairo b/crates/compiler/src/manifest_test_data/compiler_cairo/src/cairo_26.cairo new file mode 100644 index 0000000..3eb6ba8 --- /dev/null +++ b/crates/compiler/src/manifest_test_data/compiler_cairo/src/cairo_26.cairo @@ -0,0 +1,53 @@ +//! Cairo 2.6.0 feature testing. +#[starknet::contract] +mod cairo_v260 { + // Constants. + enum ThreeOptions { + A: felt252, + B: (u256, u256), + C, + } + + struct ThreeOptionsPair { + a: ThreeOptions, + b: ThreeOptions, + } + + const V: ThreeOptionsPair = ThreeOptionsPair { + a: ThreeOptions::A(1337), + b: ThreeOptions::C, + }; + + #[storage] + struct Storage {} + + #[derive(Drop)] + enum MyEnum { + Foo, + Bar + } + + fn if_let() { + let number = Option::Some(5); + let foo_or_bar = MyEnum::Foo; + + if let Option::Some(i) = number { + println!("{}", i); + } + + if let MyEnum::Bar = foo_or_bar { + println!("bar"); + } + } + + fn while_let(mut arr: Array) -> felt252 { + let mut sum = 0; + while let Option::Some(x) = arr.pop_front() { + sum += x; + }; + sum + } + + fn const_reference() -> ThreeOptionsPair { V } + fn const_box() -> Box { BoxTrait::new(V) } +} diff --git a/crates/compiler/src/manifest_test_data/compiler_cairo/src/lib.cairo b/crates/compiler/src/manifest_test_data/compiler_cairo/src/lib.cairo new file mode 100644 index 0000000..bf8bc5f --- /dev/null +++ b/crates/compiler/src/manifest_test_data/compiler_cairo/src/lib.cairo @@ -0,0 +1,2 @@ +mod cairo_24; +mod cairo_26; diff --git a/crates/compiler/src/manifest_test_data/manifest b/crates/compiler/src/manifest_test_data/manifest new file mode 100644 index 0000000..d1a8d40 --- /dev/null +++ b/crates/compiler/src/manifest_test_data/manifest @@ -0,0 +1,1735 @@ +//! > Test generated manifest file + +//! > test_runner_name +test_manifest_file + +//! > expected_manifest_file +{ + "world": { + "name": "dojo::world::world", + "address": null, + "class_hash": "0x2206663eed57fb406a3557c3dbe650451af6f271af4acdcb5cb2e2279249f66", + "abi": [ + { + "type": "impl", + "name": "World", + "interface_name": "dojo::world::IWorld" + }, + { + "type": "struct", + "name": "core::array::Span::", + "members": [ + { + "name": "snapshot", + "type": "@core::array::Array::" + } + ] + }, + { + "type": "struct", + "name": "dojo::model::resource_metadata::ResourceMetadata", + "members": [ + { + "name": "resource_id", + "type": "core::felt252" + }, + { + "name": "metadata_uri", + "type": "core::array::Span::" + } + ] + }, + { + "type": "struct", + "name": "core::array::Span::", + "members": [ + { + "name": "snapshot", + "type": "@core::array::Array::" + } + ] + }, + { + "type": "enum", + "name": "core::bool", + "variants": [ + { + "name": "False", + "type": "()" + }, + { + "name": "True", + "type": "()" + } + ] + }, + { + "type": "interface", + "name": "dojo::world::IWorld", + "items": [ + { + "type": "function", + "name": "metadata", + "inputs": [ + { + "name": "resource_id", + "type": "core::felt252" + } + ], + "outputs": [ + { + "type": "dojo::model::resource_metadata::ResourceMetadata" + } + ], + "state_mutability": "view" + }, + { + "type": "function", + "name": "set_metadata", + "inputs": [ + { + "name": "metadata", + "type": "dojo::model::resource_metadata::ResourceMetadata" + } + ], + "outputs": [], + "state_mutability": "external" + }, + { + "type": "function", + "name": "model", + "inputs": [ + { + "name": "selector", + "type": "core::felt252" + } + ], + "outputs": [ + { + "type": "(core::starknet::class_hash::ClassHash, core::starknet::contract_address::ContractAddress)" + } + ], + "state_mutability": "view" + }, + { + "type": "function", + "name": "register_model", + "inputs": [ + { + "name": "class_hash", + "type": "core::starknet::class_hash::ClassHash" + } + ], + "outputs": [], + "state_mutability": "external" + }, + { + "type": "function", + "name": "deploy_contract", + "inputs": [ + { + "name": "salt", + "type": "core::felt252" + }, + { + "name": "class_hash", + "type": "core::starknet::class_hash::ClassHash" + } + ], + "outputs": [ + { + "type": "core::starknet::contract_address::ContractAddress" + } + ], + "state_mutability": "external" + }, + { + "type": "function", + "name": "upgrade_contract", + "inputs": [ + { + "name": "address", + "type": "core::starknet::contract_address::ContractAddress" + }, + { + "name": "class_hash", + "type": "core::starknet::class_hash::ClassHash" + } + ], + "outputs": [ + { + "type": "core::starknet::class_hash::ClassHash" + } + ], + "state_mutability": "external" + }, + { + "type": "function", + "name": "uuid", + "inputs": [], + "outputs": [ + { + "type": "core::integer::u32" + } + ], + "state_mutability": "external" + }, + { + "type": "function", + "name": "emit", + "inputs": [ + { + "name": "keys", + "type": "core::array::Array::" + }, + { + "name": "values", + "type": "core::array::Span::" + } + ], + "outputs": [], + "state_mutability": "view" + }, + { + "type": "function", + "name": "entity", + "inputs": [ + { + "name": "model", + "type": "core::felt252" + }, + { + "name": "keys", + "type": "core::array::Span::" + }, + { + "name": "layout", + "type": "core::array::Span::" + } + ], + "outputs": [ + { + "type": "core::array::Span::" + } + ], + "state_mutability": "view" + }, + { + "type": "function", + "name": "set_entity", + "inputs": [ + { + "name": "model", + "type": "core::felt252" + }, + { + "name": "keys", + "type": "core::array::Span::" + }, + { + "name": "values", + "type": "core::array::Span::" + }, + { + "name": "layout", + "type": "core::array::Span::" + } + ], + "outputs": [], + "state_mutability": "external" + }, + { + "type": "function", + "name": "base", + "inputs": [], + "outputs": [ + { + "type": "core::starknet::class_hash::ClassHash" + } + ], + "state_mutability": "view" + }, + { + "type": "function", + "name": "delete_entity", + "inputs": [ + { + "name": "model", + "type": "core::felt252" + }, + { + "name": "keys", + "type": "core::array::Span::" + }, + { + "name": "layout", + "type": "core::array::Span::" + } + ], + "outputs": [], + "state_mutability": "external" + }, + { + "type": "function", + "name": "is_owner", + "inputs": [ + { + "name": "address", + "type": "core::starknet::contract_address::ContractAddress" + }, + { + "name": "resource", + "type": "core::felt252" + } + ], + "outputs": [ + { + "type": "core::bool" + } + ], + "state_mutability": "view" + }, + { + "type": "function", + "name": "grant_owner", + "inputs": [ + { + "name": "address", + "type": "core::starknet::contract_address::ContractAddress" + }, + { + "name": "resource", + "type": "core::felt252" + } + ], + "outputs": [], + "state_mutability": "external" + }, + { + "type": "function", + "name": "revoke_owner", + "inputs": [ + { + "name": "address", + "type": "core::starknet::contract_address::ContractAddress" + }, + { + "name": "resource", + "type": "core::felt252" + } + ], + "outputs": [], + "state_mutability": "external" + }, + { + "type": "function", + "name": "is_writer", + "inputs": [ + { + "name": "model", + "type": "core::felt252" + }, + { + "name": "contract", + "type": "core::starknet::contract_address::ContractAddress" + } + ], + "outputs": [ + { + "type": "core::bool" + } + ], + "state_mutability": "view" + }, + { + "type": "function", + "name": "grant_writer", + "inputs": [ + { + "name": "model", + "type": "core::felt252" + }, + { + "name": "contract", + "type": "core::starknet::contract_address::ContractAddress" + } + ], + "outputs": [], + "state_mutability": "external" + }, + { + "type": "function", + "name": "revoke_writer", + "inputs": [ + { + "name": "model", + "type": "core::felt252" + }, + { + "name": "contract", + "type": "core::starknet::contract_address::ContractAddress" + } + ], + "outputs": [], + "state_mutability": "external" + } + ] + }, + { + "type": "impl", + "name": "UpgradeableWorld", + "interface_name": "dojo::world::IUpgradeableWorld" + }, + { + "type": "interface", + "name": "dojo::world::IUpgradeableWorld", + "items": [ + { + "type": "function", + "name": "upgrade", + "inputs": [ + { + "name": "new_class_hash", + "type": "core::starknet::class_hash::ClassHash" + } + ], + "outputs": [], + "state_mutability": "external" + } + ] + }, + { + "type": "constructor", + "name": "constructor", + "inputs": [ + { + "name": "contract_base", + "type": "core::starknet::class_hash::ClassHash" + } + ] + }, + { + "type": "event", + "name": "dojo::world::world::WorldSpawned", + "kind": "struct", + "members": [ + { + "name": "address", + "type": "core::starknet::contract_address::ContractAddress", + "kind": "data" + }, + { + "name": "creator", + "type": "core::starknet::contract_address::ContractAddress", + "kind": "data" + } + ] + }, + { + "type": "event", + "name": "dojo::world::world::ContractDeployed", + "kind": "struct", + "members": [ + { + "name": "salt", + "type": "core::felt252", + "kind": "data" + }, + { + "name": "class_hash", + "type": "core::starknet::class_hash::ClassHash", + "kind": "data" + }, + { + "name": "address", + "type": "core::starknet::contract_address::ContractAddress", + "kind": "data" + } + ] + }, + { + "type": "event", + "name": "dojo::world::world::ContractUpgraded", + "kind": "struct", + "members": [ + { + "name": "class_hash", + "type": "core::starknet::class_hash::ClassHash", + "kind": "data" + }, + { + "name": "address", + "type": "core::starknet::contract_address::ContractAddress", + "kind": "data" + } + ] + }, + { + "type": "event", + "name": "dojo::world::world::WorldUpgraded", + "kind": "struct", + "members": [ + { + "name": "class_hash", + "type": "core::starknet::class_hash::ClassHash", + "kind": "data" + } + ] + }, + { + "type": "event", + "name": "dojo::world::world::MetadataUpdate", + "kind": "struct", + "members": [ + { + "name": "resource", + "type": "core::felt252", + "kind": "data" + }, + { + "name": "uri", + "type": "core::array::Span::", + "kind": "data" + } + ] + }, + { + "type": "event", + "name": "dojo::world::world::ModelRegistered", + "kind": "struct", + "members": [ + { + "name": "selector", + "type": "core::felt252", + "kind": "data" + }, + { + "name": "class_hash", + "type": "core::starknet::class_hash::ClassHash", + "kind": "data" + }, + { + "name": "prev_class_hash", + "type": "core::starknet::class_hash::ClassHash", + "kind": "data" + }, + { + "name": "address", + "type": "core::starknet::contract_address::ContractAddress", + "kind": "data" + }, + { + "name": "prev_address", + "type": "core::starknet::contract_address::ContractAddress", + "kind": "data" + } + ] + }, + { + "type": "event", + "name": "dojo::world::world::StoreSetRecord", + "kind": "struct", + "members": [ + { + "name": "table", + "type": "core::felt252", + "kind": "data" + }, + { + "name": "keys", + "type": "core::array::Span::", + "kind": "data" + }, + { + "name": "values", + "type": "core::array::Span::", + "kind": "data" + } + ] + }, + { + "type": "event", + "name": "dojo::world::world::StoreDelRecord", + "kind": "struct", + "members": [ + { + "name": "table", + "type": "core::felt252", + "kind": "data" + }, + { + "name": "keys", + "type": "core::array::Span::", + "kind": "data" + } + ] + }, + { + "type": "event", + "name": "dojo::world::world::WriterUpdated", + "kind": "struct", + "members": [ + { + "name": "model", + "type": "core::felt252", + "kind": "data" + }, + { + "name": "contract", + "type": "core::starknet::contract_address::ContractAddress", + "kind": "data" + }, + { + "name": "value", + "type": "core::bool", + "kind": "data" + } + ] + }, + { + "type": "event", + "name": "dojo::world::world::OwnerUpdated", + "kind": "struct", + "members": [ + { + "name": "address", + "type": "core::starknet::contract_address::ContractAddress", + "kind": "data" + }, + { + "name": "resource", + "type": "core::felt252", + "kind": "data" + }, + { + "name": "value", + "type": "core::bool", + "kind": "data" + } + ] + }, + { + "type": "event", + "name": "dojo::world::world::Event", + "kind": "enum", + "variants": [ + { + "name": "WorldSpawned", + "type": "dojo::world::world::WorldSpawned", + "kind": "nested" + }, + { + "name": "ContractDeployed", + "type": "dojo::world::world::ContractDeployed", + "kind": "nested" + }, + { + "name": "ContractUpgraded", + "type": "dojo::world::world::ContractUpgraded", + "kind": "nested" + }, + { + "name": "WorldUpgraded", + "type": "dojo::world::world::WorldUpgraded", + "kind": "nested" + }, + { + "name": "MetadataUpdate", + "type": "dojo::world::world::MetadataUpdate", + "kind": "nested" + }, + { + "name": "ModelRegistered", + "type": "dojo::world::world::ModelRegistered", + "kind": "nested" + }, + { + "name": "StoreSetRecord", + "type": "dojo::world::world::StoreSetRecord", + "kind": "nested" + }, + { + "name": "StoreDelRecord", + "type": "dojo::world::world::StoreDelRecord", + "kind": "nested" + }, + { + "name": "WriterUpdated", + "type": "dojo::world::world::WriterUpdated", + "kind": "nested" + }, + { + "name": "OwnerUpdated", + "type": "dojo::world::world::OwnerUpdated", + "kind": "nested" + } + ] + } + ], + "reads": [], + "writes": [], + "computed": [] + }, + "base": { + "name": "dojo::base::base", + "class_hash": "0x794d5ed2f7eb970f92e0ed9be8f73bbbdf18f7db2a9a296fa12c2d9c33e6ab3", + "abi": [ + { + "type": "impl", + "name": "WorldProviderImpl", + "interface_name": "dojo::world::IWorldProvider" + }, + { + "type": "struct", + "name": "dojo::world::IWorldDispatcher", + "members": [ + { + "name": "contract_address", + "type": "core::starknet::contract_address::ContractAddress" + } + ] + }, + { + "type": "interface", + "name": "dojo::world::IWorldProvider", + "items": [ + { + "type": "function", + "name": "world", + "inputs": [], + "outputs": [ + { + "type": "dojo::world::IWorldDispatcher" + } + ], + "state_mutability": "view" + } + ] + }, + { + "type": "impl", + "name": "UpgradableImpl", + "interface_name": "dojo::contract::upgradeable::IUpgradeable" + }, + { + "type": "interface", + "name": "dojo::contract::upgradeable::IUpgradeable", + "items": [ + { + "type": "function", + "name": "upgrade", + "inputs": [ + { + "name": "new_class_hash", + "type": "core::starknet::class_hash::ClassHash" + } + ], + "outputs": [], + "state_mutability": "external" + } + ] + }, + { + "type": "constructor", + "name": "constructor", + "inputs": [] + }, + { + "type": "event", + "name": "dojo::contract::upgradeable::upgradeable::Upgraded", + "kind": "struct", + "members": [ + { + "name": "class_hash", + "type": "core::starknet::class_hash::ClassHash", + "kind": "data" + } + ] + }, + { + "type": "event", + "name": "dojo::contract::upgradeable::upgradeable::Event", + "kind": "enum", + "variants": [ + { + "name": "Upgraded", + "type": "dojo::contract::upgradeable::upgradeable::Upgraded", + "kind": "nested" + } + ] + }, + { + "type": "event", + "name": "dojo::base::base::Event", + "kind": "enum", + "variants": [ + { + "name": "UpgradeableEvent", + "type": "dojo::contract::upgradeable::upgradeable::Event", + "kind": "nested" + } + ] + } + ] + }, + "resource_metadata": { + "name": "dojo::model::resource_metadata::resource_metadata", + "address": null, + "class_hash": "0x6a2f06cde4aad60e0b6dd595edebe8dca1fbefe5b36cfc2f46a1d1159757df9", + "abi": [ + { + "type": "function", + "name": "name", + "inputs": [], + "outputs": [ + { + "type": "core::felt252" + } + ], + "state_mutability": "view" + }, + { + "type": "function", + "name": "unpacked_size", + "inputs": [], + "outputs": [ + { + "type": "core::integer::u32" + } + ], + "state_mutability": "view" + }, + { + "type": "function", + "name": "packed_size", + "inputs": [], + "outputs": [ + { + "type": "core::integer::u32" + } + ], + "state_mutability": "view" + }, + { + "type": "struct", + "name": "core::array::Span::", + "members": [ + { + "name": "snapshot", + "type": "@core::array::Array::" + } + ] + }, + { + "type": "function", + "name": "layout", + "inputs": [], + "outputs": [ + { + "type": "core::array::Span::" + } + ], + "state_mutability": "view" + }, + { + "type": "struct", + "name": "core::array::Span::", + "members": [ + { + "name": "snapshot", + "type": "@core::array::Array::" + } + ] + }, + { + "type": "struct", + "name": "core::array::Span::>", + "members": [ + { + "name": "snapshot", + "type": "@core::array::Array::>" + } + ] + }, + { + "type": "struct", + "name": "dojo::model::introspect::Struct", + "members": [ + { + "name": "name", + "type": "core::felt252" + }, + { + "name": "attrs", + "type": "core::array::Span::" + }, + { + "name": "children", + "type": "core::array::Span::>" + } + ] + }, + { + "type": "struct", + "name": "core::array::Span::<(core::felt252, core::array::Span::)>", + "members": [ + { + "name": "snapshot", + "type": "@core::array::Array::<(core::felt252, core::array::Span::)>" + } + ] + }, + { + "type": "struct", + "name": "dojo::model::introspect::Enum", + "members": [ + { + "name": "name", + "type": "core::felt252" + }, + { + "name": "attrs", + "type": "core::array::Span::" + }, + { + "name": "children", + "type": "core::array::Span::<(core::felt252, core::array::Span::)>" + } + ] + }, + { + "type": "enum", + "name": "dojo::model::introspect::Ty", + "variants": [ + { + "name": "Primitive", + "type": "core::felt252" + }, + { + "name": "Struct", + "type": "dojo::model::introspect::Struct" + }, + { + "name": "Enum", + "type": "dojo::model::introspect::Enum" + }, + { + "name": "Tuple", + "type": "core::array::Span::>" + }, + { + "name": "Array", + "type": "core::integer::u32" + } + ] + }, + { + "type": "function", + "name": "schema", + "inputs": [], + "outputs": [ + { + "type": "dojo::model::introspect::Ty" + } + ], + "state_mutability": "view" + }, + { + "type": "struct", + "name": "dojo::model::resource_metadata::ResourceMetadata", + "members": [ + { + "name": "resource_id", + "type": "core::felt252" + }, + { + "name": "metadata_uri", + "type": "core::array::Span::" + } + ] + }, + { + "type": "function", + "name": "ensure_abi", + "inputs": [ + { + "name": "model", + "type": "dojo::model::resource_metadata::ResourceMetadata" + } + ], + "outputs": [], + "state_mutability": "view" + }, + { + "type": "event", + "name": "dojo::model::resource_metadata::resource_metadata::Event", + "kind": "enum", + "variants": [] + } + ], + "reads": [], + "writes": [], + "computed": [] + }, + "contracts": [ + { + "name": "dojo_examples::actions::actions", + "address": null, + "class_hash": "0x14179d8db6fe166dff1a9746a39efb789a15643bc0c0afddce40d12caf4ecd6", + "abi": [ + { + "type": "impl", + "name": "DojoResourceProviderImpl", + "interface_name": "dojo::world::IDojoResourceProvider" + }, + { + "type": "interface", + "name": "dojo::world::IDojoResourceProvider", + "items": [ + { + "type": "function", + "name": "dojo_resource", + "inputs": [], + "outputs": [ + { + "type": "core::felt252" + } + ], + "state_mutability": "view" + } + ] + }, + { + "type": "impl", + "name": "WorldProviderImpl", + "interface_name": "dojo::world::IWorldProvider" + }, + { + "type": "struct", + "name": "dojo::world::IWorldDispatcher", + "members": [ + { + "name": "contract_address", + "type": "core::starknet::contract_address::ContractAddress" + } + ] + }, + { + "type": "interface", + "name": "dojo::world::IWorldProvider", + "items": [ + { + "type": "function", + "name": "world", + "inputs": [], + "outputs": [ + { + "type": "dojo::world::IWorldDispatcher" + } + ], + "state_mutability": "view" + } + ] + }, + { + "type": "impl", + "name": "ActionsComputedImpl", + "interface_name": "dojo_examples::actions::IActionsComputed" + }, + { + "type": "struct", + "name": "dojo_examples::models::Vec2", + "members": [ + { + "name": "x", + "type": "core::integer::u32" + }, + { + "name": "y", + "type": "core::integer::u32" + } + ] + }, + { + "type": "struct", + "name": "dojo_examples::models::Position", + "members": [ + { + "name": "player", + "type": "core::starknet::contract_address::ContractAddress" + }, + { + "name": "vec", + "type": "dojo_examples::models::Vec2" + } + ] + }, + { + "type": "interface", + "name": "dojo_examples::actions::IActionsComputed", + "items": [ + { + "type": "function", + "name": "tile_terrain", + "inputs": [ + { + "name": "vec", + "type": "dojo_examples::models::Vec2" + } + ], + "outputs": [ + { + "type": "core::felt252" + } + ], + "state_mutability": "view" + }, + { + "type": "function", + "name": "quadrant", + "inputs": [ + { + "name": "pos", + "type": "dojo_examples::models::Position" + } + ], + "outputs": [ + { + "type": "core::integer::u8" + } + ], + "state_mutability": "view" + } + ] + }, + { + "type": "impl", + "name": "ActionsImpl", + "interface_name": "dojo_examples::actions::IActions" + }, + { + "type": "enum", + "name": "dojo_examples::models::Direction", + "variants": [ + { + "name": "None", + "type": "()" + }, + { + "name": "Left", + "type": "()" + }, + { + "name": "Right", + "type": "()" + }, + { + "name": "Up", + "type": "()" + }, + { + "name": "Down", + "type": "()" + } + ] + }, + { + "type": "interface", + "name": "dojo_examples::actions::IActions", + "items": [ + { + "type": "function", + "name": "spawn", + "inputs": [], + "outputs": [], + "state_mutability": "view" + }, + { + "type": "function", + "name": "move", + "inputs": [ + { + "name": "direction", + "type": "dojo_examples::models::Direction" + } + ], + "outputs": [], + "state_mutability": "view" + } + ] + }, + { + "type": "impl", + "name": "UpgradableImpl", + "interface_name": "dojo::contract::upgradeable::IUpgradeable" + }, + { + "type": "interface", + "name": "dojo::contract::upgradeable::IUpgradeable", + "items": [ + { + "type": "function", + "name": "upgrade", + "inputs": [ + { + "name": "new_class_hash", + "type": "core::starknet::class_hash::ClassHash" + } + ], + "outputs": [], + "state_mutability": "external" + } + ] + }, + { + "type": "event", + "name": "dojo::contract::upgradeable::upgradeable::Upgraded", + "kind": "struct", + "members": [ + { + "name": "class_hash", + "type": "core::starknet::class_hash::ClassHash", + "kind": "data" + } + ] + }, + { + "type": "event", + "name": "dojo::contract::upgradeable::upgradeable::Event", + "kind": "enum", + "variants": [ + { + "name": "Upgraded", + "type": "dojo::contract::upgradeable::upgradeable::Upgraded", + "kind": "nested" + } + ] + }, + { + "type": "event", + "name": "dojo_examples::actions::actions::Moved", + "kind": "struct", + "members": [ + { + "name": "player", + "type": "core::starknet::contract_address::ContractAddress", + "kind": "data" + }, + { + "name": "direction", + "type": "dojo_examples::models::Direction", + "kind": "data" + } + ] + }, + { + "type": "event", + "name": "dojo_examples::actions::actions::Event", + "kind": "enum", + "variants": [ + { + "name": "UpgradeableEvent", + "type": "dojo::contract::upgradeable::upgradeable::Event", + "kind": "nested" + }, + { + "name": "Moved", + "type": "dojo_examples::actions::actions::Moved", + "kind": "nested" + } + ] + } + ], + "reads": [], + "writes": [], + "computed": [] + }, + { + "name": "dojo_examples::models::moves", + "address": null, + "class_hash": "0x5465e8310088418ac0d42bd49aba2b63b0857fbdec198a365a5e370358bc2d2", + "abi": [ + { + "type": "impl", + "name": "DojoModelImpl", + "interface_name": "dojo::model::IDojoModel" + }, + { + "type": "struct", + "name": "core::array::Span::", + "members": [ + { + "name": "snapshot", + "type": "@core::array::Array::" + } + ] + }, + { + "type": "struct", + "name": "core::array::Span::", + "members": [ + { + "name": "snapshot", + "type": "@core::array::Array::" + } + ] + }, + { + "type": "struct", + "name": "core::array::Span::>", + "members": [ + { + "name": "snapshot", + "type": "@core::array::Array::>" + } + ] + }, + { + "type": "struct", + "name": "dojo::model::introspect::Struct", + "members": [ + { + "name": "name", + "type": "core::felt252" + }, + { + "name": "attrs", + "type": "core::array::Span::" + }, + { + "name": "children", + "type": "core::array::Span::>" + } + ] + }, + { + "type": "struct", + "name": "core::array::Span::<(core::felt252, core::array::Span::)>", + "members": [ + { + "name": "snapshot", + "type": "@core::array::Array::<(core::felt252, core::array::Span::)>" + } + ] + }, + { + "type": "struct", + "name": "dojo::model::introspect::Enum", + "members": [ + { + "name": "name", + "type": "core::felt252" + }, + { + "name": "attrs", + "type": "core::array::Span::" + }, + { + "name": "children", + "type": "core::array::Span::<(core::felt252, core::array::Span::)>" + } + ] + }, + { + "type": "enum", + "name": "dojo::model::introspect::Ty", + "variants": [ + { + "name": "Primitive", + "type": "core::felt252" + }, + { + "name": "Struct", + "type": "dojo::model::introspect::Struct" + }, + { + "name": "Enum", + "type": "dojo::model::introspect::Enum" + }, + { + "name": "Tuple", + "type": "core::array::Span::>" + }, + { + "name": "Array", + "type": "core::integer::u32" + } + ] + }, + { + "type": "interface", + "name": "dojo::model::IDojoModel", + "items": [ + { + "type": "function", + "name": "selector", + "inputs": [], + "outputs": [ + { + "type": "core::felt252" + } + ], + "state_mutability": "view" + }, + { + "type": "function", + "name": "unpacked_size", + "inputs": [], + "outputs": [ + { + "type": "core::integer::u32" + } + ], + "state_mutability": "view" + }, + { + "type": "function", + "name": "packed_size", + "inputs": [], + "outputs": [ + { + "type": "core::integer::u32" + } + ], + "state_mutability": "view" + }, + { + "type": "function", + "name": "layout", + "inputs": [], + "outputs": [ + { + "type": "core::array::Span::" + } + ], + "state_mutability": "view" + }, + { + "type": "function", + "name": "schema", + "inputs": [], + "outputs": [ + { + "type": "dojo::model::introspect::Ty" + } + ], + "state_mutability": "view" + } + ] + }, + { + "type": "impl", + "name": "movesImpl", + "interface_name": "dojo_examples::models::Imoves" + }, + { + "type": "enum", + "name": "dojo_examples::models::Direction", + "variants": [ + { + "name": "None", + "type": "()" + }, + { + "name": "Left", + "type": "()" + }, + { + "name": "Right", + "type": "()" + }, + { + "name": "Up", + "type": "()" + }, + { + "name": "Down", + "type": "()" + } + ] + }, + { + "type": "struct", + "name": "dojo_examples::models::Moves", + "members": [ + { + "name": "player", + "type": "core::starknet::contract_address::ContractAddress" + }, + { + "name": "remaining", + "type": "core::integer::u8" + }, + { + "name": "last_direction", + "type": "dojo_examples::models::Direction" + } + ] + }, + { + "type": "interface", + "name": "dojo_examples::models::Imoves", + "items": [ + { + "type": "function", + "name": "ensure_abi", + "inputs": [ + { + "name": "model", + "type": "dojo_examples::models::Moves" + } + ], + "outputs": [], + "state_mutability": "view" + } + ] + }, + { + "type": "event", + "name": "dojo_examples::models::moves::Event", + "kind": "enum", + "variants": [] + } + ], + "reads": [], + "writes": [], + "computed": [] + }, + { + "name": "dojo_examples::models::position", + "address": null, + "class_hash": "0x1cec286fb861c6e928c62ed270ddedd4d79691fdead0ed4faa74064d804f7ae", + "abi": [ + { + "type": "impl", + "name": "DojoModelImpl", + "interface_name": "dojo::model::IDojoModel" + }, + { + "type": "struct", + "name": "core::array::Span::", + "members": [ + { + "name": "snapshot", + "type": "@core::array::Array::" + } + ] + }, + { + "type": "struct", + "name": "core::array::Span::", + "members": [ + { + "name": "snapshot", + "type": "@core::array::Array::" + } + ] + }, + { + "type": "struct", + "name": "core::array::Span::>", + "members": [ + { + "name": "snapshot", + "type": "@core::array::Array::>" + } + ] + }, + { + "type": "struct", + "name": "dojo::model::introspect::Struct", + "members": [ + { + "name": "name", + "type": "core::felt252" + }, + { + "name": "attrs", + "type": "core::array::Span::" + }, + { + "name": "children", + "type": "core::array::Span::>" + } + ] + }, + { + "type": "struct", + "name": "core::array::Span::<(core::felt252, core::array::Span::)>", + "members": [ + { + "name": "snapshot", + "type": "@core::array::Array::<(core::felt252, core::array::Span::)>" + } + ] + }, + { + "type": "struct", + "name": "dojo::model::introspect::Enum", + "members": [ + { + "name": "name", + "type": "core::felt252" + }, + { + "name": "attrs", + "type": "core::array::Span::" + }, + { + "name": "children", + "type": "core::array::Span::<(core::felt252, core::array::Span::)>" + } + ] + }, + { + "type": "enum", + "name": "dojo::model::introspect::Ty", + "variants": [ + { + "name": "Primitive", + "type": "core::felt252" + }, + { + "name": "Struct", + "type": "dojo::model::introspect::Struct" + }, + { + "name": "Enum", + "type": "dojo::model::introspect::Enum" + }, + { + "name": "Tuple", + "type": "core::array::Span::>" + }, + { + "name": "Array", + "type": "core::integer::u32" + } + ] + }, + { + "type": "interface", + "name": "dojo::model::IDojoModel", + "items": [ + { + "type": "function", + "name": "selector", + "inputs": [], + "outputs": [ + { + "type": "core::felt252" + } + ], + "state_mutability": "view" + }, + { + "type": "function", + "name": "unpacked_size", + "inputs": [], + "outputs": [ + { + "type": "core::integer::u32" + } + ], + "state_mutability": "view" + }, + { + "type": "function", + "name": "packed_size", + "inputs": [], + "outputs": [ + { + "type": "core::integer::u32" + } + ], + "state_mutability": "view" + }, + { + "type": "function", + "name": "layout", + "inputs": [], + "outputs": [ + { + "type": "core::array::Span::" + } + ], + "state_mutability": "view" + }, + { + "type": "function", + "name": "schema", + "inputs": [], + "outputs": [ + { + "type": "dojo::model::introspect::Ty" + } + ], + "state_mutability": "view" + } + ] + }, + { + "type": "impl", + "name": "positionImpl", + "interface_name": "dojo_examples::models::Iposition" + }, + { + "type": "struct", + "name": "dojo_examples::models::Vec2", + "members": [ + { + "name": "x", + "type": "core::integer::u32" + }, + { + "name": "y", + "type": "core::integer::u32" + } + ] + }, + { + "type": "struct", + "name": "dojo_examples::models::Position", + "members": [ + { + "name": "player", + "type": "core::starknet::contract_address::ContractAddress" + }, + { + "name": "vec", + "type": "dojo_examples::models::Vec2" + } + ] + }, + { + "type": "interface", + "name": "dojo_examples::models::Iposition", + "items": [ + { + "type": "function", + "name": "ensure_abi", + "inputs": [ + { + "name": "model", + "type": "dojo_examples::models::Position" + } + ], + "outputs": [], + "state_mutability": "view" + } + ] + }, + { + "type": "event", + "name": "dojo_examples::models::position::Event", + "kind": "enum", + "variants": [] + } + ], + "reads": [], + "writes": [], + "computed": [] + } + ], + "models": [] +} diff --git a/crates/compiler/src/manifest_test_data/simple_crate/Scarb.toml b/crates/compiler/src/manifest_test_data/simple_crate/Scarb.toml new file mode 100644 index 0000000..64a96a4 --- /dev/null +++ b/crates/compiler/src/manifest_test_data/simple_crate/Scarb.toml @@ -0,0 +1,10 @@ +[package] +cairo-version = "2.4.0" +name = "test_crate" +version = "0.4.1" + +[cairo] +sierra-replace-ids = true + +[dependencies] +dojo = { path = "../../../../dojo-core" } diff --git a/crates/compiler/src/manifest_test_data/simple_crate/src/lib.cairo b/crates/compiler/src/manifest_test_data/simple_crate/src/lib.cairo new file mode 100644 index 0000000..e69de29 diff --git a/crates/compiler/src/manifest_test_data/spawn-and-move b/crates/compiler/src/manifest_test_data/spawn-and-move new file mode 120000 index 0000000..0b85d07 --- /dev/null +++ b/crates/compiler/src/manifest_test_data/spawn-and-move @@ -0,0 +1 @@ +../../../../examples/spawn-and-move \ No newline at end of file diff --git a/crates/compiler/src/namespace_config.rs b/crates/compiler/src/namespace_config.rs new file mode 100644 index 0000000..4fbc429 --- /dev/null +++ b/crates/compiler/src/namespace_config.rs @@ -0,0 +1,292 @@ +use std::collections::HashMap; + +use anyhow::Result; +use cairo_lang_filesystem::cfg::CfgSet; +use regex::Regex; +use serde::Deserialize; + +pub const NAMESPACE_CFG_PREFIX: &str = "nm|"; +pub const DEFAULT_NAMESPACE_CFG_KEY: &str = "namespace_default"; +pub const DOJO_MANIFESTS_DIR_CFG_KEY: &str = "dojo_manifests_dir"; +pub const DEFAULT_NAMESPACE: &str = "DEFAULT_NAMESPACE"; + +/// Namespace configuration. +#[derive(Debug, Clone, Deserialize)] +pub struct NamespaceConfig { + pub default: String, + pub mappings: Option>, +} + +impl Default for NamespaceConfig { + fn default() -> Self { + NamespaceConfig { + default: DEFAULT_NAMESPACE.to_string(), + mappings: None, + } + } +} + +impl NamespaceConfig { + /// Creates a new namespace configuration with a default namespace. + pub fn new(default: &str) -> Self { + NamespaceConfig { + default: default.to_string(), + mappings: None, + } + } + + /// Adds mappings to the namespace configuration. + pub fn with_mappings(mut self, mappings: HashMap) -> Self { + self.mappings = Some(mappings); + self + } + + /// Displays the namespace mappings as a string. + pub fn display_mappings(&self) -> String { + if let Some(mappings) = &self.mappings { + let mut result = String::from("\n-- Mappings --\n"); + for (k, v) in mappings.iter() { + result += &format!("{} -> {}\n", k, v); + } + result + } else { + "No mapping to apply".to_string() + } + } + + /// Gets the namespace for a given tag or namespace, or return the default + /// namespace if no mapping was found. + /// + /// If the input is a tag, a first perfect match is checked. If no match + /// for the tag, then a check is done against the namespace of the tag. + /// If the input is a namespace, a perfect match if checked. + /// + /// Examples: + /// - `get_mapping("armory-Flatbow")` first checks for `armory-Flatbow` tag, then for `armory` + /// namespace in mapping keys. + /// - `get_mapping("armory")` checks for `armory` namespace in mapping keys. + /// + /// # Arguments + /// + /// * `tag_or_namespace`: the tag or namespace to get the namespace for. + /// + /// # Returns + /// + /// A [`String`] object containing the namespace. + pub fn get_mapping(&self, tag_or_namespace: &str) -> String { + if let Some(namespace_from_tag) = + self.mappings.as_ref().and_then(|m| m.get(tag_or_namespace)) + { + namespace_from_tag.clone() + } else if tag_or_namespace.contains('-') { + // TODO: we can't access the dojo-world/contracts from here as it belongs to a different + // feature. The naming module has to be relocated in more generic place, + // always available. + let (namespace, _) = tag_or_namespace.split_at(tag_or_namespace.rfind('-').unwrap()); + self.mappings + .as_ref() + .and_then(|m| m.get(namespace)) + .unwrap_or(&self.default) + .to_string() + } else { + self.default.clone() + } + } + + /// Validates the namespace configuration and their names. + /// + /// # Returns + /// + /// A [`Result`] object containing the namespace configuration if valid, error otherwise. + pub fn validate(self) -> Result { + if self.default.is_empty() { + return Err(anyhow::anyhow!("Default namespace is empty")); + } + + if !Self::is_name_valid(&self.default) { + return Err(anyhow::anyhow!( + "Invalid default namespace `{}`", + self.default + )); + } + + for (tag_or_namespace, namespace) in self.mappings.as_ref().unwrap_or(&HashMap::new()) { + if !Self::is_name_valid(namespace) { + return Err(anyhow::anyhow!( + "Invalid namespace `{}` for tag or namespace `{}`", + namespace, + tag_or_namespace + )); + } + } + + Ok(self) + } + + /// Checks if the provided namespace follows the format rules. + pub fn is_name_valid(namespace: &str) -> bool { + Regex::new(r"^[a-zA-Z0-9_]+$").unwrap().is_match(namespace) + } +} + +impl From<&CfgSet> for NamespaceConfig { + fn from(cfg_set: &CfgSet) -> Self { + let mut default = "".to_string(); + let mut mappings = HashMap::new(); + + for cfg in cfg_set.into_iter() { + if cfg.key == DEFAULT_NAMESPACE_CFG_KEY { + if let Some(v) = &cfg.value { + default = v.to_string(); + } + } else if cfg.key.starts_with(NAMESPACE_CFG_PREFIX) { + let key = cfg.key.replace(NAMESPACE_CFG_PREFIX, ""); + if let Some(v) = &cfg.value { + mappings.insert(key, v.to_string()); + } + } + } + + let mappings = if mappings.is_empty() { + None + } else { + Some(mappings) + }; + + NamespaceConfig { + default: default.to_string(), + mappings, + } + } +} + +#[cfg(test)] +mod tests { + use cairo_lang_filesystem::cfg::Cfg; + use smol_str::SmolStr; + + use super::*; + + #[test] + fn test_namespace_config_get_mapping() { + let config = NamespaceConfig { + default: "nm".to_string(), + mappings: Some(HashMap::from([ + ("tag1".to_string(), "namespace1".to_string()), + ("namespace2".to_string(), "namespace2".to_string()), + ("armory-Flatbow".to_string(), "weapons".to_string()), + ])), + }; + + assert_eq!(config.get_mapping("tag1"), "namespace1"); + assert_eq!(config.get_mapping("tag1-TestModel"), "namespace1"); + assert_eq!(config.get_mapping("namespace2"), "namespace2"); + assert_eq!(config.get_mapping("armory-Flatbow"), "weapons"); + assert_eq!(config.get_mapping("armory"), "nm"); + assert_eq!(config.get_mapping("unknown"), "nm"); + } + + #[test] + fn test_namespace_config_validate() { + let valid_config = NamespaceConfig { + default: "valid_default".to_string(), + mappings: Some(HashMap::from([ + ("tag1".to_string(), "valid_namespace1".to_string()), + ("tag2".to_string(), "valid_namespace2".to_string()), + ])), + }; + assert!(valid_config.validate().is_ok()); + + let empty_default_config = NamespaceConfig { + default: "".to_string(), + mappings: None, + }; + assert!(empty_default_config.validate().is_err()); + + let invalid_default_config = NamespaceConfig { + default: "invalid-default".to_string(), + mappings: None, + }; + assert!(invalid_default_config.validate().is_err()); + + let invalid_mapping_config = NamespaceConfig { + default: "valid_default".to_string(), + mappings: Some(HashMap::from([ + ("tag1".to_string(), "valid_namespace".to_string()), + ("tag2".to_string(), "invalid-namespace".to_string()), + ])), + }; + assert!(invalid_mapping_config.validate().is_err()); + } + + #[test] + fn test_namespace_config_new() { + let config = NamespaceConfig::new("default_namespace"); + assert_eq!(config.default, "default_namespace"); + assert_eq!(config.mappings, None); + } + + #[test] + fn test_namespace_config_with_mappings() { + let mut mappings = HashMap::new(); + mappings.insert("tag1".to_string(), "namespace1".to_string()); + mappings.insert("tag2".to_string(), "namespace2".to_string()); + + let config = NamespaceConfig::new("default_namespace").with_mappings(mappings.clone()); + assert_eq!(config.default, "default_namespace"); + assert_eq!(config.mappings, Some(mappings)); + } + + #[test] + fn test_is_name_valid_with_valid_names() { + assert!(NamespaceConfig::is_name_valid("validName")); + assert!(NamespaceConfig::is_name_valid("valid_name")); + assert!(NamespaceConfig::is_name_valid("ValidName123")); + assert!(NamespaceConfig::is_name_valid("VALID_NAME")); + assert!(NamespaceConfig::is_name_valid("v")); + } + + #[test] + fn test_is_name_valid_with_invalid_names() { + assert!(!NamespaceConfig::is_name_valid("invalid-name")); + assert!(!NamespaceConfig::is_name_valid("invalid name")); + assert!(!NamespaceConfig::is_name_valid("invalid.name")); + assert!(!NamespaceConfig::is_name_valid("invalid!name")); + assert!(!NamespaceConfig::is_name_valid("")); + } + + #[test] + fn test_namespace_config_from_cfg_set() { + let mut cfg_set = CfgSet::new(); + cfg_set.insert(Cfg::kv( + DEFAULT_NAMESPACE_CFG_KEY, + SmolStr::from("default_namespace"), + )); + cfg_set.insert(Cfg::kv( + format!("{}tag1", NAMESPACE_CFG_PREFIX), + SmolStr::from("namespace1"), + )); + cfg_set.insert(Cfg::kv( + format!("{}tag2", NAMESPACE_CFG_PREFIX), + SmolStr::from("namespace2"), + )); + + let namespace_config = NamespaceConfig::from(&cfg_set); + + assert_eq!(namespace_config.default, "default_namespace"); + assert_eq!( + namespace_config.mappings, + Some(HashMap::from([ + ("tag1".to_string(), "namespace1".to_string()), + ("tag2".to_string(), "namespace2".to_string()), + ])) + ); + + // Test with empty CfgSet + let empty_cfg_set = CfgSet::new(); + let empty_namespace_config = NamespaceConfig::from(&empty_cfg_set); + + assert_eq!(empty_namespace_config.default, ""); + assert_eq!(empty_namespace_config.mappings, None); + } +} diff --git a/crates/compiler/src/plugin.rs b/crates/compiler/src/plugin.rs new file mode 100644 index 0000000..7b9d5f1 --- /dev/null +++ b/crates/compiler/src/plugin.rs @@ -0,0 +1,497 @@ +use std::cmp::Ordering; + +use anyhow::Result; +use cairo_lang_defs::patcher::PatchBuilder; +use cairo_lang_defs::plugin::{ + DynGeneratedFileAuxData, GeneratedFileAuxData, MacroPlugin, MacroPluginMetadata, + PluginDiagnostic, PluginGeneratedFile, PluginResult, +}; +use cairo_lang_diagnostics::Severity; +use cairo_lang_semantic::plugin::PluginSuite; +use cairo_lang_starknet::plugin::aux_data::StarkNetEventAuxData; +use cairo_lang_syntax::attribute::structured::{AttributeArgVariant, AttributeStructurize}; +use cairo_lang_syntax::node::ast::Attribute; +use cairo_lang_syntax::node::db::SyntaxGroup; +use cairo_lang_syntax::node::helpers::QueryAttrs; +use cairo_lang_syntax::node::ids::SyntaxStablePtrId; +use cairo_lang_syntax::node::{ast, Terminal, TypedSyntaxNode}; +use scarb::compiler::plugin::builtin::BuiltinStarkNetPlugin; +use scarb::compiler::plugin::{CairoPlugin, CairoPluginInstance}; +use scarb::core::{PackageId, PackageName, SourceId}; +use semver::Version; +use smol_str::SmolStr; +use url::Url; + +use crate::attribute_macros::contract::DojoContract; +use crate::attribute_macros::event::handle_event_struct; +use crate::attribute_macros::interface::DojoInterface; +use crate::attribute_macros::model::handle_model_struct; +use crate::inline_macros::delete::DeleteMacro; +use crate::inline_macros::emit::EmitMacro; +use crate::inline_macros::get::GetMacro; +use crate::inline_macros::get_models_test_class_hashes::GetModelsTestClassHashes; +use crate::inline_macros::selector_from_tag::SelectorFromTagMacro; +use crate::inline_macros::set::SetMacro; +use crate::inline_macros::spawn_test_world::SpawnTestWorld; +use crate::introspect::{handle_introspect_enum, handle_introspect_struct}; +use crate::namespace_config::NamespaceConfig; +use crate::print::{handle_print_enum, handle_print_struct}; +pub const DOJO_CONTRACT_ATTR: &str = "dojo::contract"; +pub const DOJO_INTERFACE_ATTR: &str = "dojo::interface"; +pub const DOJO_MODEL_ATTR: &str = "dojo::model"; +pub const DOJO_EVENT_ATTR: &str = "dojo::event"; + +pub const DOJO_INTROSPECT_ATTR: &str = "Introspect"; +pub const DOJO_PACKED_ATTR: &str = "IntrospectPacked"; + +/// Represents a member of a struct. +#[derive(Clone, Debug, PartialEq)] +pub struct Member { + // Name of the member. + pub name: String, + // Type of the member. + // #[serde(rename = "type")] + pub ty: String, + // Whether the member is a key. + pub key: bool, +} + +#[derive(Clone, Debug, PartialEq)] +pub struct ModelAuxData { + pub name: String, + pub namespace: String, + pub members: Vec, +} + +#[derive(Debug, PartialEq, Eq)] +pub struct ContractAuxData { + pub name: SmolStr, + pub namespace: String, + pub systems: Vec, +} + +/// Dojo related auxiliary data of the Dojo plugin. +#[derive(Debug, Default, PartialEq)] +pub struct DojoAuxData { + /// A list of models that were processed by the plugin. + pub models: Vec, + /// A list of contracts that were processed by the plugin. + pub contracts: Vec, + /// A list of events that were processed by the plugin. + pub events: Vec, +} + +impl GeneratedFileAuxData for DojoAuxData { + fn as_any(&self) -> &dyn std::any::Any { + self + } + fn eq(&self, other: &dyn GeneratedFileAuxData) -> bool { + if let Some(other) = other.as_any().downcast_ref::() { + self == other + } else { + false + } + } +} + +#[cfg(test)] +#[path = "plugin_test.rs"] +mod test; + +pub const PACKAGE_NAME: &str = "dojo_plugin"; + +#[derive(Debug, Default)] +pub struct BuiltinDojoPlugin; + +impl BuiltinDojoPlugin { + fn handle_mod( + &self, + db: &dyn SyntaxGroup, + module_ast: ast::ItemModule, + namespace_config: &NamespaceConfig, + metadata: &MacroPluginMetadata<'_>, + ) -> PluginResult { + if module_ast.has_attr(db, DOJO_CONTRACT_ATTR) { + return DojoContract::from_module(db, &module_ast, namespace_config, metadata); + } + + PluginResult::default() + } + + fn handle_trait( + &self, + db: &dyn SyntaxGroup, + trait_ast: ast::ItemTrait, + metadata: &MacroPluginMetadata<'_>, + ) -> PluginResult { + if trait_ast.has_attr(db, DOJO_INTERFACE_ATTR) { + return DojoInterface::from_trait(db, trait_ast, metadata); + } + + PluginResult::default() + } +} + +impl CairoPlugin for BuiltinDojoPlugin { + fn id(&self) -> PackageId { + let url = Url::parse("https://github.com/dojoengine/dojo").unwrap(); + let version = "0.4.0"; + // TODO: update this once pushed. + let rev = "1e651b5d4d3b79b14a7d8aa29a92062fcb9e6659"; + + let source_id = SourceId::for_git( + &url, + &scarb::core::GitReference::Tag(format!("v{version}").into()), + ) + .unwrap() + .with_precise(rev.to_string()) + .unwrap(); + + PackageId::new( + PackageName::new(PACKAGE_NAME), + Version::parse(version).unwrap(), + source_id, + ) + } + + fn instantiate(&self) -> Result> { + Ok(Box::new(BuiltinDojoPluginInstance)) + } +} + +struct BuiltinDojoPluginInstance; +impl CairoPluginInstance for BuiltinDojoPluginInstance { + fn plugin_suite(&self) -> PluginSuite { + dojo_plugin_suite() + } +} + +pub fn dojo_plugin_suite() -> PluginSuite { + let mut suite = PluginSuite::default(); + + suite + .add_plugin::() + .add_inline_macro_plugin::() + .add_inline_macro_plugin::() + .add_inline_macro_plugin::() + .add_inline_macro_plugin::() + .add_inline_macro_plugin::() + .add_inline_macro_plugin::() + .add_inline_macro_plugin::(); + + suite +} + +fn get_derive_attr_names( + db: &dyn SyntaxGroup, + diagnostics: &mut Vec, + attrs: Vec, +) -> Vec { + attrs + .iter() + .filter_map(|attr| { + let args = attr.clone().structurize(db).args; + if args.is_empty() { + diagnostics.push(PluginDiagnostic { + stable_ptr: attr.stable_ptr().0, + message: "Expected args.".into(), + severity: Severity::Error, + }); + None + } else { + Some(args.into_iter().filter_map(|a| { + if let AttributeArgVariant::Unnamed(ast::Expr::Path(path)) = a.variant { + if let [ast::PathSegment::Simple(segment)] = &path.elements(db)[..] { + Some(segment.ident(db).text(db).to_string()) + } else { + None + } + } else { + None + } + })) + } + }) + .flatten() + .collect::>() +} + +fn check_for_derive_attr_conflicts( + diagnostics: &mut Vec, + diagnostic_item: SyntaxStablePtrId, + attr_names: &[String], +) { + if attr_names.contains(&DOJO_INTROSPECT_ATTR.to_string()) + && attr_names.contains(&DOJO_PACKED_ATTR.to_string()) + { + diagnostics.push(PluginDiagnostic { + stable_ptr: diagnostic_item, + message: format!( + "{} and {} attributes cannot be used at a same time.", + DOJO_INTROSPECT_ATTR, DOJO_PACKED_ATTR + ), + severity: Severity::Error, + }); + } +} + +fn get_additional_derive_attrs_for_model(derive_attr_names: &[String]) -> Vec { + let mut additional_attrs = vec![]; + + // if not already present, add Introspect to derive attributes because it + // is mandatory for a model + if !derive_attr_names.contains(&DOJO_INTROSPECT_ATTR.to_string()) + && !derive_attr_names.contains(&DOJO_PACKED_ATTR.to_string()) + { + additional_attrs.push(DOJO_INTROSPECT_ATTR.to_string()); + } + + additional_attrs +} + +impl MacroPlugin for BuiltinDojoPlugin { + // This function is called for every item in whole db. Hence, + // the sooner we can return, the better. + // As an example, compiling spawn-and-move project, it's almost 14K calls to this + // function. + fn generate_code( + &self, + db: &dyn SyntaxGroup, + item_ast: ast::ModuleItem, + metadata: &MacroPluginMetadata<'_>, + ) -> PluginResult { + // Metadata gives information from the crates from where `item_ast` was parsed. + // During the compilation phase, we inject namespace information into the `CfgSet` + // so that it can be used here. + let namespace_config = metadata.cfg_set.into(); + + match item_ast { + ast::ModuleItem::Module(module_ast) => { + self.handle_mod(db, module_ast, &namespace_config, metadata) + } + ast::ModuleItem::Trait(trait_ast) => self.handle_trait(db, trait_ast, metadata), + ast::ModuleItem::Enum(enum_ast) => { + let aux_data = DojoAuxData::default(); + let mut rewrite_nodes = vec![]; + let mut diagnostics = vec![]; + + let derive_attr_names = get_derive_attr_names( + db, + &mut diagnostics, + enum_ast.attributes(db).query_attr(db, "derive"), + ); + + check_for_derive_attr_conflicts( + &mut diagnostics, + enum_ast.name(db).stable_ptr().0, + &derive_attr_names, + ); + + // Iterate over all the derive attributes of the struct + for attr in derive_attr_names { + match attr.as_str() { + DOJO_INTROSPECT_ATTR => { + rewrite_nodes.push(handle_introspect_enum( + db, + &mut diagnostics, + enum_ast.clone(), + false, + )); + } + DOJO_PACKED_ATTR => { + rewrite_nodes.push(handle_introspect_enum( + db, + &mut diagnostics, + enum_ast.clone(), + true, + )); + } + "Print" => rewrite_nodes.push(handle_print_enum(db, enum_ast.clone())), + _ => continue, + } + } + + if rewrite_nodes.is_empty() { + return PluginResult { + diagnostics, + ..PluginResult::default() + }; + } + + let name = enum_ast.name(db).text(db); + let mut builder = PatchBuilder::new(db, &enum_ast); + for node in rewrite_nodes { + builder.add_modified(node); + } + + let (code, code_mappings) = builder.build(); + + PluginResult { + code: Some(PluginGeneratedFile { + name, + content: code, + aux_data: Some(DynGeneratedFileAuxData::new(aux_data)), + code_mappings, + }), + diagnostics, + remove_original_item: false, + } + } + ast::ModuleItem::Struct(struct_ast) => { + let mut aux_data = DojoAuxData::default(); + let mut rewrite_nodes = vec![]; + let mut diagnostics = vec![]; + + let mut addtional_derive_attr_names = vec![]; + let derive_attr_names = get_derive_attr_names( + db, + &mut diagnostics, + struct_ast.attributes(db).query_attr(db, "derive"), + ); + + let model_attrs = struct_ast.attributes(db).query_attr(db, DOJO_MODEL_ATTR); + + check_for_derive_attr_conflicts( + &mut diagnostics, + struct_ast.name(db).stable_ptr().0, + &derive_attr_names, + ); + + if !model_attrs.is_empty() { + addtional_derive_attr_names = + get_additional_derive_attrs_for_model(&derive_attr_names); + } + + // Iterate over all the derive attributes of the struct + for attr in derive_attr_names + .iter() + .chain(addtional_derive_attr_names.iter()) + { + match attr.as_str() { + "Print" => { + rewrite_nodes.push(handle_print_struct(db, struct_ast.clone())); + } + DOJO_INTROSPECT_ATTR => { + rewrite_nodes.push(handle_introspect_struct( + db, + &mut diagnostics, + struct_ast.clone(), + false, + )); + } + DOJO_PACKED_ATTR => { + rewrite_nodes.push(handle_introspect_struct( + db, + &mut diagnostics, + struct_ast.clone(), + true, + )); + } + _ => continue, + } + } + + let event_attrs = struct_ast.attributes(db).query_attr(db, DOJO_EVENT_ATTR); + + match event_attrs.len().cmp(&1) { + Ordering::Equal => { + let (event_rewrite_nodes, event_diagnostics) = + handle_event_struct(db, &mut aux_data, struct_ast.clone()); + rewrite_nodes.push(event_rewrite_nodes); + diagnostics.extend(event_diagnostics); + } + Ordering::Greater => { + diagnostics.push(PluginDiagnostic { + message: "A Dojo event must have zero or one dojo::event attribute." + .into(), + stable_ptr: struct_ast.stable_ptr().0, + severity: Severity::Error, + }); + } + _ => {} + } + + match model_attrs.len().cmp(&1) { + Ordering::Equal => { + let (model_rewrite_nodes, model_diagnostics) = handle_model_struct( + db, + &mut aux_data, + struct_ast.clone(), + &namespace_config, + ); + rewrite_nodes.push(model_rewrite_nodes); + diagnostics.extend(model_diagnostics); + } + Ordering::Greater => { + diagnostics.push(PluginDiagnostic { + message: "A Dojo model must have zero or one dojo::model attribute." + .into(), + stable_ptr: struct_ast.stable_ptr().0, + severity: Severity::Error, + }); + } + _ => {} + } + + if rewrite_nodes.is_empty() { + return PluginResult { + diagnostics, + ..PluginResult::default() + }; + } + + let name = struct_ast.name(db).text(db); + let mut builder = PatchBuilder::new(db, &struct_ast); + for node in rewrite_nodes { + builder.add_modified(node); + } + + let (code, code_mappings) = builder.build(); + + PluginResult { + code: Some(PluginGeneratedFile { + name, + content: code, + aux_data: Some(DynGeneratedFileAuxData::new(aux_data)), + code_mappings, + }), + diagnostics, + remove_original_item: false, + } + } + _ => PluginResult::default(), + } + } + + fn declared_attributes(&self) -> Vec { + vec![ + DOJO_INTERFACE_ATTR.to_string(), + DOJO_CONTRACT_ATTR.to_string(), + DOJO_EVENT_ATTR.to_string(), + DOJO_MODEL_ATTR.to_string(), + "key".to_string(), + ] + } + + fn declared_derives(&self) -> Vec { + vec!["Introspect".to_string(), "IntrospectPacked".to_string()] + } +} + +#[derive(Debug)] +pub struct CairoPluginRepository(scarb::compiler::plugin::CairoPluginRepository); + +impl Default for CairoPluginRepository { + fn default() -> Self { + let mut repo = scarb::compiler::plugin::CairoPluginRepository::empty(); + repo.add(Box::new(BuiltinDojoPlugin)).unwrap(); + repo.add(Box::new(BuiltinStarkNetPlugin)).unwrap(); + Self(repo) + } +} + +impl From for scarb::compiler::plugin::CairoPluginRepository { + fn from(val: CairoPluginRepository) -> Self { + val.0 + } +} diff --git a/crates/compiler/src/plugin_test.rs b/crates/compiler/src/plugin_test.rs new file mode 100644 index 0000000..be75dd8 --- /dev/null +++ b/crates/compiler/src/plugin_test.rs @@ -0,0 +1,174 @@ +use std::path::PathBuf; +use std::sync::Arc; + +use cairo_lang_defs::db::{DefsDatabase, DefsGroup}; +use cairo_lang_defs::ids::ModuleId; +use cairo_lang_defs::plugin::MacroPlugin; +use cairo_lang_filesystem::cfg::{Cfg, CfgSet}; +use cairo_lang_filesystem::db::{ + init_files_group, AsFilesGroupMut, CrateConfiguration, FilesDatabase, FilesGroup, FilesGroupEx, +}; +use cairo_lang_filesystem::ids::{CrateLongId, Directory}; +use cairo_lang_parser::db::ParserDatabase; +use cairo_lang_plugins::get_base_plugins; +use cairo_lang_plugins::test_utils::expand_module_text; +use cairo_lang_starknet::plugin::StarkNetPlugin; +use cairo_lang_syntax::node::db::{SyntaxDatabase, SyntaxGroup}; +use cairo_lang_test_utils::parse_test_file::TestRunnerResult; +use cairo_lang_test_utils::verify_diagnostics_expectation; +use cairo_lang_utils::ordered_hash_map::OrderedHashMap; +use cairo_lang_utils::Upcast; +use smol_str::SmolStr; + +use super::BuiltinDojoPlugin; +use crate::namespace_config::DEFAULT_NAMESPACE_CFG_KEY; + +cairo_lang_test_utils::test_file_test!( + expand_plugin, + "src/plugin_test_data", + { + model: "model", + print: "print", + introspect: "introspect", + system: "system", + }, + test_expand_plugin +); + +pub fn test_expand_plugin( + inputs: &OrderedHashMap, + args: &OrderedHashMap, +) -> TestRunnerResult { + test_expand_plugin_inner( + inputs, + args, + &[ + Arc::new(BuiltinDojoPlugin), + Arc::new(StarkNetPlugin::default()), + ], + ) +} + +#[salsa::database(DefsDatabase, ParserDatabase, SyntaxDatabase, FilesDatabase)] +#[allow(missing_debug_implementations)] +pub struct DatabaseForTesting { + storage: salsa::Storage, +} +impl salsa::Database for DatabaseForTesting {} +impl Default for DatabaseForTesting { + fn default() -> Self { + let mut res = Self { + storage: Default::default(), + }; + init_files_group(&mut res); + res.set_macro_plugins(get_base_plugins()); + res + } +} +impl AsFilesGroupMut for DatabaseForTesting { + fn as_files_group_mut(&mut self) -> &mut (dyn FilesGroup + 'static) { + self + } +} +impl Upcast for DatabaseForTesting { + fn upcast(&self) -> &(dyn DefsGroup + 'static) { + self + } +} +impl Upcast for DatabaseForTesting { + fn upcast(&self) -> &(dyn FilesGroup + 'static) { + self + } +} +impl Upcast for DatabaseForTesting { + fn upcast(&self) -> &(dyn SyntaxGroup + 'static) { + self + } +} + +/// Tests expansion of given code, with the default plugins plus the given extra plugins. +pub fn test_expand_plugin_inner( + inputs: &OrderedHashMap, + args: &OrderedHashMap, + extra_plugins: &[Arc], +) -> TestRunnerResult { + let db = &mut DatabaseForTesting::default(); + let mut plugins = db.macro_plugins(); + plugins.extend_from_slice(extra_plugins); + db.set_macro_plugins(plugins); + + // if no configuration is provided, be sure there is at least a default namespace, + // so all the tests have a correct configuration. + let cfg_set: CfgSet = match inputs.get("cfg") { + Some(cfg) => serde_json::from_str(cfg.as_str()).unwrap(), + None => { + let mut cfg_set = CfgSet::new(); + cfg_set.insert(Cfg::kv( + DEFAULT_NAMESPACE_CFG_KEY, + SmolStr::from("dojo_test"), + )); + cfg_set + } + }; + + db.set_cfg_set(Arc::new(cfg_set)); + + let test_id = &inputs["test_id"]; + let cairo_code = &inputs["cairo_code"]; + + // The path as to remain the same, because diagnostics contains the path + // of the file. Which can cause error when checked without CAIRO_FIX=1. + let tmp_dir = PathBuf::from(format!("/tmp/plugin_test/{}", test_id)); + let _ = std::fs::create_dir_all(&tmp_dir); + let tmp_path = tmp_dir.as_path(); + + // Create Scarb.toml file + let scarb_toml_path = tmp_path.join("Scarb.toml"); + std::fs::write( + scarb_toml_path, + r#" +[package] +cairo-version = "=2.6.4" +edition = "2024_07" +name = "test_package" +version = "0.7.3" + +[cairo] +sierra-replace-ids = true + +[[target.dojo]] + +[tool.dojo.world] +namespace = { default = "test_package" } +seed = "test_package" +"#, + ) + .expect("Failed to write Scarb.toml"); + + // Create src directory + let src_dir = tmp_path.join("src"); + let _ = std::fs::create_dir(&src_dir); + + // Create lib.cairo file + let lib_cairo_path = src_dir.join("lib.cairo"); + std::fs::write(lib_cairo_path, cairo_code).expect("Failed to write lib.cairo"); + + let crate_id = db.intern_crate(CrateLongId::Real("test".into())); + let root = Directory::Real(src_dir.to_path_buf()); + + db.set_crate_config(crate_id, Some(CrateConfiguration::default_for_root(root))); + + let mut diagnostic_items = vec![]; + let expanded_module = + expand_module_text(db, ModuleId::CrateRoot(crate_id), &mut diagnostic_items); + let joined_diagnostics = diagnostic_items.join("\n"); + let error = verify_diagnostics_expectation(args, &joined_diagnostics); + + TestRunnerResult { + outputs: OrderedHashMap::from([ + ("expanded_cairo_code".into(), expanded_module), + ("expected_diagnostics".into(), joined_diagnostics), + ]), + error, + } +} diff --git a/crates/compiler/src/plugin_test_data/introspect b/crates/compiler/src/plugin_test_data/introspect new file mode 100644 index 0000000..90233db --- /dev/null +++ b/crates/compiler/src/plugin_test_data/introspect @@ -0,0 +1,2944 @@ +//! > Test expansion of the derive(Introspect). + +//! > test_runner_name +test_expand_plugin + +//! > test_id +introspect + +//! > cairo_code +use core::serde::Serde; + +#[derive(Copy, Drop, Serde, Introspect)] +struct Vec2 { + x: u32, + y: u32 +} + +#[derive(Serde, Copy, Drop, Introspect)] +enum PlainEnum { + Left, + Right, +} + +#[derive(Serde, Copy, Drop, Introspect)] +enum EnumWithPrimitive { + Left: u32, + Right: u32, +} + +#[derive(Serde, Copy, Drop, Introspect)] +enum EnumWithStruct { + Left: Vec2, + Right: Vec2, +} + +#[derive(Serde, Copy, Drop, Introspect)] +enum EnumWithSimpleArray { + Left: Array, + Right: Array, +} + +#[derive(Serde, Copy, Drop, Introspect)] +enum EnumWithByteArray { + Left: ByteArray, + Right: ByteArray, +} + +#[derive(Serde, Copy, Drop, Introspect)] +enum EnumWithSimpleTuple { + Left: (u8, u256), + Right: (u8, u256), +} + +#[derive(Serde, Copy, Drop, Introspect)] +enum EnumWithComplexTuple { + Left: (u8, Vec2), + Right: (u8, Vec2), +} + +#[derive(Serde, Copy, Drop, Introspect)] +enum EnumWithPrimitive { + Left: u32, + Right: u32, +} + +#[derive(Serde, Copy, Drop, Introspect)] +enum EnumCustom { + Left: Vec2, + Right: Vec2, +} + +#[derive(Serde, Copy, Drop, Introspect)] +enum EnumTupleMix { + Left: (Vec2, u64, EnumCustom), + Right: (Vec2, u64, EnumCustom), +} + +#[derive(Serde, Copy, Drop, Introspect)] +enum EnumWithDifferentVariantData { + One, + Two: u32, + Three: (Vec2, u64), +} + +#[derive(Copy, Drop, Introspect)] +struct StructWithPrimitives { + #[key] + player: ContractAddress, + before: u8, + after: u16, +} + +#[derive(Copy, Drop, Introspect)] +struct StructWithStruct { + #[key] + player: ContractAddress, + before: u8, + after: Vec2, +} + +#[derive(Copy, Drop, Introspect)] +struct StructWithSimpleArray { + #[key] + player: ContractAddress, + before: u8, + after: Array, +} + +#[derive(Copy, Drop, Introspect)] +struct StructWithByteArray { + #[key] + player: ContractAddress, + before: u8, + after: ByteArray, +} + +#[derive(Copy, Drop, Introspect)] +struct StructWithComplexArray { + #[key] + player: ContractAddress, + before: u8, + after: Array, +} + +#[derive(Copy, Drop, Introspect)] +struct StructWithSimpleTuple { + #[key] + player: ContractAddress, + before: u8, + after: (u8, u256), +} + +#[derive(Copy, Drop, Introspect)] +struct StructWithComplexTuple { + #[key] + player: ContractAddress, + before: u8, + after: (u8, Vec2, EnumCustom), +} + +#[derive(Copy, Drop, Introspect)] +struct StructWithNestedArrays { + #[key] + player: ContractAddress, + before: u8, + after: Array>>, +} + +#[derive(Copy, Drop, Introspect)] +struct StructWithNestedTuples { + #[key] + player: ContractAddress, + before: u8, + after: ((u8, u32), (Vec2, EnumCustom)), +} + +#[derive(Copy, Drop, Introspect)] +struct StructWithNestedTuplesAndByteArray { + #[key] + player: ContractAddress, + before: u8, + after: ((u8, u32), (Vec2, ByteArray)), +} + +#[derive(Copy, Drop, Introspect)] +struct StructWithNestedEverything { + #[key] + player: ContractAddress, + before: u8, + after: ((u8, u32), (Vec2, EnumCustom), (Array<(u32, Vec2)>, EnumCustom), (u16,)) +} + +#[derive(Copy, Drop, Serde, Introspect)] +struct GenericStruct { + t: T, +} + +#[derive(Copy, Drop, Serde, Introspect)] +struct StructWithBadOption { + x: Option<(u8, u16)> +} + +#[derive(Copy, Drop, Serde, Introspect)] +enum EnumWithBadOption { + first: Option<(u8, u16)>, +} + +#[derive(Introspect, IntrospectPacked)] +enum EnumIncompatibleAttrs {} + +#[derive(Introspect, IntrospectPacked)] +struct StructIncompatibleAttrs {} + +#[derive(Introspect)] +#[derive(IntrospectPacked)] +struct StructIncompatibleAttrs2 {} + +#[derive(Introspect)] +#[derive(IntrospectPacked)] +enum EnumIncompatibleAttrs2 {} + +#[derive(IntrospectPacked)] +struct StructPacked1 { + x: u8 +} + +#[derive(IntrospectPacked)] +struct StructPacked2 { + x: u8, + y: u256 +} + +#[derive(IntrospectPacked)] +struct StructPacked3 { + x: u256, + y: (u8, u32) +} + +#[derive(IntrospectPacked)] +struct StructNotPackable1 { + x: u8, + y: Array +} + +#[derive(IntrospectPacked)] +struct StructPackableWithInnerPacked { + x: u8, + y: StructPacked1 +} + +#[derive(IntrospectPacked)] +enum EnumPacked1 { + a, + b, + c +} + +#[derive(IntrospectPacked)] +enum EnumPacked2 { + a: u8, + b: u8, + c: u8 +} + +#[derive(IntrospectPacked)] +enum EnumPacked3 { + a: (u128, u128), + b: u256, +} + + +#[derive(IntrospectPacked)] +enum EnumPackableWithInnerPacked { + a: StructPacked1, + b: StructPacked1, +} + +#[derive(IntrospectPacked)] +enum EnumNotPackable1 { + a: u8, + b: u256, +} + +//! > expanded_cairo_code +use core::serde::Serde; + +#[derive(Copy, Drop, Serde, Introspect)] +struct Vec2 { + x: u32, + y: u32 +} + +#[derive(Serde, Copy, Drop, Introspect)] +enum PlainEnum { + Left, + Right, +} + +#[derive(Serde, Copy, Drop, Introspect)] +enum EnumWithPrimitive { + Left: u32, + Right: u32, +} + +#[derive(Serde, Copy, Drop, Introspect)] +enum EnumWithStruct { + Left: Vec2, + Right: Vec2, +} + +#[derive(Serde, Copy, Drop, Introspect)] +enum EnumWithSimpleArray { + Left: Array, + Right: Array, +} + +#[derive(Serde, Copy, Drop, Introspect)] +enum EnumWithByteArray { + Left: ByteArray, + Right: ByteArray, +} + +#[derive(Serde, Copy, Drop, Introspect)] +enum EnumWithSimpleTuple { + Left: (u8, u256), + Right: (u8, u256), +} + +#[derive(Serde, Copy, Drop, Introspect)] +enum EnumWithComplexTuple { + Left: (u8, Vec2), + Right: (u8, Vec2), +} + +#[derive(Serde, Copy, Drop, Introspect)] +enum EnumWithPrimitive { + Left: u32, + Right: u32, +} + +#[derive(Serde, Copy, Drop, Introspect)] +enum EnumCustom { + Left: Vec2, + Right: Vec2, +} + +#[derive(Serde, Copy, Drop, Introspect)] +enum EnumTupleMix { + Left: (Vec2, u64, EnumCustom), + Right: (Vec2, u64, EnumCustom), +} + +#[derive(Serde, Copy, Drop, Introspect)] +enum EnumWithDifferentVariantData { + One, + Two: u32, + Three: (Vec2, u64), +} + +#[derive(Copy, Drop, Introspect)] +struct StructWithPrimitives { + #[key] + player: ContractAddress, + before: u8, + after: u16, +} + +#[derive(Copy, Drop, Introspect)] +struct StructWithStruct { + #[key] + player: ContractAddress, + before: u8, + after: Vec2, +} + +#[derive(Copy, Drop, Introspect)] +struct StructWithSimpleArray { + #[key] + player: ContractAddress, + before: u8, + after: Array, +} + +#[derive(Copy, Drop, Introspect)] +struct StructWithByteArray { + #[key] + player: ContractAddress, + before: u8, + after: ByteArray, +} + +#[derive(Copy, Drop, Introspect)] +struct StructWithComplexArray { + #[key] + player: ContractAddress, + before: u8, + after: Array, +} + +#[derive(Copy, Drop, Introspect)] +struct StructWithSimpleTuple { + #[key] + player: ContractAddress, + before: u8, + after: (u8, u256), +} + +#[derive(Copy, Drop, Introspect)] +struct StructWithComplexTuple { + #[key] + player: ContractAddress, + before: u8, + after: (u8, Vec2, EnumCustom), +} + +#[derive(Copy, Drop, Introspect)] +struct StructWithNestedArrays { + #[key] + player: ContractAddress, + before: u8, + after: Array>>, +} + +#[derive(Copy, Drop, Introspect)] +struct StructWithNestedTuples { + #[key] + player: ContractAddress, + before: u8, + after: ((u8, u32), (Vec2, EnumCustom)), +} + +#[derive(Copy, Drop, Introspect)] +struct StructWithNestedTuplesAndByteArray { + #[key] + player: ContractAddress, + before: u8, + after: ((u8, u32), (Vec2, ByteArray)), +} + +#[derive(Copy, Drop, Introspect)] +struct StructWithNestedEverything { + #[key] + player: ContractAddress, + before: u8, + after: ((u8, u32), (Vec2, EnumCustom), (Array<(u32, Vec2)>, EnumCustom), (u16,)) +} + +#[derive(Copy, Drop, Serde, Introspect)] +struct GenericStruct { + t: T, +} + +#[derive(Copy, Drop, Serde, Introspect)] +struct StructWithBadOption { + x: Option<(u8, u16)> +} + +#[derive(Copy, Drop, Serde, Introspect)] +enum EnumWithBadOption { + first: Option<(u8, u16)>, +} + +#[derive(Introspect, IntrospectPacked)] +enum EnumIncompatibleAttrs {} + +#[derive(Introspect, IntrospectPacked)] +struct StructIncompatibleAttrs {} + +#[derive(Introspect)] +#[derive(IntrospectPacked)] +struct StructIncompatibleAttrs2 {} + +#[derive(Introspect)] +#[derive(IntrospectPacked)] +enum EnumIncompatibleAttrs2 {} + +#[derive(IntrospectPacked)] +struct StructPacked1 { + x: u8 +} + +#[derive(IntrospectPacked)] +struct StructPacked2 { + x: u8, + y: u256 +} + +#[derive(IntrospectPacked)] +struct StructPacked3 { + x: u256, + y: (u8, u32) +} + +#[derive(IntrospectPacked)] +struct StructNotPackable1 { + x: u8, + y: Array +} + +#[derive(IntrospectPacked)] +struct StructPackableWithInnerPacked { + x: u8, + y: StructPacked1 +} + +#[derive(IntrospectPacked)] +enum EnumPacked1 { + a, + b, + c +} + +#[derive(IntrospectPacked)] +enum EnumPacked2 { + a: u8, + b: u8, + c: u8 +} + +#[derive(IntrospectPacked)] +enum EnumPacked3 { + a: (u128, u128), + b: u256, +} + + +#[derive(IntrospectPacked)] +enum EnumPackableWithInnerPacked { + a: StructPacked1, + b: StructPacked1, +} + +#[derive(IntrospectPacked)] +enum EnumNotPackable1 { + a: u8, + b: u256, +}impl Vec2Copy of core::traits::Copy::; +impl Vec2Drop of core::traits::Drop::; +impl Vec2Serde of core::serde::Serde:: { + fn serialize(self: @Vec2, ref output: core::array::Array) { + core::serde::Serde::serialize(self.x, ref output); + core::serde::Serde::serialize(self.y, ref output) + } + fn deserialize(ref serialized: core::array::Span) -> core::option::Option { + core::option::Option::Some(Vec2 { + x: core::serde::Serde::deserialize(ref serialized)?, + y: core::serde::Serde::deserialize(ref serialized)?, + }) + } +} + +impl Vec2Introspect<> of dojo::model::introspect::Introspect> { + #[inline(always)] + fn size() -> Option { + Option::Some(2) + } + + fn layout() -> dojo::model::Layout { + dojo::model::Layout::Struct( + array![ + dojo::model::FieldLayout { + selector: 512066735765477566404754172672287371265995314501343422459174036873487219331, + layout: dojo::model::introspect::Introspect::::layout() + }, +dojo::model::FieldLayout { + selector: 1591024729085637502504777720563487898377940395575083379770417352976841400819, + layout: dojo::model::introspect::Introspect::::layout() + } + ].span() + ) + } + + #[inline(always)] + fn ty() -> dojo::model::introspect::Ty { + dojo::model::introspect::Ty::Struct( + dojo::model::introspect::Struct { + name: 'Vec2', + attrs: array![].span(), + children: array![ + dojo::model::introspect::Member { + name: 'x', + attrs: array![].span(), + ty: dojo::model::introspect::Introspect::::ty() + }, +dojo::model::introspect::Member { + name: 'y', + attrs: array![].span(), + ty: dojo::model::introspect::Introspect::::ty() + } + + ].span() + } + ) + } +} +impl PlainEnumSerde of core::serde::Serde:: { + fn serialize(self: @PlainEnum, ref output: core::array::Array) { + match self { + PlainEnum::Left(x) => { core::serde::Serde::serialize(@0, ref output); core::serde::Serde::serialize(x, ref output); }, + PlainEnum::Right(x) => { core::serde::Serde::serialize(@1, ref output); core::serde::Serde::serialize(x, ref output); }, + } + } + fn deserialize(ref serialized: core::array::Span) -> core::option::Option { + let idx: felt252 = core::serde::Serde::deserialize(ref serialized)?; + core::option::Option::Some( + match idx { + 0 => PlainEnum::Left(core::serde::Serde::deserialize(ref serialized)?), + 1 => PlainEnum::Right(core::serde::Serde::deserialize(ref serialized)?), + _ => { return core::option::Option::None; } + } + ) + } +} +impl PlainEnumCopy of core::traits::Copy::; +impl PlainEnumDrop of core::traits::Drop::; + +impl PlainEnumIntrospect<> of dojo::model::introspect::Introspect> { + #[inline(always)] + fn size() -> Option { + Option::Some(1) + } + + fn layout() -> dojo::model::Layout { + dojo::model::Layout::Enum( + array![ + dojo::model::FieldLayout { + selector: 0, + layout: dojo::model::Layout::Fixed(array![].span()) + }, +dojo::model::FieldLayout { + selector: 1, + layout: dojo::model::Layout::Fixed(array![].span()) + } + ].span() + ) + } + + #[inline(always)] + fn ty() -> dojo::model::introspect::Ty { + dojo::model::introspect::Ty::Enum( + dojo::model::introspect::Enum { + name: 'PlainEnum', + attrs: array![].span(), + children: array![ + ('Left', dojo::model::introspect::Ty::Tuple(array![].span())), +('Right', dojo::model::introspect::Ty::Tuple(array![].span())) + + ].span() + } + ) + } +} +impl EnumWithPrimitiveSerde of core::serde::Serde:: { + fn serialize(self: @EnumWithPrimitive, ref output: core::array::Array) { + match self { + EnumWithPrimitive::Left(x) => { core::serde::Serde::serialize(@0, ref output); core::serde::Serde::serialize(x, ref output); }, + EnumWithPrimitive::Right(x) => { core::serde::Serde::serialize(@1, ref output); core::serde::Serde::serialize(x, ref output); }, + } + } + fn deserialize(ref serialized: core::array::Span) -> core::option::Option { + let idx: felt252 = core::serde::Serde::deserialize(ref serialized)?; + core::option::Option::Some( + match idx { + 0 => EnumWithPrimitive::Left(core::serde::Serde::deserialize(ref serialized)?), + 1 => EnumWithPrimitive::Right(core::serde::Serde::deserialize(ref serialized)?), + _ => { return core::option::Option::None; } + } + ) + } +} +impl EnumWithPrimitiveCopy of core::traits::Copy::; +impl EnumWithPrimitiveDrop of core::traits::Drop::; + +impl EnumWithPrimitiveIntrospect<> of dojo::model::introspect::Introspect> { + #[inline(always)] + fn size() -> Option { + Option::Some(2) + } + + fn layout() -> dojo::model::Layout { + dojo::model::Layout::Enum( + array![ + dojo::model::FieldLayout { + selector: 0, + layout: dojo::model::introspect::Introspect::::layout() + }, +dojo::model::FieldLayout { + selector: 1, + layout: dojo::model::introspect::Introspect::::layout() + } + ].span() + ) + } + + #[inline(always)] + fn ty() -> dojo::model::introspect::Ty { + dojo::model::introspect::Ty::Enum( + dojo::model::introspect::Enum { + name: 'EnumWithPrimitive', + attrs: array![].span(), + children: array![ + ('Left', dojo::model::introspect::Introspect::::ty()), +('Right', dojo::model::introspect::Introspect::::ty()) + + ].span() + } + ) + } +} +impl EnumWithStructSerde of core::serde::Serde:: { + fn serialize(self: @EnumWithStruct, ref output: core::array::Array) { + match self { + EnumWithStruct::Left(x) => { core::serde::Serde::serialize(@0, ref output); core::serde::Serde::serialize(x, ref output); }, + EnumWithStruct::Right(x) => { core::serde::Serde::serialize(@1, ref output); core::serde::Serde::serialize(x, ref output); }, + } + } + fn deserialize(ref serialized: core::array::Span) -> core::option::Option { + let idx: felt252 = core::serde::Serde::deserialize(ref serialized)?; + core::option::Option::Some( + match idx { + 0 => EnumWithStruct::Left(core::serde::Serde::deserialize(ref serialized)?), + 1 => EnumWithStruct::Right(core::serde::Serde::deserialize(ref serialized)?), + _ => { return core::option::Option::None; } + } + ) + } +} +impl EnumWithStructCopy of core::traits::Copy::; +impl EnumWithStructDrop of core::traits::Drop::; + +impl EnumWithStructIntrospect<> of dojo::model::introspect::Introspect> { + #[inline(always)] + fn size() -> Option { + let sizes : Array> = array![ + dojo::model::introspect::Introspect::::size(), +Option::Some(1) + ]; + + if dojo::utils::any_none(@sizes) { + return Option::None; + } + Option::Some(dojo::utils::sum(sizes)) + + } + + fn layout() -> dojo::model::Layout { + dojo::model::Layout::Enum( + array![ + dojo::model::FieldLayout { + selector: 0, + layout: dojo::model::introspect::Introspect::::layout() + }, +dojo::model::FieldLayout { + selector: 1, + layout: dojo::model::introspect::Introspect::::layout() + } + ].span() + ) + } + + #[inline(always)] + fn ty() -> dojo::model::introspect::Ty { + dojo::model::introspect::Ty::Enum( + dojo::model::introspect::Enum { + name: 'EnumWithStruct', + attrs: array![].span(), + children: array![ + ('Left', dojo::model::introspect::Introspect::::ty()), +('Right', dojo::model::introspect::Introspect::::ty()) + + ].span() + } + ) + } +} +impl EnumWithSimpleArraySerde of core::serde::Serde:: { + fn serialize(self: @EnumWithSimpleArray, ref output: core::array::Array) { + match self { + EnumWithSimpleArray::Left(x) => { core::serde::Serde::serialize(@0, ref output); core::serde::Serde::serialize(x, ref output); }, + EnumWithSimpleArray::Right(x) => { core::serde::Serde::serialize(@1, ref output); core::serde::Serde::serialize(x, ref output); }, + } + } + fn deserialize(ref serialized: core::array::Span) -> core::option::Option { + let idx: felt252 = core::serde::Serde::deserialize(ref serialized)?; + core::option::Option::Some( + match idx { + 0 => EnumWithSimpleArray::Left(core::serde::Serde::deserialize(ref serialized)?), + 1 => EnumWithSimpleArray::Right(core::serde::Serde::deserialize(ref serialized)?), + _ => { return core::option::Option::None; } + } + ) + } +} +impl EnumWithSimpleArrayCopy of core::traits::Copy::; +impl EnumWithSimpleArrayDrop of core::traits::Drop::; + +impl EnumWithSimpleArrayIntrospect<> of dojo::model::introspect::Introspect> { + #[inline(always)] + fn size() -> Option { + Option::None + } + + fn layout() -> dojo::model::Layout { + dojo::model::Layout::Enum( + array![ + dojo::model::FieldLayout { + selector: 0, + layout: dojo::model::introspect::Introspect::>::layout() + }, +dojo::model::FieldLayout { + selector: 1, + layout: dojo::model::introspect::Introspect::>::layout() + } + ].span() + ) + } + + #[inline(always)] + fn ty() -> dojo::model::introspect::Ty { + dojo::model::introspect::Ty::Enum( + dojo::model::introspect::Enum { + name: 'EnumWithSimpleArray', + attrs: array![].span(), + children: array![ + ('Left', dojo::model::introspect::Ty::Array( + array![ + dojo::model::introspect::Introspect::::ty() + ].span() + )), +('Right', dojo::model::introspect::Ty::Array( + array![ + dojo::model::introspect::Introspect::::ty() + ].span() + )) + + ].span() + } + ) + } +} +impl EnumWithByteArraySerde of core::serde::Serde:: { + fn serialize(self: @EnumWithByteArray, ref output: core::array::Array) { + match self { + EnumWithByteArray::Left(x) => { core::serde::Serde::serialize(@0, ref output); core::serde::Serde::serialize(x, ref output); }, + EnumWithByteArray::Right(x) => { core::serde::Serde::serialize(@1, ref output); core::serde::Serde::serialize(x, ref output); }, + } + } + fn deserialize(ref serialized: core::array::Span) -> core::option::Option { + let idx: felt252 = core::serde::Serde::deserialize(ref serialized)?; + core::option::Option::Some( + match idx { + 0 => EnumWithByteArray::Left(core::serde::Serde::deserialize(ref serialized)?), + 1 => EnumWithByteArray::Right(core::serde::Serde::deserialize(ref serialized)?), + _ => { return core::option::Option::None; } + } + ) + } +} +impl EnumWithByteArrayCopy of core::traits::Copy::; +impl EnumWithByteArrayDrop of core::traits::Drop::; + +impl EnumWithByteArrayIntrospect<> of dojo::model::introspect::Introspect> { + #[inline(always)] + fn size() -> Option { + Option::None + } + + fn layout() -> dojo::model::Layout { + dojo::model::Layout::Enum( + array![ + dojo::model::FieldLayout { + selector: 0, + layout: dojo::model::introspect::Introspect::::layout() + }, +dojo::model::FieldLayout { + selector: 1, + layout: dojo::model::introspect::Introspect::::layout() + } + ].span() + ) + } + + #[inline(always)] + fn ty() -> dojo::model::introspect::Ty { + dojo::model::introspect::Ty::Enum( + dojo::model::introspect::Enum { + name: 'EnumWithByteArray', + attrs: array![].span(), + children: array![ + ('Left', dojo::model::introspect::Ty::ByteArray), +('Right', dojo::model::introspect::Ty::ByteArray) + + ].span() + } + ) + } +} +impl EnumWithSimpleTupleSerde of core::serde::Serde:: { + fn serialize(self: @EnumWithSimpleTuple, ref output: core::array::Array) { + match self { + EnumWithSimpleTuple::Left(x) => { core::serde::Serde::serialize(@0, ref output); core::serde::Serde::serialize(x, ref output); }, + EnumWithSimpleTuple::Right(x) => { core::serde::Serde::serialize(@1, ref output); core::serde::Serde::serialize(x, ref output); }, + } + } + fn deserialize(ref serialized: core::array::Span) -> core::option::Option { + let idx: felt252 = core::serde::Serde::deserialize(ref serialized)?; + core::option::Option::Some( + match idx { + 0 => EnumWithSimpleTuple::Left(core::serde::Serde::deserialize(ref serialized)?), + 1 => EnumWithSimpleTuple::Right(core::serde::Serde::deserialize(ref serialized)?), + _ => { return core::option::Option::None; } + } + ) + } +} +impl EnumWithSimpleTupleCopy of core::traits::Copy::; +impl EnumWithSimpleTupleDrop of core::traits::Drop::; + +impl EnumWithSimpleTupleIntrospect<> of dojo::model::introspect::Introspect> { + #[inline(always)] + fn size() -> Option { + Option::Some(4) + } + + fn layout() -> dojo::model::Layout { + dojo::model::Layout::Enum( + array![ + dojo::model::FieldLayout { + selector: 0, + layout: dojo::model::Layout::Tuple( + array![ + dojo::model::introspect::Introspect::::layout(), +dojo::model::introspect::Introspect::::layout() + ].span() + ) + }, +dojo::model::FieldLayout { + selector: 1, + layout: dojo::model::Layout::Tuple( + array![ + dojo::model::introspect::Introspect::::layout(), +dojo::model::introspect::Introspect::::layout() + ].span() + ) + } + ].span() + ) + } + + #[inline(always)] + fn ty() -> dojo::model::introspect::Ty { + dojo::model::introspect::Ty::Enum( + dojo::model::introspect::Enum { + name: 'EnumWithSimpleTuple', + attrs: array![].span(), + children: array![ + ('Left', dojo::model::introspect::Ty::Tuple( + array![ + dojo::model::introspect::Introspect::::ty(), +dojo::model::introspect::Introspect::::ty() + ].span() + )), +('Right', dojo::model::introspect::Ty::Tuple( + array![ + dojo::model::introspect::Introspect::::ty(), +dojo::model::introspect::Introspect::::ty() + ].span() + )) + + ].span() + } + ) + } +} +impl EnumWithComplexTupleSerde of core::serde::Serde:: { + fn serialize(self: @EnumWithComplexTuple, ref output: core::array::Array) { + match self { + EnumWithComplexTuple::Left(x) => { core::serde::Serde::serialize(@0, ref output); core::serde::Serde::serialize(x, ref output); }, + EnumWithComplexTuple::Right(x) => { core::serde::Serde::serialize(@1, ref output); core::serde::Serde::serialize(x, ref output); }, + } + } + fn deserialize(ref serialized: core::array::Span) -> core::option::Option { + let idx: felt252 = core::serde::Serde::deserialize(ref serialized)?; + core::option::Option::Some( + match idx { + 0 => EnumWithComplexTuple::Left(core::serde::Serde::deserialize(ref serialized)?), + 1 => EnumWithComplexTuple::Right(core::serde::Serde::deserialize(ref serialized)?), + _ => { return core::option::Option::None; } + } + ) + } +} +impl EnumWithComplexTupleCopy of core::traits::Copy::; +impl EnumWithComplexTupleDrop of core::traits::Drop::; + +impl EnumWithComplexTupleIntrospect<> of dojo::model::introspect::Introspect> { + #[inline(always)] + fn size() -> Option { + let sizes : Array> = array![ + dojo::model::introspect::Introspect::::size(), +Option::Some(2) + ]; + + if dojo::utils::any_none(@sizes) { + return Option::None; + } + Option::Some(dojo::utils::sum(sizes)) + + } + + fn layout() -> dojo::model::Layout { + dojo::model::Layout::Enum( + array![ + dojo::model::FieldLayout { + selector: 0, + layout: dojo::model::Layout::Tuple( + array![ + dojo::model::introspect::Introspect::::layout(), +dojo::model::introspect::Introspect::::layout() + ].span() + ) + }, +dojo::model::FieldLayout { + selector: 1, + layout: dojo::model::Layout::Tuple( + array![ + dojo::model::introspect::Introspect::::layout(), +dojo::model::introspect::Introspect::::layout() + ].span() + ) + } + ].span() + ) + } + + #[inline(always)] + fn ty() -> dojo::model::introspect::Ty { + dojo::model::introspect::Ty::Enum( + dojo::model::introspect::Enum { + name: 'EnumWithComplexTuple', + attrs: array![].span(), + children: array![ + ('Left', dojo::model::introspect::Ty::Tuple( + array![ + dojo::model::introspect::Introspect::::ty(), +dojo::model::introspect::Introspect::::ty() + ].span() + )), +('Right', dojo::model::introspect::Ty::Tuple( + array![ + dojo::model::introspect::Introspect::::ty(), +dojo::model::introspect::Introspect::::ty() + ].span() + )) + + ].span() + } + ) + } +} +impl EnumWithPrimitiveSerde of core::serde::Serde:: { + fn serialize(self: @EnumWithPrimitive, ref output: core::array::Array) { + match self { + EnumWithPrimitive::Left(x) => { core::serde::Serde::serialize(@0, ref output); core::serde::Serde::serialize(x, ref output); }, + EnumWithPrimitive::Right(x) => { core::serde::Serde::serialize(@1, ref output); core::serde::Serde::serialize(x, ref output); }, + } + } + fn deserialize(ref serialized: core::array::Span) -> core::option::Option { + let idx: felt252 = core::serde::Serde::deserialize(ref serialized)?; + core::option::Option::Some( + match idx { + 0 => EnumWithPrimitive::Left(core::serde::Serde::deserialize(ref serialized)?), + 1 => EnumWithPrimitive::Right(core::serde::Serde::deserialize(ref serialized)?), + _ => { return core::option::Option::None; } + } + ) + } +} +impl EnumWithPrimitiveCopy of core::traits::Copy::; +impl EnumWithPrimitiveDrop of core::traits::Drop::; + +impl EnumWithPrimitiveIntrospect<> of dojo::model::introspect::Introspect> { + #[inline(always)] + fn size() -> Option { + Option::Some(2) + } + + fn layout() -> dojo::model::Layout { + dojo::model::Layout::Enum( + array![ + dojo::model::FieldLayout { + selector: 0, + layout: dojo::model::introspect::Introspect::::layout() + }, +dojo::model::FieldLayout { + selector: 1, + layout: dojo::model::introspect::Introspect::::layout() + } + ].span() + ) + } + + #[inline(always)] + fn ty() -> dojo::model::introspect::Ty { + dojo::model::introspect::Ty::Enum( + dojo::model::introspect::Enum { + name: 'EnumWithPrimitive', + attrs: array![].span(), + children: array![ + ('Left', dojo::model::introspect::Introspect::::ty()), +('Right', dojo::model::introspect::Introspect::::ty()) + + ].span() + } + ) + } +} +impl EnumCustomSerde of core::serde::Serde:: { + fn serialize(self: @EnumCustom, ref output: core::array::Array) { + match self { + EnumCustom::Left(x) => { core::serde::Serde::serialize(@0, ref output); core::serde::Serde::serialize(x, ref output); }, + EnumCustom::Right(x) => { core::serde::Serde::serialize(@1, ref output); core::serde::Serde::serialize(x, ref output); }, + } + } + fn deserialize(ref serialized: core::array::Span) -> core::option::Option { + let idx: felt252 = core::serde::Serde::deserialize(ref serialized)?; + core::option::Option::Some( + match idx { + 0 => EnumCustom::Left(core::serde::Serde::deserialize(ref serialized)?), + 1 => EnumCustom::Right(core::serde::Serde::deserialize(ref serialized)?), + _ => { return core::option::Option::None; } + } + ) + } +} +impl EnumCustomCopy of core::traits::Copy::; +impl EnumCustomDrop of core::traits::Drop::; + +impl EnumCustomIntrospect<> of dojo::model::introspect::Introspect> { + #[inline(always)] + fn size() -> Option { + let sizes : Array> = array![ + dojo::model::introspect::Introspect::::size(), +Option::Some(1) + ]; + + if dojo::utils::any_none(@sizes) { + return Option::None; + } + Option::Some(dojo::utils::sum(sizes)) + + } + + fn layout() -> dojo::model::Layout { + dojo::model::Layout::Enum( + array![ + dojo::model::FieldLayout { + selector: 0, + layout: dojo::model::introspect::Introspect::::layout() + }, +dojo::model::FieldLayout { + selector: 1, + layout: dojo::model::introspect::Introspect::::layout() + } + ].span() + ) + } + + #[inline(always)] + fn ty() -> dojo::model::introspect::Ty { + dojo::model::introspect::Ty::Enum( + dojo::model::introspect::Enum { + name: 'EnumCustom', + attrs: array![].span(), + children: array![ + ('Left', dojo::model::introspect::Introspect::::ty()), +('Right', dojo::model::introspect::Introspect::::ty()) + + ].span() + } + ) + } +} +impl EnumTupleMixSerde of core::serde::Serde:: { + fn serialize(self: @EnumTupleMix, ref output: core::array::Array) { + match self { + EnumTupleMix::Left(x) => { core::serde::Serde::serialize(@0, ref output); core::serde::Serde::serialize(x, ref output); }, + EnumTupleMix::Right(x) => { core::serde::Serde::serialize(@1, ref output); core::serde::Serde::serialize(x, ref output); }, + } + } + fn deserialize(ref serialized: core::array::Span) -> core::option::Option { + let idx: felt252 = core::serde::Serde::deserialize(ref serialized)?; + core::option::Option::Some( + match idx { + 0 => EnumTupleMix::Left(core::serde::Serde::deserialize(ref serialized)?), + 1 => EnumTupleMix::Right(core::serde::Serde::deserialize(ref serialized)?), + _ => { return core::option::Option::None; } + } + ) + } +} +impl EnumTupleMixCopy of core::traits::Copy::; +impl EnumTupleMixDrop of core::traits::Drop::; + +impl EnumTupleMixIntrospect<> of dojo::model::introspect::Introspect> { + #[inline(always)] + fn size() -> Option { + let sizes : Array> = array![ + dojo::model::introspect::Introspect::::size(), +dojo::model::introspect::Introspect::::size(), +Option::Some(2) + ]; + + if dojo::utils::any_none(@sizes) { + return Option::None; + } + Option::Some(dojo::utils::sum(sizes)) + + } + + fn layout() -> dojo::model::Layout { + dojo::model::Layout::Enum( + array![ + dojo::model::FieldLayout { + selector: 0, + layout: dojo::model::Layout::Tuple( + array![ + dojo::model::introspect::Introspect::::layout(), +dojo::model::introspect::Introspect::::layout(), +dojo::model::introspect::Introspect::::layout() + ].span() + ) + }, +dojo::model::FieldLayout { + selector: 1, + layout: dojo::model::Layout::Tuple( + array![ + dojo::model::introspect::Introspect::::layout(), +dojo::model::introspect::Introspect::::layout(), +dojo::model::introspect::Introspect::::layout() + ].span() + ) + } + ].span() + ) + } + + #[inline(always)] + fn ty() -> dojo::model::introspect::Ty { + dojo::model::introspect::Ty::Enum( + dojo::model::introspect::Enum { + name: 'EnumTupleMix', + attrs: array![].span(), + children: array![ + ('Left', dojo::model::introspect::Ty::Tuple( + array![ + dojo::model::introspect::Introspect::::ty(), +dojo::model::introspect::Introspect::::ty(), +dojo::model::introspect::Introspect::::ty() + ].span() + )), +('Right', dojo::model::introspect::Ty::Tuple( + array![ + dojo::model::introspect::Introspect::::ty(), +dojo::model::introspect::Introspect::::ty(), +dojo::model::introspect::Introspect::::ty() + ].span() + )) + + ].span() + } + ) + } +} +impl EnumWithDifferentVariantDataSerde of core::serde::Serde:: { + fn serialize(self: @EnumWithDifferentVariantData, ref output: core::array::Array) { + match self { + EnumWithDifferentVariantData::One(x) => { core::serde::Serde::serialize(@0, ref output); core::serde::Serde::serialize(x, ref output); }, + EnumWithDifferentVariantData::Two(x) => { core::serde::Serde::serialize(@1, ref output); core::serde::Serde::serialize(x, ref output); }, + EnumWithDifferentVariantData::Three(x) => { core::serde::Serde::serialize(@2, ref output); core::serde::Serde::serialize(x, ref output); }, + } + } + fn deserialize(ref serialized: core::array::Span) -> core::option::Option { + let idx: felt252 = core::serde::Serde::deserialize(ref serialized)?; + core::option::Option::Some( + match idx { + 0 => EnumWithDifferentVariantData::One(core::serde::Serde::deserialize(ref serialized)?), + 1 => EnumWithDifferentVariantData::Two(core::serde::Serde::deserialize(ref serialized)?), + 2 => EnumWithDifferentVariantData::Three(core::serde::Serde::deserialize(ref serialized)?), + _ => { return core::option::Option::None; } + } + ) + } +} +impl EnumWithDifferentVariantDataCopy of core::traits::Copy::; +impl EnumWithDifferentVariantDataDrop of core::traits::Drop::; + +impl EnumWithDifferentVariantDataIntrospect<> of dojo::model::introspect::Introspect> { + #[inline(always)] + fn size() -> Option { + Option::None + } + + fn layout() -> dojo::model::Layout { + dojo::model::Layout::Enum( + array![ + dojo::model::FieldLayout { + selector: 0, + layout: dojo::model::Layout::Fixed(array![].span()) + }, +dojo::model::FieldLayout { + selector: 1, + layout: dojo::model::introspect::Introspect::::layout() + }, +dojo::model::FieldLayout { + selector: 2, + layout: dojo::model::Layout::Tuple( + array![ + dojo::model::introspect::Introspect::::layout(), +dojo::model::introspect::Introspect::::layout() + ].span() + ) + } + ].span() + ) + } + + #[inline(always)] + fn ty() -> dojo::model::introspect::Ty { + dojo::model::introspect::Ty::Enum( + dojo::model::introspect::Enum { + name: 'EnumWithDifferentVariantData', + attrs: array![].span(), + children: array![ + ('One', dojo::model::introspect::Ty::Tuple(array![].span())), +('Two', dojo::model::introspect::Introspect::::ty()), +('Three', dojo::model::introspect::Ty::Tuple( + array![ + dojo::model::introspect::Introspect::::ty(), +dojo::model::introspect::Introspect::::ty() + ].span() + )) + + ].span() + } + ) + } +} +impl StructWithPrimitivesCopy of core::traits::Copy::; +impl StructWithPrimitivesDrop of core::traits::Drop::; + +impl StructWithPrimitivesIntrospect<> of dojo::model::introspect::Introspect> { + #[inline(always)] + fn size() -> Option { + Option::Some(2) + } + + fn layout() -> dojo::model::Layout { + dojo::model::Layout::Struct( + array![ + dojo::model::FieldLayout { + selector: 387461982739864353524563589639770327077359184971688375275386807599796929637, + layout: dojo::model::introspect::Introspect::::layout() + }, +dojo::model::FieldLayout { + selector: 564613130574576288414461160574656432422962213642984413874723251824844509768, + layout: dojo::model::introspect::Introspect::::layout() + } + ].span() + ) + } + + #[inline(always)] + fn ty() -> dojo::model::introspect::Ty { + dojo::model::introspect::Ty::Struct( + dojo::model::introspect::Struct { + name: 'StructWithPrimitives', + attrs: array![].span(), + children: array![ + dojo::model::introspect::Member { + name: 'player', + attrs: array!['key'].span(), + ty: dojo::model::introspect::Introspect::::ty() + }, +dojo::model::introspect::Member { + name: 'before', + attrs: array![].span(), + ty: dojo::model::introspect::Introspect::::ty() + }, +dojo::model::introspect::Member { + name: 'after', + attrs: array![].span(), + ty: dojo::model::introspect::Introspect::::ty() + } + + ].span() + } + ) + } +} +impl StructWithStructCopy of core::traits::Copy::; +impl StructWithStructDrop of core::traits::Drop::; + +impl StructWithStructIntrospect<> of dojo::model::introspect::Introspect> { + #[inline(always)] + fn size() -> Option { + let sizes : Array> = array![ + dojo::model::introspect::Introspect::::size(), +Option::Some(1) + ]; + + if dojo::utils::any_none(@sizes) { + return Option::None; + } + Option::Some(dojo::utils::sum(sizes)) + + } + + fn layout() -> dojo::model::Layout { + dojo::model::Layout::Struct( + array![ + dojo::model::FieldLayout { + selector: 387461982739864353524563589639770327077359184971688375275386807599796929637, + layout: dojo::model::introspect::Introspect::::layout() + }, +dojo::model::FieldLayout { + selector: 564613130574576288414461160574656432422962213642984413874723251824844509768, + layout: dojo::model::introspect::Introspect::::layout() + } + ].span() + ) + } + + #[inline(always)] + fn ty() -> dojo::model::introspect::Ty { + dojo::model::introspect::Ty::Struct( + dojo::model::introspect::Struct { + name: 'StructWithStruct', + attrs: array![].span(), + children: array![ + dojo::model::introspect::Member { + name: 'player', + attrs: array!['key'].span(), + ty: dojo::model::introspect::Introspect::::ty() + }, +dojo::model::introspect::Member { + name: 'before', + attrs: array![].span(), + ty: dojo::model::introspect::Introspect::::ty() + }, +dojo::model::introspect::Member { + name: 'after', + attrs: array![].span(), + ty: dojo::model::introspect::Introspect::::ty() + } + + ].span() + } + ) + } +} +impl StructWithSimpleArrayCopy of core::traits::Copy::; +impl StructWithSimpleArrayDrop of core::traits::Drop::; + +impl StructWithSimpleArrayIntrospect<> of dojo::model::introspect::Introspect> { + #[inline(always)] + fn size() -> Option { + Option::None + } + + fn layout() -> dojo::model::Layout { + dojo::model::Layout::Struct( + array![ + dojo::model::FieldLayout { + selector: 387461982739864353524563589639770327077359184971688375275386807599796929637, + layout: dojo::model::introspect::Introspect::::layout() + }, +dojo::model::FieldLayout { + selector: 564613130574576288414461160574656432422962213642984413874723251824844509768, + layout: dojo::model::introspect::Introspect::>::layout() + } + ].span() + ) + } + + #[inline(always)] + fn ty() -> dojo::model::introspect::Ty { + dojo::model::introspect::Ty::Struct( + dojo::model::introspect::Struct { + name: 'StructWithSimpleArray', + attrs: array![].span(), + children: array![ + dojo::model::introspect::Member { + name: 'player', + attrs: array!['key'].span(), + ty: dojo::model::introspect::Introspect::::ty() + }, +dojo::model::introspect::Member { + name: 'before', + attrs: array![].span(), + ty: dojo::model::introspect::Introspect::::ty() + }, +dojo::model::introspect::Member { + name: 'after', + attrs: array![].span(), + ty: dojo::model::introspect::Ty::Array( + array![ + dojo::model::introspect::Introspect::::ty() + ].span() + ) + } + + ].span() + } + ) + } +} +impl StructWithByteArrayCopy of core::traits::Copy::; +impl StructWithByteArrayDrop of core::traits::Drop::; + +impl StructWithByteArrayIntrospect<> of dojo::model::introspect::Introspect> { + #[inline(always)] + fn size() -> Option { + Option::None + } + + fn layout() -> dojo::model::Layout { + dojo::model::Layout::Struct( + array![ + dojo::model::FieldLayout { + selector: 387461982739864353524563589639770327077359184971688375275386807599796929637, + layout: dojo::model::introspect::Introspect::::layout() + }, +dojo::model::FieldLayout { + selector: 564613130574576288414461160574656432422962213642984413874723251824844509768, + layout: dojo::model::introspect::Introspect::::layout() + } + ].span() + ) + } + + #[inline(always)] + fn ty() -> dojo::model::introspect::Ty { + dojo::model::introspect::Ty::Struct( + dojo::model::introspect::Struct { + name: 'StructWithByteArray', + attrs: array![].span(), + children: array![ + dojo::model::introspect::Member { + name: 'player', + attrs: array!['key'].span(), + ty: dojo::model::introspect::Introspect::::ty() + }, +dojo::model::introspect::Member { + name: 'before', + attrs: array![].span(), + ty: dojo::model::introspect::Introspect::::ty() + }, +dojo::model::introspect::Member { + name: 'after', + attrs: array![].span(), + ty: dojo::model::introspect::Ty::ByteArray + } + + ].span() + } + ) + } +} +impl StructWithComplexArrayCopy of core::traits::Copy::; +impl StructWithComplexArrayDrop of core::traits::Drop::; + +impl StructWithComplexArrayIntrospect<> of dojo::model::introspect::Introspect> { + #[inline(always)] + fn size() -> Option { + Option::None + } + + fn layout() -> dojo::model::Layout { + dojo::model::Layout::Struct( + array![ + dojo::model::FieldLayout { + selector: 387461982739864353524563589639770327077359184971688375275386807599796929637, + layout: dojo::model::introspect::Introspect::::layout() + }, +dojo::model::FieldLayout { + selector: 564613130574576288414461160574656432422962213642984413874723251824844509768, + layout: dojo::model::introspect::Introspect::>::layout() + } + ].span() + ) + } + + #[inline(always)] + fn ty() -> dojo::model::introspect::Ty { + dojo::model::introspect::Ty::Struct( + dojo::model::introspect::Struct { + name: 'StructWithComplexArray', + attrs: array![].span(), + children: array![ + dojo::model::introspect::Member { + name: 'player', + attrs: array!['key'].span(), + ty: dojo::model::introspect::Introspect::::ty() + }, +dojo::model::introspect::Member { + name: 'before', + attrs: array![].span(), + ty: dojo::model::introspect::Introspect::::ty() + }, +dojo::model::introspect::Member { + name: 'after', + attrs: array![].span(), + ty: dojo::model::introspect::Ty::Array( + array![ + dojo::model::introspect::Introspect::::ty() + ].span() + ) + } + + ].span() + } + ) + } +} +impl StructWithSimpleTupleCopy of core::traits::Copy::; +impl StructWithSimpleTupleDrop of core::traits::Drop::; + +impl StructWithSimpleTupleIntrospect<> of dojo::model::introspect::Introspect> { + #[inline(always)] + fn size() -> Option { + Option::Some(4) + } + + fn layout() -> dojo::model::Layout { + dojo::model::Layout::Struct( + array![ + dojo::model::FieldLayout { + selector: 387461982739864353524563589639770327077359184971688375275386807599796929637, + layout: dojo::model::introspect::Introspect::::layout() + }, +dojo::model::FieldLayout { + selector: 564613130574576288414461160574656432422962213642984413874723251824844509768, + layout: dojo::model::Layout::Tuple( + array![ + dojo::model::introspect::Introspect::::layout(), +dojo::model::introspect::Introspect::::layout() + ].span() + ) + } + ].span() + ) + } + + #[inline(always)] + fn ty() -> dojo::model::introspect::Ty { + dojo::model::introspect::Ty::Struct( + dojo::model::introspect::Struct { + name: 'StructWithSimpleTuple', + attrs: array![].span(), + children: array![ + dojo::model::introspect::Member { + name: 'player', + attrs: array!['key'].span(), + ty: dojo::model::introspect::Introspect::::ty() + }, +dojo::model::introspect::Member { + name: 'before', + attrs: array![].span(), + ty: dojo::model::introspect::Introspect::::ty() + }, +dojo::model::introspect::Member { + name: 'after', + attrs: array![].span(), + ty: dojo::model::introspect::Ty::Tuple( + array![ + dojo::model::introspect::Introspect::::ty(), +dojo::model::introspect::Introspect::::ty() + ].span() + ) + } + + ].span() + } + ) + } +} +impl StructWithComplexTupleCopy of core::traits::Copy::; +impl StructWithComplexTupleDrop of core::traits::Drop::; + +impl StructWithComplexTupleIntrospect<> of dojo::model::introspect::Introspect> { + #[inline(always)] + fn size() -> Option { + let sizes : Array> = array![ + dojo::model::introspect::Introspect::::size(), +dojo::model::introspect::Introspect::::size(), +Option::Some(2) + ]; + + if dojo::utils::any_none(@sizes) { + return Option::None; + } + Option::Some(dojo::utils::sum(sizes)) + + } + + fn layout() -> dojo::model::Layout { + dojo::model::Layout::Struct( + array![ + dojo::model::FieldLayout { + selector: 387461982739864353524563589639770327077359184971688375275386807599796929637, + layout: dojo::model::introspect::Introspect::::layout() + }, +dojo::model::FieldLayout { + selector: 564613130574576288414461160574656432422962213642984413874723251824844509768, + layout: dojo::model::Layout::Tuple( + array![ + dojo::model::introspect::Introspect::::layout(), +dojo::model::introspect::Introspect::::layout(), +dojo::model::introspect::Introspect::::layout() + ].span() + ) + } + ].span() + ) + } + + #[inline(always)] + fn ty() -> dojo::model::introspect::Ty { + dojo::model::introspect::Ty::Struct( + dojo::model::introspect::Struct { + name: 'StructWithComplexTuple', + attrs: array![].span(), + children: array![ + dojo::model::introspect::Member { + name: 'player', + attrs: array!['key'].span(), + ty: dojo::model::introspect::Introspect::::ty() + }, +dojo::model::introspect::Member { + name: 'before', + attrs: array![].span(), + ty: dojo::model::introspect::Introspect::::ty() + }, +dojo::model::introspect::Member { + name: 'after', + attrs: array![].span(), + ty: dojo::model::introspect::Ty::Tuple( + array![ + dojo::model::introspect::Introspect::::ty(), +dojo::model::introspect::Introspect::::ty(), +dojo::model::introspect::Introspect::::ty() + ].span() + ) + } + + ].span() + } + ) + } +} +impl StructWithNestedArraysCopy of core::traits::Copy::; +impl StructWithNestedArraysDrop of core::traits::Drop::; + +impl StructWithNestedArraysIntrospect<> of dojo::model::introspect::Introspect> { + #[inline(always)] + fn size() -> Option { + Option::None + } + + fn layout() -> dojo::model::Layout { + dojo::model::Layout::Struct( + array![ + dojo::model::FieldLayout { + selector: 387461982739864353524563589639770327077359184971688375275386807599796929637, + layout: dojo::model::introspect::Introspect::::layout() + }, +dojo::model::FieldLayout { + selector: 564613130574576288414461160574656432422962213642984413874723251824844509768, + layout: dojo::model::Layout::Array( + array![ + dojo::model::Layout::Array( + array![ + dojo::model::introspect::Introspect::>::layout() + ].span() + ) + ].span() + ) + } + ].span() + ) + } + + #[inline(always)] + fn ty() -> dojo::model::introspect::Ty { + dojo::model::introspect::Ty::Struct( + dojo::model::introspect::Struct { + name: 'StructWithNestedArrays', + attrs: array![].span(), + children: array![ + dojo::model::introspect::Member { + name: 'player', + attrs: array!['key'].span(), + ty: dojo::model::introspect::Introspect::::ty() + }, +dojo::model::introspect::Member { + name: 'before', + attrs: array![].span(), + ty: dojo::model::introspect::Introspect::::ty() + }, +dojo::model::introspect::Member { + name: 'after', + attrs: array![].span(), + ty: dojo::model::introspect::Ty::Array( + array![ + dojo::model::introspect::Ty::Array( + array![ + dojo::model::introspect::Ty::Array( + array![ + dojo::model::introspect::Introspect::::ty() + ].span() + ) + ].span() + ) + ].span() + ) + } + + ].span() + } + ) + } +} +impl StructWithNestedTuplesCopy of core::traits::Copy::; +impl StructWithNestedTuplesDrop of core::traits::Drop::; + +impl StructWithNestedTuplesIntrospect<> of dojo::model::introspect::Introspect> { + #[inline(always)] + fn size() -> Option { + let sizes : Array> = array![ + dojo::model::introspect::Introspect::::size(), +dojo::model::introspect::Introspect::::size(), +Option::Some(3) + ]; + + if dojo::utils::any_none(@sizes) { + return Option::None; + } + Option::Some(dojo::utils::sum(sizes)) + + } + + fn layout() -> dojo::model::Layout { + dojo::model::Layout::Struct( + array![ + dojo::model::FieldLayout { + selector: 387461982739864353524563589639770327077359184971688375275386807599796929637, + layout: dojo::model::introspect::Introspect::::layout() + }, +dojo::model::FieldLayout { + selector: 564613130574576288414461160574656432422962213642984413874723251824844509768, + layout: dojo::model::Layout::Tuple( + array![ + dojo::model::Layout::Tuple( + array![ + dojo::model::introspect::Introspect::::layout(), +dojo::model::introspect::Introspect::::layout() + ].span() + ), +dojo::model::Layout::Tuple( + array![ + dojo::model::introspect::Introspect::::layout(), +dojo::model::introspect::Introspect::::layout() + ].span() + ) + ].span() + ) + } + ].span() + ) + } + + #[inline(always)] + fn ty() -> dojo::model::introspect::Ty { + dojo::model::introspect::Ty::Struct( + dojo::model::introspect::Struct { + name: 'StructWithNestedTuples', + attrs: array![].span(), + children: array![ + dojo::model::introspect::Member { + name: 'player', + attrs: array!['key'].span(), + ty: dojo::model::introspect::Introspect::::ty() + }, +dojo::model::introspect::Member { + name: 'before', + attrs: array![].span(), + ty: dojo::model::introspect::Introspect::::ty() + }, +dojo::model::introspect::Member { + name: 'after', + attrs: array![].span(), + ty: dojo::model::introspect::Ty::Tuple( + array![ + dojo::model::introspect::Ty::Tuple( + array![ + dojo::model::introspect::Introspect::::ty(), +dojo::model::introspect::Introspect::::ty() + ].span() + ), +dojo::model::introspect::Ty::Tuple( + array![ + dojo::model::introspect::Introspect::::ty(), +dojo::model::introspect::Introspect::::ty() + ].span() + ) + ].span() + ) + } + + ].span() + } + ) + } +} +impl StructWithNestedTuplesAndByteArrayCopy of core::traits::Copy::; +impl StructWithNestedTuplesAndByteArrayDrop of core::traits::Drop::; + +impl StructWithNestedTuplesAndByteArrayIntrospect<> of dojo::model::introspect::Introspect> { + #[inline(always)] + fn size() -> Option { + Option::None + } + + fn layout() -> dojo::model::Layout { + dojo::model::Layout::Struct( + array![ + dojo::model::FieldLayout { + selector: 387461982739864353524563589639770327077359184971688375275386807599796929637, + layout: dojo::model::introspect::Introspect::::layout() + }, +dojo::model::FieldLayout { + selector: 564613130574576288414461160574656432422962213642984413874723251824844509768, + layout: dojo::model::Layout::Tuple( + array![ + dojo::model::Layout::Tuple( + array![ + dojo::model::introspect::Introspect::::layout(), +dojo::model::introspect::Introspect::::layout() + ].span() + ), +dojo::model::Layout::Tuple( + array![ + dojo::model::introspect::Introspect::::layout(), +dojo::model::introspect::Introspect::::layout() + ].span() + ) + ].span() + ) + } + ].span() + ) + } + + #[inline(always)] + fn ty() -> dojo::model::introspect::Ty { + dojo::model::introspect::Ty::Struct( + dojo::model::introspect::Struct { + name: 'StructWithNestedTuplesAndByteArray', + attrs: array![].span(), + children: array![ + dojo::model::introspect::Member { + name: 'player', + attrs: array!['key'].span(), + ty: dojo::model::introspect::Introspect::::ty() + }, +dojo::model::introspect::Member { + name: 'before', + attrs: array![].span(), + ty: dojo::model::introspect::Introspect::::ty() + }, +dojo::model::introspect::Member { + name: 'after', + attrs: array![].span(), + ty: dojo::model::introspect::Ty::Tuple( + array![ + dojo::model::introspect::Ty::Tuple( + array![ + dojo::model::introspect::Introspect::::ty(), +dojo::model::introspect::Introspect::::ty() + ].span() + ), +dojo::model::introspect::Ty::Tuple( + array![ + dojo::model::introspect::Introspect::::ty(), +dojo::model::introspect::Ty::ByteArray + ].span() + ) + ].span() + ) + } + + ].span() + } + ) + } +} +impl StructWithNestedEverythingCopy of core::traits::Copy::; +impl StructWithNestedEverythingDrop of core::traits::Drop::; + +impl StructWithNestedEverythingIntrospect<> of dojo::model::introspect::Introspect> { + #[inline(always)] + fn size() -> Option { + Option::None + } + + fn layout() -> dojo::model::Layout { + dojo::model::Layout::Struct( + array![ + dojo::model::FieldLayout { + selector: 387461982739864353524563589639770327077359184971688375275386807599796929637, + layout: dojo::model::introspect::Introspect::::layout() + }, +dojo::model::FieldLayout { + selector: 564613130574576288414461160574656432422962213642984413874723251824844509768, + layout: dojo::model::Layout::Tuple( + array![ + dojo::model::Layout::Tuple( + array![ + dojo::model::introspect::Introspect::::layout(), +dojo::model::introspect::Introspect::::layout() + ].span() + ), +dojo::model::Layout::Tuple( + array![ + dojo::model::introspect::Introspect::::layout(), +dojo::model::introspect::Introspect::::layout() + ].span() + ), +dojo::model::Layout::Tuple( + array![ + dojo::model::Layout::Array( + array![ + dojo::model::Layout::Tuple( + array![ + dojo::model::introspect::Introspect::::layout(), +dojo::model::introspect::Introspect::::layout() + ].span() + ) + ].span() + ), +dojo::model::introspect::Introspect::::layout() + ].span() + ), +dojo::model::Layout::Tuple( + array![ + dojo::model::introspect::Introspect::::layout() + ].span() + ) + ].span() + ) + } + ].span() + ) + } + + #[inline(always)] + fn ty() -> dojo::model::introspect::Ty { + dojo::model::introspect::Ty::Struct( + dojo::model::introspect::Struct { + name: 'StructWithNestedEverything', + attrs: array![].span(), + children: array![ + dojo::model::introspect::Member { + name: 'player', + attrs: array!['key'].span(), + ty: dojo::model::introspect::Introspect::::ty() + }, +dojo::model::introspect::Member { + name: 'before', + attrs: array![].span(), + ty: dojo::model::introspect::Introspect::::ty() + }, +dojo::model::introspect::Member { + name: 'after', + attrs: array![].span(), + ty: dojo::model::introspect::Ty::Tuple( + array![ + dojo::model::introspect::Ty::Tuple( + array![ + dojo::model::introspect::Introspect::::ty(), +dojo::model::introspect::Introspect::::ty() + ].span() + ), +dojo::model::introspect::Ty::Tuple( + array![ + dojo::model::introspect::Introspect::::ty(), +dojo::model::introspect::Introspect::::ty() + ].span() + ), +dojo::model::introspect::Ty::Tuple( + array![ + dojo::model::introspect::Ty::Array( + array![ + dojo::model::introspect::Ty::Tuple( + array![ + dojo::model::introspect::Introspect::::ty(), +dojo::model::introspect::Introspect::::ty() + ].span() + ) + ].span() + ), +dojo::model::introspect::Introspect::::ty() + ].span() + ), +dojo::model::introspect::Ty::Tuple( + array![ + dojo::model::introspect::Introspect::::ty() + ].span() + ) + ].span() + ) + } + + ].span() + } + ) + } +} +impl GenericStructCopy> of core::traits::Copy::>; +impl GenericStructDrop> of core::traits::Drop::>; +impl GenericStructSerde, +core::traits::Destruct> of core::serde::Serde::> { + fn serialize(self: @GenericStruct, ref output: core::array::Array) { + core::serde::Serde::serialize(self.t, ref output) + } + fn deserialize(ref serialized: core::array::Span) -> core::option::Option> { + core::option::Option::Some(GenericStruct { + t: core::serde::Serde::deserialize(ref serialized)?, + }) + } +} + +impl GenericStructIntrospect> of dojo::model::introspect::Introspect> { + #[inline(always)] + fn size() -> Option { + dojo::model::introspect::Introspect::::size() + } + + fn layout() -> dojo::model::Layout { + dojo::model::Layout::Struct( + array![ + dojo::model::FieldLayout { + selector: 1246920879054256875300693562709339669009726288543267794550465531256469553289, + layout: dojo::model::introspect::Introspect::::layout() + } + ].span() + ) + } + + #[inline(always)] + fn ty() -> dojo::model::introspect::Ty { + dojo::model::introspect::Ty::Struct( + dojo::model::introspect::Struct { + name: 'GenericStruct', + attrs: array![].span(), + children: array![ + dojo::model::introspect::Member { + name: 't', + attrs: array![].span(), + ty: dojo::model::introspect::Introspect::::ty() + } + + ].span() + } + ) + } +} +impl StructWithBadOptionCopy of core::traits::Copy::; +impl StructWithBadOptionDrop of core::traits::Drop::; +impl StructWithBadOptionSerde of core::serde::Serde:: { + fn serialize(self: @StructWithBadOption, ref output: core::array::Array) { + core::serde::Serde::serialize(self.x, ref output) + } + fn deserialize(ref serialized: core::array::Span) -> core::option::Option { + core::option::Option::Some(StructWithBadOption { + x: core::serde::Serde::deserialize(ref serialized)?, + }) + } +} + +impl StructWithBadOptionIntrospect<> of dojo::model::introspect::Introspect> { + #[inline(always)] + fn size() -> Option { + dojo::model::introspect::Introspect::>::size() + } + + fn layout() -> dojo::model::Layout { + dojo::model::Layout::Struct( + array![ + dojo::model::FieldLayout { + selector: 512066735765477566404754172672287371265995314501343422459174036873487219331, + layout: dojo::model::introspect::Introspect:: +>::layout() + } + ].span() + ) + } + + #[inline(always)] + fn ty() -> dojo::model::introspect::Ty { + dojo::model::introspect::Ty::Struct( + dojo::model::introspect::Struct { + name: 'StructWithBadOption', + attrs: array![].span(), + children: array![ + dojo::model::introspect::Member { + name: 'x', + attrs: array![].span(), + ty: dojo::model::introspect::Introspect::>::ty() + } + + ].span() + } + ) + } +} +impl EnumWithBadOptionCopy of core::traits::Copy::; +impl EnumWithBadOptionDrop of core::traits::Drop::; +impl EnumWithBadOptionSerde of core::serde::Serde:: { + fn serialize(self: @EnumWithBadOption, ref output: core::array::Array) { + match self { + EnumWithBadOption::first(x) => { core::serde::Serde::serialize(@0, ref output); core::serde::Serde::serialize(x, ref output); }, + } + } + fn deserialize(ref serialized: core::array::Span) -> core::option::Option { + let idx: felt252 = core::serde::Serde::deserialize(ref serialized)?; + core::option::Option::Some( + match idx { + 0 => EnumWithBadOption::first(core::serde::Serde::deserialize(ref serialized)?), + _ => { return core::option::Option::None; } + } + ) + } +} + +impl EnumWithBadOptionIntrospect<> of dojo::model::introspect::Introspect> { + #[inline(always)] + fn size() -> Option { + let sizes : Array> = array![ + dojo::model::introspect::Introspect::>::size(), +Option::Some(1) + ]; + + if dojo::utils::any_none(@sizes) { + return Option::None; + } + Option::Some(dojo::utils::sum(sizes)) + + } + + fn layout() -> dojo::model::Layout { + dojo::model::Layout::Enum( + array![ + dojo::model::FieldLayout { + selector: 0, + layout: dojo::model::introspect::Introspect::>::layout() + } + ].span() + ) + } + + #[inline(always)] + fn ty() -> dojo::model::introspect::Ty { + dojo::model::introspect::Ty::Enum( + dojo::model::introspect::Enum { + name: 'EnumWithBadOption', + attrs: array![].span(), + children: array![ + ('first', dojo::model::introspect::Introspect::>::ty()) + + ].span() + } + ) + } +} + +impl EnumIncompatibleAttrsIntrospect<> of dojo::model::introspect::Introspect> { + #[inline(always)] + fn size() -> Option { + Option::None + } + + fn layout() -> dojo::model::Layout { + dojo::model::Layout::Enum( + array![ + + ].span() + ) + } + + #[inline(always)] + fn ty() -> dojo::model::introspect::Ty { + dojo::model::introspect::Ty::Enum( + dojo::model::introspect::Enum { + name: 'EnumIncompatibleAttrs', + attrs: array![].span(), + children: array![ + + + ].span() + } + ) + } +} + +impl EnumIncompatibleAttrsIntrospect<> of dojo::model::introspect::Introspect> { + #[inline(always)] + fn size() -> Option { + Option::None + } + + fn layout() -> dojo::model::Layout { + dojo::model::Layout::Fixed( + array![ + 8 + ].span() + ) + } + + #[inline(always)] + fn ty() -> dojo::model::introspect::Ty { + dojo::model::introspect::Ty::Enum( + dojo::model::introspect::Enum { + name: 'EnumIncompatibleAttrs', + attrs: array![].span(), + children: array![ + + + ].span() + } + ) + } +} + +impl StructIncompatibleAttrsIntrospect<> of dojo::model::introspect::Introspect> { + #[inline(always)] + fn size() -> Option { + Option::None + } + + fn layout() -> dojo::model::Layout { + dojo::model::Layout::Struct( + array![ + + ].span() + ) + } + + #[inline(always)] + fn ty() -> dojo::model::introspect::Ty { + dojo::model::introspect::Ty::Struct( + dojo::model::introspect::Struct { + name: 'StructIncompatibleAttrs', + attrs: array![].span(), + children: array![ + + + ].span() + } + ) + } +} + +impl StructIncompatibleAttrsIntrospect<> of dojo::model::introspect::Introspect> { + #[inline(always)] + fn size() -> Option { + Option::None + } + + fn layout() -> dojo::model::Layout { + dojo::model::Layout::Fixed( + array![ + + ].span() + ) + } + + #[inline(always)] + fn ty() -> dojo::model::introspect::Ty { + dojo::model::introspect::Ty::Struct( + dojo::model::introspect::Struct { + name: 'StructIncompatibleAttrs', + attrs: array![].span(), + children: array![ + + + ].span() + } + ) + } +} + +impl StructIncompatibleAttrs2Introspect<> of dojo::model::introspect::Introspect> { + #[inline(always)] + fn size() -> Option { + Option::None + } + + fn layout() -> dojo::model::Layout { + dojo::model::Layout::Struct( + array![ + + ].span() + ) + } + + #[inline(always)] + fn ty() -> dojo::model::introspect::Ty { + dojo::model::introspect::Ty::Struct( + dojo::model::introspect::Struct { + name: 'StructIncompatibleAttrs2', + attrs: array![].span(), + children: array![ + + + ].span() + } + ) + } +} + +impl StructIncompatibleAttrs2Introspect<> of dojo::model::introspect::Introspect> { + #[inline(always)] + fn size() -> Option { + Option::None + } + + fn layout() -> dojo::model::Layout { + dojo::model::Layout::Fixed( + array![ + + ].span() + ) + } + + #[inline(always)] + fn ty() -> dojo::model::introspect::Ty { + dojo::model::introspect::Ty::Struct( + dojo::model::introspect::Struct { + name: 'StructIncompatibleAttrs2', + attrs: array![].span(), + children: array![ + + + ].span() + } + ) + } +} + +impl EnumIncompatibleAttrs2Introspect<> of dojo::model::introspect::Introspect> { + #[inline(always)] + fn size() -> Option { + Option::None + } + + fn layout() -> dojo::model::Layout { + dojo::model::Layout::Enum( + array![ + + ].span() + ) + } + + #[inline(always)] + fn ty() -> dojo::model::introspect::Ty { + dojo::model::introspect::Ty::Enum( + dojo::model::introspect::Enum { + name: 'EnumIncompatibleAttrs2', + attrs: array![].span(), + children: array![ + + + ].span() + } + ) + } +} + +impl EnumIncompatibleAttrs2Introspect<> of dojo::model::introspect::Introspect> { + #[inline(always)] + fn size() -> Option { + Option::None + } + + fn layout() -> dojo::model::Layout { + dojo::model::Layout::Fixed( + array![ + 8 + ].span() + ) + } + + #[inline(always)] + fn ty() -> dojo::model::introspect::Ty { + dojo::model::introspect::Ty::Enum( + dojo::model::introspect::Enum { + name: 'EnumIncompatibleAttrs2', + attrs: array![].span(), + children: array![ + + + ].span() + } + ) + } +} + +impl StructPacked1Introspect<> of dojo::model::introspect::Introspect> { + #[inline(always)] + fn size() -> Option { + Option::Some(1) + } + + fn layout() -> dojo::model::Layout { + dojo::model::Layout::Fixed( + array![ + 8 + ].span() + ) + } + + #[inline(always)] + fn ty() -> dojo::model::introspect::Ty { + dojo::model::introspect::Ty::Struct( + dojo::model::introspect::Struct { + name: 'StructPacked1', + attrs: array![].span(), + children: array![ + dojo::model::introspect::Member { + name: 'x', + attrs: array![].span(), + ty: dojo::model::introspect::Introspect::::ty() + } + + ].span() + } + ) + } +} + +impl StructPacked2Introspect<> of dojo::model::introspect::Introspect> { + #[inline(always)] + fn size() -> Option { + Option::Some(3) + } + + fn layout() -> dojo::model::Layout { + dojo::model::Layout::Fixed( + array![ + 8,128,128 + ].span() + ) + } + + #[inline(always)] + fn ty() -> dojo::model::introspect::Ty { + dojo::model::introspect::Ty::Struct( + dojo::model::introspect::Struct { + name: 'StructPacked2', + attrs: array![].span(), + children: array![ + dojo::model::introspect::Member { + name: 'x', + attrs: array![].span(), + ty: dojo::model::introspect::Introspect::::ty() + }, +dojo::model::introspect::Member { + name: 'y', + attrs: array![].span(), + ty: dojo::model::introspect::Introspect::::ty() + } + + ].span() + } + ) + } +} + +impl StructPacked3Introspect<> of dojo::model::introspect::Introspect> { + #[inline(always)] + fn size() -> Option { + Option::Some(4) + } + + fn layout() -> dojo::model::Layout { + dojo::model::Layout::Fixed( + array![ + 128,128,8,32 + ].span() + ) + } + + #[inline(always)] + fn ty() -> dojo::model::introspect::Ty { + dojo::model::introspect::Ty::Struct( + dojo::model::introspect::Struct { + name: 'StructPacked3', + attrs: array![].span(), + children: array![ + dojo::model::introspect::Member { + name: 'x', + attrs: array![].span(), + ty: dojo::model::introspect::Introspect::::ty() + }, +dojo::model::introspect::Member { + name: 'y', + attrs: array![].span(), + ty: dojo::model::introspect::Ty::Tuple( + array![ + dojo::model::introspect::Introspect::::ty(), +dojo::model::introspect::Introspect::::ty() + ].span() + ) + } + + ].span() + } + ) + } +} + +impl StructNotPackable1Introspect<> of dojo::model::introspect::Introspect> { + #[inline(always)] + fn size() -> Option { + Option::None + } + + fn layout() -> dojo::model::Layout { + dojo::model::Layout::Fixed( + array![ + 8,ERROR + ].span() + ) + } + + #[inline(always)] + fn ty() -> dojo::model::introspect::Ty { + dojo::model::introspect::Ty::Struct( + dojo::model::introspect::Struct { + name: 'StructNotPackable1', + attrs: array![].span(), + children: array![ + dojo::model::introspect::Member { + name: 'x', + attrs: array![].span(), + ty: dojo::model::introspect::Introspect::::ty() + }, +dojo::model::introspect::Member { + name: 'y', + attrs: array![].span(), + ty: dojo::model::introspect::Ty::Array( + array![ + dojo::model::introspect::Introspect::::ty() + ].span() + ) + } + + ].span() + } + ) + } +} + +impl StructPackableWithInnerPackedIntrospect<> of dojo::model::introspect::Introspect> { + #[inline(always)] + fn size() -> Option { + let sizes : Array> = array![ + dojo::model::introspect::Introspect::::size(), +Option::Some(1) + ]; + + + Option::Some(dojo::utils::sum(sizes)) + + } + + fn layout() -> dojo::model::Layout { + let mut layouts = array![ + dojo::model::Layout::Fixed(array![8].span()), +dojo::model::introspect::Introspect::::layout() + ]; + let mut merged_layout = ArrayTrait::::new(); + + loop { + match ArrayTrait::pop_front(ref layouts) { + Option::Some(mut layout) => { + match layout { + dojo::model::Layout::Fixed(mut l) => { + loop { + match SpanTrait::pop_front(ref l) { + Option::Some(x) => merged_layout.append(*x), + Option::None(_) => { break; } + }; + }; + }, + _ => panic!("A packed model layout must contain Fixed layouts only."), + }; + }, + Option::None(_) => { break; } + }; + }; + + dojo::model::Layout::Fixed(merged_layout.span()) + + } + + #[inline(always)] + fn ty() -> dojo::model::introspect::Ty { + dojo::model::introspect::Ty::Struct( + dojo::model::introspect::Struct { + name: 'StructPackableWithInnerPacked', + attrs: array![].span(), + children: array![ + dojo::model::introspect::Member { + name: 'x', + attrs: array![].span(), + ty: dojo::model::introspect::Introspect::::ty() + }, +dojo::model::introspect::Member { + name: 'y', + attrs: array![].span(), + ty: dojo::model::introspect::Introspect::::ty() + } + + ].span() + } + ) + } +} + +impl EnumPacked1Introspect<> of dojo::model::introspect::Introspect> { + #[inline(always)] + fn size() -> Option { + Option::Some(1) + } + + fn layout() -> dojo::model::Layout { + dojo::model::Layout::Fixed( + array![ + 8 + ].span() + ) + } + + #[inline(always)] + fn ty() -> dojo::model::introspect::Ty { + dojo::model::introspect::Ty::Enum( + dojo::model::introspect::Enum { + name: 'EnumPacked1', + attrs: array![].span(), + children: array![ + ('a', dojo::model::introspect::Ty::Tuple(array![].span())), +('b', dojo::model::introspect::Ty::Tuple(array![].span())), +('c', dojo::model::introspect::Ty::Tuple(array![].span())) + + ].span() + } + ) + } +} + +impl EnumPacked2Introspect<> of dojo::model::introspect::Introspect> { + #[inline(always)] + fn size() -> Option { + Option::Some(2) + } + + fn layout() -> dojo::model::Layout { + dojo::model::Layout::Fixed( + array![ + 8,8 + ].span() + ) + } + + #[inline(always)] + fn ty() -> dojo::model::introspect::Ty { + dojo::model::introspect::Ty::Enum( + dojo::model::introspect::Enum { + name: 'EnumPacked2', + attrs: array![].span(), + children: array![ + ('a', dojo::model::introspect::Introspect::::ty()), +('b', dojo::model::introspect::Introspect::::ty()), +('c', dojo::model::introspect::Introspect::::ty()) + + ].span() + } + ) + } +} + +impl EnumPacked3Introspect<> of dojo::model::introspect::Introspect> { + #[inline(always)] + fn size() -> Option { + Option::Some(3) + } + + fn layout() -> dojo::model::Layout { + dojo::model::Layout::Fixed( + array![ + 8,128,128 + ].span() + ) + } + + #[inline(always)] + fn ty() -> dojo::model::introspect::Ty { + dojo::model::introspect::Ty::Enum( + dojo::model::introspect::Enum { + name: 'EnumPacked3', + attrs: array![].span(), + children: array![ + ('a', dojo::model::introspect::Ty::Tuple( + array![ + dojo::model::introspect::Introspect::::ty(), +dojo::model::introspect::Introspect::::ty() + ].span() + )), +('b', dojo::model::introspect::Introspect::::ty()) + + ].span() + } + ) + } +} + +impl EnumPackableWithInnerPackedIntrospect<> of dojo::model::introspect::Introspect> { + #[inline(always)] + fn size() -> Option { + let sizes : Array> = array![ + dojo::model::introspect::Introspect::::size(), +Option::Some(1) + ]; + + + Option::Some(dojo::utils::sum(sizes)) + + } + + fn layout() -> dojo::model::Layout { + let mut layouts = array![ + dojo::model::Layout::Fixed(array![8].span()), +dojo::model::introspect::Introspect::::layout() + ]; + let mut merged_layout = ArrayTrait::::new(); + + loop { + match ArrayTrait::pop_front(ref layouts) { + Option::Some(mut layout) => { + match layout { + dojo::model::Layout::Fixed(mut l) => { + loop { + match SpanTrait::pop_front(ref l) { + Option::Some(x) => merged_layout.append(*x), + Option::None(_) => { break; } + }; + }; + }, + _ => panic!("A packed model layout must contain Fixed layouts only."), + }; + }, + Option::None(_) => { break; } + }; + }; + + dojo::model::Layout::Fixed(merged_layout.span()) + + } + + #[inline(always)] + fn ty() -> dojo::model::introspect::Ty { + dojo::model::introspect::Ty::Enum( + dojo::model::introspect::Enum { + name: 'EnumPackableWithInnerPacked', + attrs: array![].span(), + children: array![ + ('a', dojo::model::introspect::Introspect::::ty()), +('b', dojo::model::introspect::Introspect::::ty()) + + ].span() + } + ) + } +} + +impl EnumNotPackable1Introspect<> of dojo::model::introspect::Introspect> { + #[inline(always)] + fn size() -> Option { + Option::None + } + + fn layout() -> dojo::model::Layout { + ERROR + } + + #[inline(always)] + fn ty() -> dojo::model::introspect::Ty { + dojo::model::introspect::Ty::Enum( + dojo::model::introspect::Enum { + name: 'EnumNotPackable1', + attrs: array![].span(), + children: array![ + ('a', dojo::model::introspect::Introspect::::ty()), +('b', dojo::model::introspect::Introspect::::ty()) + + ].span() + } + ) + } +} + +//! > expected_diagnostics +error: Option cannot be used with tuples. Prefer using a struct. + --> /tmp/plugin_test/introspect/src/lib.cairo:171:6 + x: Option<(u8, u16)> + ^*****************^ + +error: Option cannot be used with tuples. Prefer using a struct. + --> /tmp/plugin_test/introspect/src/lib.cairo:176:10 + first: Option<(u8, u16)>, + ^*****************^ + +error: Introspect and IntrospectPacked attributes cannot be used at a same time. + --> /tmp/plugin_test/introspect/src/lib.cairo:180:6 +enum EnumIncompatibleAttrs {} + ^*******************^ + +error: Introspect and IntrospectPacked attributes cannot be used at a same time. + --> /tmp/plugin_test/introspect/src/lib.cairo:183:8 +struct StructIncompatibleAttrs {} + ^*********************^ + +error: Introspect and IntrospectPacked attributes cannot be used at a same time. + --> /tmp/plugin_test/introspect/src/lib.cairo:187:8 +struct StructIncompatibleAttrs2 {} + ^**********************^ + +error: Introspect and IntrospectPacked attributes cannot be used at a same time. + --> /tmp/plugin_test/introspect/src/lib.cairo:191:6 +enum EnumIncompatibleAttrs2 {} + ^********************^ + +error: Array field cannot be packed. + --> /tmp/plugin_test/introspect/src/lib.cairo:213:6 + y: Array + ^**********^ + +error: To be packed, all variants must have fixed layout of same size. + --> /tmp/plugin_test/introspect/src/lib.cairo:250:6 +enum EnumNotPackable1 { + ^**************^ diff --git a/crates/compiler/src/plugin_test_data/model b/crates/compiler/src/plugin_test_data/model new file mode 100644 index 0000000..9a704e2 --- /dev/null +++ b/crates/compiler/src/plugin_test_data/model @@ -0,0 +1,26713 @@ +//! > Test expansion of the dojo::model. + +//! > test_runner_name +test_expand_plugin + +//! > test_id +model + +//! > cairo_code +#[dojo::model(version: 0)] +#[dojo::model(version: 0)] +struct BadModelMultipleAttr { + #[key] + id: felt252, + v: Vec3, +} + +#[dojo::model(version: 0, version: 0)] +struct BadModelMultipleVersions { + #[key] + id: felt252, + v: Vec3, +} + +#[dojo::model(version: hello)] +struct BadModelBadVersionType { + #[key] + id: felt252, + v: Vec3, +} + +#[dojo::model(version)] +struct BadModelNoVersionValue { + #[key] + id: felt252, + v: Vec3, +} + +#[dojo::model(my_arg: 1)] +struct BadModelUnexpectedArgWithValue { + #[key] + id: felt252, + v: Vec3, +} + +#[dojo::model(my_arg)] +struct BadModelUnexpectedArg { + #[key] + id: felt252, + v: Vec3, +} + +#[dojo::model(version: 2)] +struct BadModelNotSupportedVersion { + #[key] + id: felt252, + v: Vec3, +} + +#[dojo::model(version: 0)] +struct Modelv0 { + #[key] + id: felt252, + v: Vec3, +} + +#[dojo::model(namespace: 'MyNamespace')] +struct ModelWithBadNamespaceFormat { + #[key] + id: felt252, + v: Vec3, +} + +#[dojo::model(namespace: 'my_namespace')] +struct ModelWithShortStringNamespace { + #[key] + id: felt252, + v: Vec3, +} + +#[dojo::model(namespace: "my_namespace")] +struct ModelWithStringNamespace { + #[key] + id: felt252, + v: Vec3, +} + +#[dojo::model] +struct Position { + #[key] + id: felt252, + v: Vec3, +} + +#[dojo::model] +struct Roles { + role_ids: Array +} + +#[dojo::model] +struct OnlyKeyModel { + #[key] + id: felt252 +} + +#[dojo::model] +struct U256KeyModel { + #[key] + id: u256 +} + +#[dojo::model] +struct Player { + #[key] + game: felt252, + #[key] + player: ContractAddress, + name: felt252, +} + +#[dojo::model] +type OtherPlayer = Player; + +#[dojo::model] +struct ModelWithSimpleArray { + #[key] + player: ContractAddress, + x: u16, + y: Array +} + +#[dojo::model] +struct ModelWithByteArray { + #[key] + player: ContractAddress, + x: u16, + y: ByteArray +} + +#[dojo::model] +struct ModelWithComplexArray { + #[key] + player: ContractAddress, + x: u16, + y: Array +} + +#[dojo::model] +struct ModelWithTuple { + #[key] + player: ContractAddress, + x: u16, + y: (u8, u16, u32) +} + +#[dojo::model] +struct ModelWithTupleNoPrimitives { + #[key] + player: ContractAddress, + x: u16, + y: (u8, Vec3, u32) +} + +//! > expanded_cairo_code +#[dojo::model(version: 0)] +#[dojo::model(version: 0)] +struct BadModelMultipleAttr { + #[key] + id: felt252, + v: Vec3, +} + +#[dojo::model(version: 0, version: 0)] +struct BadModelMultipleVersions { + #[key] + id: felt252, + v: Vec3, +} + +#[dojo::model(version: hello)] +struct BadModelBadVersionType { + #[key] + id: felt252, + v: Vec3, +} + +#[dojo::model(version)] +struct BadModelNoVersionValue { + #[key] + id: felt252, + v: Vec3, +} + +#[dojo::model(my_arg: 1)] +struct BadModelUnexpectedArgWithValue { + #[key] + id: felt252, + v: Vec3, +} + +#[dojo::model(my_arg)] +struct BadModelUnexpectedArg { + #[key] + id: felt252, + v: Vec3, +} + +#[dojo::model(version: 2)] +struct BadModelNotSupportedVersion { + #[key] + id: felt252, + v: Vec3, +} + +#[dojo::model(version: 0)] +struct Modelv0 { + #[key] + id: felt252, + v: Vec3, +} + +#[dojo::model(namespace: 'MyNamespace')] +struct ModelWithBadNamespaceFormat { + #[key] + id: felt252, + v: Vec3, +} + +#[dojo::model(namespace: 'my_namespace')] +struct ModelWithShortStringNamespace { + #[key] + id: felt252, + v: Vec3, +} + +#[dojo::model(namespace: "my_namespace")] +struct ModelWithStringNamespace { + #[key] + id: felt252, + v: Vec3, +} + +#[dojo::model] +struct Position { + #[key] + id: felt252, + v: Vec3, +} + +#[dojo::model] +struct Roles { + role_ids: Array +} + +#[dojo::model] +struct OnlyKeyModel { + #[key] + id: felt252 +} + +#[dojo::model] +struct U256KeyModel { + #[key] + id: u256 +} + +#[dojo::model] +struct Player { + #[key] + game: felt252, + #[key] + player: ContractAddress, + name: felt252, +} + +#[dojo::model] +type OtherPlayer = Player; + +#[dojo::model] +struct ModelWithSimpleArray { + #[key] + player: ContractAddress, + x: u16, + y: Array +} + +#[dojo::model] +struct ModelWithByteArray { + #[key] + player: ContractAddress, + x: u16, + y: ByteArray +} + +#[dojo::model] +struct ModelWithComplexArray { + #[key] + player: ContractAddress, + x: u16, + y: Array +} + +#[dojo::model] +struct ModelWithTuple { + #[key] + player: ContractAddress, + x: u16, + y: (u8, u16, u32) +} + +#[dojo::model] +struct ModelWithTupleNoPrimitives { + #[key] + player: ContractAddress, + x: u16, + y: (u8, Vec3, u32) +} +impl BadModelMultipleAttrIntrospect<> of dojo::model::introspect::Introspect> { + #[inline(always)] + fn size() -> Option { + dojo::model::introspect::Introspect::::size() + } + + fn layout() -> dojo::model::Layout { + dojo::model::Layout::Struct( + array![ + dojo::model::FieldLayout { + selector: 578691550836206188651404750433984985630363913126316857592149308417275000080, + layout: dojo::model::introspect::Introspect::::layout() + } + ].span() + ) + } + + #[inline(always)] + fn ty() -> dojo::model::introspect::Ty { + dojo::model::introspect::Ty::Struct( + dojo::model::introspect::Struct { + name: 'BadModelMultipleAttr', + attrs: array![].span(), + children: array![ + dojo::model::introspect::Member { + name: 'id', + attrs: array!['key'].span(), + ty: dojo::model::introspect::Introspect::::ty() + }, +dojo::model::introspect::Member { + name: 'v', + attrs: array![].span(), + ty: dojo::model::introspect::Introspect::::ty() + } + + ].span() + } + ) + } +} + +impl BadModelMultipleVersionsIntrospect<> of dojo::model::introspect::Introspect> { + #[inline(always)] + fn size() -> Option { + dojo::model::introspect::Introspect::::size() + } + + fn layout() -> dojo::model::Layout { + dojo::model::Layout::Struct( + array![ + dojo::model::FieldLayout { + selector: 578691550836206188651404750433984985630363913126316857592149308417275000080, + layout: dojo::model::introspect::Introspect::::layout() + } + ].span() + ) + } + + #[inline(always)] + fn ty() -> dojo::model::introspect::Ty { + dojo::model::introspect::Ty::Struct( + dojo::model::introspect::Struct { + name: 'BadModelMultipleVersions', + attrs: array![].span(), + children: array![ + dojo::model::introspect::Member { + name: 'id', + attrs: array!['key'].span(), + ty: dojo::model::introspect::Introspect::::ty() + }, +dojo::model::introspect::Member { + name: 'v', + attrs: array![].span(), + ty: dojo::model::introspect::Introspect::::ty() + } + + ].span() + } + ) + } +} + +#[derive(Drop, Serde)] +pub struct BadModelMultipleVersionsEntity { + __id: felt252, // private field + pub v: Vec3, + +} + +#[generate_trait] +pub impl BadModelMultipleVersionsEntityStoreImpl of BadModelMultipleVersionsEntityStore { + fn get(world: dojo::world::IWorldDispatcher, entity_id: felt252) -> BadModelMultipleVersionsEntity { + BadModelMultipleVersionsModelEntityImpl::get(world, entity_id) + } + + fn update(self: @BadModelMultipleVersionsEntity, world: dojo::world::IWorldDispatcher) { + dojo::model::ModelEntity::::update_entity(self, world); + } + + fn delete(self: @BadModelMultipleVersionsEntity, world: dojo::world::IWorldDispatcher) { + dojo::model::ModelEntity::::delete_entity(self, world); + } + + + fn get_v(world: dojo::world::IWorldDispatcher, entity_id: felt252) -> Vec3 { + let mut values = dojo::model::ModelEntity::::get_member( + world, + entity_id, + 578691550836206188651404750433984985630363913126316857592149308417275000080 + ); + let field_value = core::serde::Serde::::deserialize(ref values); + + if core::option::OptionTrait::::is_none(@field_value) { + panic!( + "Field `BadModelMultipleVersions::v`: deserialization failed." + ); + } + + core::option::OptionTrait::::unwrap(field_value) + } + + fn set_v(self: @BadModelMultipleVersionsEntity, world: dojo::world::IWorldDispatcher, value: Vec3) { + let mut serialized = core::array::ArrayTrait::new(); + core::serde::Serde::serialize(@value, ref serialized); + + self.set_member( + world, + 578691550836206188651404750433984985630363913126316857592149308417275000080, + serialized.span() + ); + } + +} + +#[generate_trait] +pub impl BadModelMultipleVersionsStoreImpl of BadModelMultipleVersionsStore { + fn entity_id_from_keys(id: felt252) -> felt252 { + let mut serialized = core::array::ArrayTrait::new(); + core::array::ArrayTrait::append(ref serialized, id); + + core::poseidon::poseidon_hash_span(serialized.span()) + } + + fn from_values(ref keys: Span, ref values: Span) -> BadModelMultipleVersions { + let mut serialized = core::array::ArrayTrait::new(); + serialized.append_span(keys); + serialized.append_span(values); + let mut serialized = core::array::ArrayTrait::span(@serialized); + + let entity = core::serde::Serde::::deserialize(ref serialized); + + if core::option::OptionTrait::::is_none(@entity) { + panic!( + "Model `BadModelMultipleVersions`: deserialization failed. Ensure the length of the keys tuple is matching the number of #[key] fields in the model struct." + ); + } + + core::option::OptionTrait::::unwrap(entity) + } + + fn get(world: dojo::world::IWorldDispatcher, id: felt252) -> BadModelMultipleVersions { + let mut serialized = core::array::ArrayTrait::new(); + core::array::ArrayTrait::append(ref serialized, id); + + + dojo::model::Model::::get(world, serialized.span()) + } + + fn set(self: @BadModelMultipleVersions, world: dojo::world::IWorldDispatcher) { + dojo::model::Model::::set_model(self, world); + } + + fn delete(self: @BadModelMultipleVersions, world: dojo::world::IWorldDispatcher) { + dojo::model::Model::::delete_model(self, world); + } + + + fn get_v(world: dojo::world::IWorldDispatcher, id: felt252) -> Vec3 { + let mut serialized = core::array::ArrayTrait::new(); + core::array::ArrayTrait::append(ref serialized, id); + + + let mut values = dojo::model::Model::::get_member( + world, + serialized.span(), + 578691550836206188651404750433984985630363913126316857592149308417275000080 + ); + + let field_value = core::serde::Serde::::deserialize(ref values); + + if core::option::OptionTrait::::is_none(@field_value) { + panic!( + "Field `BadModelMultipleVersions::v`: deserialization failed." + ); + } + + core::option::OptionTrait::::unwrap(field_value) + } + + fn set_v(self: @BadModelMultipleVersions, world: dojo::world::IWorldDispatcher, value: Vec3) { + let mut serialized = core::array::ArrayTrait::new(); + core::serde::Serde::serialize(@value, ref serialized); + + self.set_member( + world, + 578691550836206188651404750433984985630363913126316857592149308417275000080, + serialized.span() + ); + } + +} + +pub impl BadModelMultipleVersionsModelEntityImpl of dojo::model::ModelEntity { + fn id(self: @BadModelMultipleVersionsEntity) -> felt252 { + *self.__id + } + + fn values(self: @BadModelMultipleVersionsEntity) -> Span { + let mut serialized = core::array::ArrayTrait::new(); + core::serde::Serde::serialize(self.v, ref serialized); + + core::array::ArrayTrait::span(@serialized) + } + + fn from_values(entity_id: felt252, ref values: Span) -> BadModelMultipleVersionsEntity { + let mut serialized = array![entity_id]; + serialized.append_span(values); + let mut serialized = core::array::ArrayTrait::span(@serialized); + + let entity_values = core::serde::Serde::::deserialize(ref serialized); + if core::option::OptionTrait::::is_none(@entity_values) { + panic!( + "ModelEntity `BadModelMultipleVersionsEntity`: deserialization failed." + ); + } + core::option::OptionTrait::::unwrap(entity_values) + } + + fn get(world: dojo::world::IWorldDispatcher, entity_id: felt252) -> BadModelMultipleVersionsEntity { + let mut values = dojo::world::IWorldDispatcherTrait::entity( + world, + dojo::model::Model::::selector(), + dojo::model::ModelIndex::Id(entity_id), + dojo::model::Model::::layout() + ); + Self::from_values(entity_id, ref values) + } + + fn update_entity(self: @BadModelMultipleVersionsEntity, world: dojo::world::IWorldDispatcher) { + dojo::world::IWorldDispatcherTrait::set_entity( + world, + dojo::model::Model::::selector(), + dojo::model::ModelIndex::Id(self.id()), + self.values(), + dojo::model::Model::::layout() + ); + } + + fn delete_entity(self: @BadModelMultipleVersionsEntity, world: dojo::world::IWorldDispatcher) { + dojo::world::IWorldDispatcherTrait::delete_entity( + world, + dojo::model::Model::::selector(), + dojo::model::ModelIndex::Id(self.id()), + dojo::model::Model::::layout() + ); + } + + fn get_member( + world: dojo::world::IWorldDispatcher, + entity_id: felt252, + member_id: felt252, + ) -> Span { + match dojo::utils::find_model_field_layout(dojo::model::Model::::layout(), member_id) { + Option::Some(field_layout) => { + dojo::world::IWorldDispatcherTrait::entity( + world, + dojo::model::Model::::selector(), + dojo::model::ModelIndex::MemberId((entity_id, member_id)), + field_layout + ) + }, + Option::None => core::panic_with_felt252('bad member id') + } + } + + fn set_member( + self: @BadModelMultipleVersionsEntity, + world: dojo::world::IWorldDispatcher, + member_id: felt252, + values: Span, + ) { + match dojo::utils::find_model_field_layout(dojo::model::Model::::layout(), member_id) { + Option::Some(field_layout) => { + dojo::world::IWorldDispatcherTrait::set_entity( + world, + dojo::model::Model::::selector(), + dojo::model::ModelIndex::MemberId((self.id(), member_id)), + values, + field_layout + ) + }, + Option::None => core::panic_with_felt252('bad member id') + } + } +} + +pub impl BadModelMultipleVersionsModelImpl of dojo::model::Model { + fn get(world: dojo::world::IWorldDispatcher, keys: Span) -> BadModelMultipleVersions { + let mut values = dojo::world::IWorldDispatcherTrait::entity( + world, + Self::selector(), + dojo::model::ModelIndex::Keys(keys), + Self::layout() + ); + let mut _keys = keys; + + BadModelMultipleVersionsStore::from_values(ref _keys, ref values) + } + + fn set_model( + self: @BadModelMultipleVersions, + world: dojo::world::IWorldDispatcher + ) { + dojo::world::IWorldDispatcherTrait::set_entity( + world, + Self::selector(), + dojo::model::ModelIndex::Keys(Self::keys(self)), + Self::values(self), + Self::layout() + ); + } + + fn delete_model( + self: @BadModelMultipleVersions, + world: dojo::world::IWorldDispatcher + ) { + dojo::world::IWorldDispatcherTrait::delete_entity( + world, + Self::selector(), + dojo::model::ModelIndex::Keys(Self::keys(self)), + Self::layout() + ); + } + + fn get_member( + world: dojo::world::IWorldDispatcher, + keys: Span, + member_id: felt252 + ) -> Span { + match dojo::utils::find_model_field_layout(Self::layout(), member_id) { + Option::Some(field_layout) => { + let entity_id = dojo::utils::entity_id_from_keys(keys); + dojo::world::IWorldDispatcherTrait::entity( + world, + Self::selector(), + dojo::model::ModelIndex::MemberId((entity_id, member_id)), + field_layout + ) + }, + Option::None => core::panic_with_felt252('bad member id') + } + } + + fn set_member( + self: @BadModelMultipleVersions, + world: dojo::world::IWorldDispatcher, + member_id: felt252, + values: Span + ) { + match dojo::utils::find_model_field_layout(Self::layout(), member_id) { + Option::Some(field_layout) => { + dojo::world::IWorldDispatcherTrait::set_entity( + world, + Self::selector(), + dojo::model::ModelIndex::MemberId((self.entity_id(), member_id)), + values, + field_layout + ) + }, + Option::None => core::panic_with_felt252('bad member id') + } + } + + #[inline(always)] + fn name() -> ByteArray { + "BadModelMultipleVersions" + } + + #[inline(always)] + fn namespace() -> ByteArray { + "dojo_test" + } + + #[inline(always)] + fn tag() -> ByteArray { + "dojo_test-BadModelMultipleVersions" + } + + #[inline(always)] + fn version() -> u8 { + 0 + } + + #[inline(always)] + fn selector() -> felt252 { + "BadModelMultipleVersions" + } + + #[inline(always)] + fn instance_selector(self: @BadModelMultipleVersions) -> felt252 { + Self::selector() + } + + #[inline(always)] + fn name_hash() -> felt252 { + 3538888628466873673221842373412072042558277047191927145880480325050722136660 + } + + #[inline(always)] + fn namespace_hash() -> felt252 { + 1452123528942907587532668415362544424816022573043154497385993678618948064048 + } + + #[inline(always)] + fn entity_id(self: @BadModelMultipleVersions) -> felt252 { + core::poseidon::poseidon_hash_span(self.keys()) + } + + #[inline(always)] + fn keys(self: @BadModelMultipleVersions) -> Span { + let mut serialized = core::array::ArrayTrait::new(); + core::array::ArrayTrait::append(ref serialized, *self.id); + + core::array::ArrayTrait::span(@serialized) + } + + #[inline(always)] + fn values(self: @BadModelMultipleVersions) -> Span { + let mut serialized = core::array::ArrayTrait::new(); + core::serde::Serde::serialize(self.v, ref serialized); + + core::array::ArrayTrait::span(@serialized) + } + + #[inline(always)] + fn layout() -> dojo::model::Layout { + dojo::model::introspect::Introspect::::layout() + } + + #[inline(always)] + fn instance_layout(self: @BadModelMultipleVersions) -> dojo::model::Layout { + Self::layout() + } + + #[inline(always)] + fn packed_size() -> Option { + dojo::model::layout::compute_packed_size(Self::layout()) + } +} + +#[starknet::interface] +pub trait Ibad_model_multiple_versions { + fn ensure_abi(self: @T, model: BadModelMultipleVersions); +} + +#[starknet::contract] +pub mod bad_model_multiple_versions { + use super::BadModelMultipleVersions; + use super::Ibad_model_multiple_versions; + + #[abi(embed_v0)] + impl DojoModelImpl of dojo::model::IModel{ + fn name(self: @ContractState) -> ByteArray { + "BadModelMultipleVersions" + } + + fn namespace(self: @ContractState) -> ByteArray { + "dojo_test" + } + + fn tag(self: @ContractState) -> ByteArray { + "dojo_test-BadModelMultipleVersions" + } + + fn version(self: @ContractState) -> u8 { + 0 + } + + fn selector(self: @ContractState) -> felt252 { + "BadModelMultipleVersions" + } + + fn name_hash(self: @ContractState) -> felt252 { + 3538888628466873673221842373412072042558277047191927145880480325050722136660 + } + + fn namespace_hash(self: @ContractState) -> felt252 { + 1452123528942907587532668415362544424816022573043154497385993678618948064048 + } + + fn unpacked_size(self: @ContractState) -> Option { + dojo::model::introspect::Introspect::::size() + } + + fn packed_size(self: @ContractState) -> Option { + dojo::model::Model::::packed_size() + } + + fn layout(self: @ContractState) -> dojo::model::Layout { + dojo::model::Model::::layout() + } + + fn schema(self: @ContractState) -> dojo::model::introspect::Ty { + dojo::model::introspect::Introspect::::ty() + } + } + + #[abi(embed_v0)] + impl bad_model_multiple_versionsImpl of Ibad_model_multiple_versions{ + fn ensure_abi(self: @ContractState, model: BadModelMultipleVersions) { + } + } +#[event] +#[derive(Drop, starknet::Event)] +pub enum Event {} + + +#[phantom] +pub struct Storage { +} + +#[derive(Drop, Copy)] +pub struct StorageStorageBase { +} +impl StorageStorageImpl of starknet::storage::StorageTrait { + type BaseType = StorageStorageBase; + fn storage(self: starknet::storage::FlattenedStorage) -> StorageStorageBase { + StorageStorageBase { + } + } +} +#[derive(Drop, Copy)] +pub struct StorageStorageBaseMut { +} +impl StorageStorageMutImpl of starknet::storage::StorageTraitMut { + type BaseType = StorageStorageBaseMut; + fn storage_mut(self: starknet::storage::FlattenedStorage>) -> StorageStorageBaseMut { + StorageStorageBaseMut { + } + } +} + +pub struct ContractState { +} + +impl ContractStateDrop of Drop {} + +impl ContractStateDeref of core::ops::SnapshotDeref { + type Target = starknet::storage::FlattenedStorage; + fn snapshot_deref(self: @ContractState) -> starknet::storage::FlattenedStorage { + starknet::storage::FlattenedStorage {} + } +} +impl ContractStateDerefMut of core::ops::DerefMut { + type Target = starknet::storage::FlattenedStorage> ; + fn deref_mut(ref self: ContractState) -> starknet::storage::FlattenedStorage> { + starknet::storage::FlattenedStorage {} + } +} +pub fn unsafe_new_contract_state() -> ContractState { + ContractState { + } +} + +// TODO(Gil): This generates duplicate diagnostics because of the plugin system, squash the duplicates into one. +#[deprecated( + feature: "deprecated_legacy_map", + note: "Use `starknet::storage::Map` instead." +)] +use starknet::storage::Map as LegacyMap; + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__DojoModelImpl__name(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = DojoModelImpl::name(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__DojoModelImpl__namespace(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = DojoModelImpl::namespace(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__DojoModelImpl__tag(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = DojoModelImpl::tag(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__DojoModelImpl__version(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = DojoModelImpl::version(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__DojoModelImpl__selector(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = DojoModelImpl::selector(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__DojoModelImpl__name_hash(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = DojoModelImpl::name_hash(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__DojoModelImpl__namespace_hash(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = DojoModelImpl::namespace_hash(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__DojoModelImpl__unpacked_size(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = DojoModelImpl::unpacked_size(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::>::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__DojoModelImpl__packed_size(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = DojoModelImpl::packed_size(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::>::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__DojoModelImpl__layout(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = DojoModelImpl::layout(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__DojoModelImpl__schema(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = DojoModelImpl::schema(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__bad_model_multiple_versionsImpl__ensure_abi(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + let __arg_model = core::option::OptionTraitImpl::expect( + core::serde::Serde::::deserialize(ref data), + 'Failed to deserialize param #1' + ); + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + bad_model_multiple_versionsImpl::ensure_abi(@contract_state, __arg_model); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::array::ArrayTrait::span(@arr) +} + + +pub mod __external { + pub use super::__wrapper__DojoModelImpl__name as name; + pub use super::__wrapper__DojoModelImpl__namespace as namespace; + pub use super::__wrapper__DojoModelImpl__tag as tag; + pub use super::__wrapper__DojoModelImpl__version as version; + pub use super::__wrapper__DojoModelImpl__selector as selector; + pub use super::__wrapper__DojoModelImpl__name_hash as name_hash; + pub use super::__wrapper__DojoModelImpl__namespace_hash as namespace_hash; + pub use super::__wrapper__DojoModelImpl__unpacked_size as unpacked_size; + pub use super::__wrapper__DojoModelImpl__packed_size as packed_size; + pub use super::__wrapper__DojoModelImpl__layout as layout; + pub use super::__wrapper__DojoModelImpl__schema as schema; + pub use super::__wrapper__bad_model_multiple_versionsImpl__ensure_abi as ensure_abi; +} +pub mod __l1_handler { +} +pub mod __constructor { +} + impl ContractStateEventEmitter of starknet::event::EventEmitter< + ContractState, Event + > { + fn emit>( + ref self: ContractState, event: S + ) { + let event: Event = core::traits::Into::into(event); + let mut keys = Default::::default(); + let mut data = Default::::default(); + starknet::Event::append_keys_and_data(@event, ref keys, ref data); + starknet::SyscallResultTrait::unwrap_syscall( + starknet::syscalls::emit_event_syscall( + core::array::ArrayTrait::span(@keys), + core::array::ArrayTrait::span(@data), + ) + ) + } + } +impl EventDrop of core::traits::Drop::; +impl EventIsEvent of starknet::Event { + fn append_keys_and_data( + self: @Event, ref keys: Array, ref data: Array + ) { + match self { + } + } + fn deserialize( + ref keys: Span, ref data: Span, + ) -> Option { + let __selector__ = *core::array::SpanTrait::pop_front(ref keys)?; + Option::None + } +} +impl StorageStorageBaseDrop of core::traits::Drop::; +impl StorageStorageBaseCopy of core::traits::Copy::; +impl StorageStorageBaseMutDrop of core::traits::Drop::; +impl StorageStorageBaseMutCopy of core::traits::Copy::; +} + +impl BadModelBadVersionTypeIntrospect<> of dojo::model::introspect::Introspect> { + #[inline(always)] + fn size() -> Option { + dojo::model::introspect::Introspect::::size() + } + + fn layout() -> dojo::model::Layout { + dojo::model::Layout::Struct( + array![ + dojo::model::FieldLayout { + selector: 578691550836206188651404750433984985630363913126316857592149308417275000080, + layout: dojo::model::introspect::Introspect::::layout() + } + ].span() + ) + } + + #[inline(always)] + fn ty() -> dojo::model::introspect::Ty { + dojo::model::introspect::Ty::Struct( + dojo::model::introspect::Struct { + name: 'BadModelBadVersionType', + attrs: array![].span(), + children: array![ + dojo::model::introspect::Member { + name: 'id', + attrs: array!['key'].span(), + ty: dojo::model::introspect::Introspect::::ty() + }, +dojo::model::introspect::Member { + name: 'v', + attrs: array![].span(), + ty: dojo::model::introspect::Introspect::::ty() + } + + ].span() + } + ) + } +} + +#[derive(Drop, Serde)] +pub struct BadModelBadVersionTypeEntity { + __id: felt252, // private field + pub v: Vec3, + +} + +#[generate_trait] +pub impl BadModelBadVersionTypeEntityStoreImpl of BadModelBadVersionTypeEntityStore { + fn get(world: dojo::world::IWorldDispatcher, entity_id: felt252) -> BadModelBadVersionTypeEntity { + BadModelBadVersionTypeModelEntityImpl::get(world, entity_id) + } + + fn update(self: @BadModelBadVersionTypeEntity, world: dojo::world::IWorldDispatcher) { + dojo::model::ModelEntity::::update_entity(self, world); + } + + fn delete(self: @BadModelBadVersionTypeEntity, world: dojo::world::IWorldDispatcher) { + dojo::model::ModelEntity::::delete_entity(self, world); + } + + + fn get_v(world: dojo::world::IWorldDispatcher, entity_id: felt252) -> Vec3 { + let mut values = dojo::model::ModelEntity::::get_member( + world, + entity_id, + 578691550836206188651404750433984985630363913126316857592149308417275000080 + ); + let field_value = core::serde::Serde::::deserialize(ref values); + + if core::option::OptionTrait::::is_none(@field_value) { + panic!( + "Field `BadModelBadVersionType::v`: deserialization failed." + ); + } + + core::option::OptionTrait::::unwrap(field_value) + } + + fn set_v(self: @BadModelBadVersionTypeEntity, world: dojo::world::IWorldDispatcher, value: Vec3) { + let mut serialized = core::array::ArrayTrait::new(); + core::serde::Serde::serialize(@value, ref serialized); + + self.set_member( + world, + 578691550836206188651404750433984985630363913126316857592149308417275000080, + serialized.span() + ); + } + +} + +#[generate_trait] +pub impl BadModelBadVersionTypeStoreImpl of BadModelBadVersionTypeStore { + fn entity_id_from_keys(id: felt252) -> felt252 { + let mut serialized = core::array::ArrayTrait::new(); + core::array::ArrayTrait::append(ref serialized, id); + + core::poseidon::poseidon_hash_span(serialized.span()) + } + + fn from_values(ref keys: Span, ref values: Span) -> BadModelBadVersionType { + let mut serialized = core::array::ArrayTrait::new(); + serialized.append_span(keys); + serialized.append_span(values); + let mut serialized = core::array::ArrayTrait::span(@serialized); + + let entity = core::serde::Serde::::deserialize(ref serialized); + + if core::option::OptionTrait::::is_none(@entity) { + panic!( + "Model `BadModelBadVersionType`: deserialization failed. Ensure the length of the keys tuple is matching the number of #[key] fields in the model struct." + ); + } + + core::option::OptionTrait::::unwrap(entity) + } + + fn get(world: dojo::world::IWorldDispatcher, id: felt252) -> BadModelBadVersionType { + let mut serialized = core::array::ArrayTrait::new(); + core::array::ArrayTrait::append(ref serialized, id); + + + dojo::model::Model::::get(world, serialized.span()) + } + + fn set(self: @BadModelBadVersionType, world: dojo::world::IWorldDispatcher) { + dojo::model::Model::::set_model(self, world); + } + + fn delete(self: @BadModelBadVersionType, world: dojo::world::IWorldDispatcher) { + dojo::model::Model::::delete_model(self, world); + } + + + fn get_v(world: dojo::world::IWorldDispatcher, id: felt252) -> Vec3 { + let mut serialized = core::array::ArrayTrait::new(); + core::array::ArrayTrait::append(ref serialized, id); + + + let mut values = dojo::model::Model::::get_member( + world, + serialized.span(), + 578691550836206188651404750433984985630363913126316857592149308417275000080 + ); + + let field_value = core::serde::Serde::::deserialize(ref values); + + if core::option::OptionTrait::::is_none(@field_value) { + panic!( + "Field `BadModelBadVersionType::v`: deserialization failed." + ); + } + + core::option::OptionTrait::::unwrap(field_value) + } + + fn set_v(self: @BadModelBadVersionType, world: dojo::world::IWorldDispatcher, value: Vec3) { + let mut serialized = core::array::ArrayTrait::new(); + core::serde::Serde::serialize(@value, ref serialized); + + self.set_member( + world, + 578691550836206188651404750433984985630363913126316857592149308417275000080, + serialized.span() + ); + } + +} + +pub impl BadModelBadVersionTypeModelEntityImpl of dojo::model::ModelEntity { + fn id(self: @BadModelBadVersionTypeEntity) -> felt252 { + *self.__id + } + + fn values(self: @BadModelBadVersionTypeEntity) -> Span { + let mut serialized = core::array::ArrayTrait::new(); + core::serde::Serde::serialize(self.v, ref serialized); + + core::array::ArrayTrait::span(@serialized) + } + + fn from_values(entity_id: felt252, ref values: Span) -> BadModelBadVersionTypeEntity { + let mut serialized = array![entity_id]; + serialized.append_span(values); + let mut serialized = core::array::ArrayTrait::span(@serialized); + + let entity_values = core::serde::Serde::::deserialize(ref serialized); + if core::option::OptionTrait::::is_none(@entity_values) { + panic!( + "ModelEntity `BadModelBadVersionTypeEntity`: deserialization failed." + ); + } + core::option::OptionTrait::::unwrap(entity_values) + } + + fn get(world: dojo::world::IWorldDispatcher, entity_id: felt252) -> BadModelBadVersionTypeEntity { + let mut values = dojo::world::IWorldDispatcherTrait::entity( + world, + dojo::model::Model::::selector(), + dojo::model::ModelIndex::Id(entity_id), + dojo::model::Model::::layout() + ); + Self::from_values(entity_id, ref values) + } + + fn update_entity(self: @BadModelBadVersionTypeEntity, world: dojo::world::IWorldDispatcher) { + dojo::world::IWorldDispatcherTrait::set_entity( + world, + dojo::model::Model::::selector(), + dojo::model::ModelIndex::Id(self.id()), + self.values(), + dojo::model::Model::::layout() + ); + } + + fn delete_entity(self: @BadModelBadVersionTypeEntity, world: dojo::world::IWorldDispatcher) { + dojo::world::IWorldDispatcherTrait::delete_entity( + world, + dojo::model::Model::::selector(), + dojo::model::ModelIndex::Id(self.id()), + dojo::model::Model::::layout() + ); + } + + fn get_member( + world: dojo::world::IWorldDispatcher, + entity_id: felt252, + member_id: felt252, + ) -> Span { + match dojo::utils::find_model_field_layout(dojo::model::Model::::layout(), member_id) { + Option::Some(field_layout) => { + dojo::world::IWorldDispatcherTrait::entity( + world, + dojo::model::Model::::selector(), + dojo::model::ModelIndex::MemberId((entity_id, member_id)), + field_layout + ) + }, + Option::None => core::panic_with_felt252('bad member id') + } + } + + fn set_member( + self: @BadModelBadVersionTypeEntity, + world: dojo::world::IWorldDispatcher, + member_id: felt252, + values: Span, + ) { + match dojo::utils::find_model_field_layout(dojo::model::Model::::layout(), member_id) { + Option::Some(field_layout) => { + dojo::world::IWorldDispatcherTrait::set_entity( + world, + dojo::model::Model::::selector(), + dojo::model::ModelIndex::MemberId((self.id(), member_id)), + values, + field_layout + ) + }, + Option::None => core::panic_with_felt252('bad member id') + } + } +} + +pub impl BadModelBadVersionTypeModelImpl of dojo::model::Model { + fn get(world: dojo::world::IWorldDispatcher, keys: Span) -> BadModelBadVersionType { + let mut values = dojo::world::IWorldDispatcherTrait::entity( + world, + Self::selector(), + dojo::model::ModelIndex::Keys(keys), + Self::layout() + ); + let mut _keys = keys; + + BadModelBadVersionTypeStore::from_values(ref _keys, ref values) + } + + fn set_model( + self: @BadModelBadVersionType, + world: dojo::world::IWorldDispatcher + ) { + dojo::world::IWorldDispatcherTrait::set_entity( + world, + Self::selector(), + dojo::model::ModelIndex::Keys(Self::keys(self)), + Self::values(self), + Self::layout() + ); + } + + fn delete_model( + self: @BadModelBadVersionType, + world: dojo::world::IWorldDispatcher + ) { + dojo::world::IWorldDispatcherTrait::delete_entity( + world, + Self::selector(), + dojo::model::ModelIndex::Keys(Self::keys(self)), + Self::layout() + ); + } + + fn get_member( + world: dojo::world::IWorldDispatcher, + keys: Span, + member_id: felt252 + ) -> Span { + match dojo::utils::find_model_field_layout(Self::layout(), member_id) { + Option::Some(field_layout) => { + let entity_id = dojo::utils::entity_id_from_keys(keys); + dojo::world::IWorldDispatcherTrait::entity( + world, + Self::selector(), + dojo::model::ModelIndex::MemberId((entity_id, member_id)), + field_layout + ) + }, + Option::None => core::panic_with_felt252('bad member id') + } + } + + fn set_member( + self: @BadModelBadVersionType, + world: dojo::world::IWorldDispatcher, + member_id: felt252, + values: Span + ) { + match dojo::utils::find_model_field_layout(Self::layout(), member_id) { + Option::Some(field_layout) => { + dojo::world::IWorldDispatcherTrait::set_entity( + world, + Self::selector(), + dojo::model::ModelIndex::MemberId((self.entity_id(), member_id)), + values, + field_layout + ) + }, + Option::None => core::panic_with_felt252('bad member id') + } + } + + #[inline(always)] + fn name() -> ByteArray { + "BadModelBadVersionType" + } + + #[inline(always)] + fn namespace() -> ByteArray { + "dojo_test" + } + + #[inline(always)] + fn tag() -> ByteArray { + "dojo_test-BadModelBadVersionType" + } + + #[inline(always)] + fn version() -> u8 { + 1 + } + + #[inline(always)] + fn selector() -> felt252 { + 1905541678078795270787966976324692071183638743428320623241420232497892529006 + } + + #[inline(always)] + fn instance_selector(self: @BadModelBadVersionType) -> felt252 { + Self::selector() + } + + #[inline(always)] + fn name_hash() -> felt252 { + 760683829940564015458541272487101565210915690045377810379189532484191344547 + } + + #[inline(always)] + fn namespace_hash() -> felt252 { + 1452123528942907587532668415362544424816022573043154497385993678618948064048 + } + + #[inline(always)] + fn entity_id(self: @BadModelBadVersionType) -> felt252 { + core::poseidon::poseidon_hash_span(self.keys()) + } + + #[inline(always)] + fn keys(self: @BadModelBadVersionType) -> Span { + let mut serialized = core::array::ArrayTrait::new(); + core::array::ArrayTrait::append(ref serialized, *self.id); + + core::array::ArrayTrait::span(@serialized) + } + + #[inline(always)] + fn values(self: @BadModelBadVersionType) -> Span { + let mut serialized = core::array::ArrayTrait::new(); + core::serde::Serde::serialize(self.v, ref serialized); + + core::array::ArrayTrait::span(@serialized) + } + + #[inline(always)] + fn layout() -> dojo::model::Layout { + dojo::model::introspect::Introspect::::layout() + } + + #[inline(always)] + fn instance_layout(self: @BadModelBadVersionType) -> dojo::model::Layout { + Self::layout() + } + + #[inline(always)] + fn packed_size() -> Option { + dojo::model::layout::compute_packed_size(Self::layout()) + } +} + +#[starknet::interface] +pub trait Ibad_model_bad_version_type { + fn ensure_abi(self: @T, model: BadModelBadVersionType); +} + +#[starknet::contract] +pub mod bad_model_bad_version_type { + use super::BadModelBadVersionType; + use super::Ibad_model_bad_version_type; + + #[abi(embed_v0)] + impl DojoModelImpl of dojo::model::IModel{ + fn name(self: @ContractState) -> ByteArray { + "BadModelBadVersionType" + } + + fn namespace(self: @ContractState) -> ByteArray { + "dojo_test" + } + + fn tag(self: @ContractState) -> ByteArray { + "dojo_test-BadModelBadVersionType" + } + + fn version(self: @ContractState) -> u8 { + 1 + } + + fn selector(self: @ContractState) -> felt252 { + 1905541678078795270787966976324692071183638743428320623241420232497892529006 + } + + fn name_hash(self: @ContractState) -> felt252 { + 760683829940564015458541272487101565210915690045377810379189532484191344547 + } + + fn namespace_hash(self: @ContractState) -> felt252 { + 1452123528942907587532668415362544424816022573043154497385993678618948064048 + } + + fn unpacked_size(self: @ContractState) -> Option { + dojo::model::introspect::Introspect::::size() + } + + fn packed_size(self: @ContractState) -> Option { + dojo::model::Model::::packed_size() + } + + fn layout(self: @ContractState) -> dojo::model::Layout { + dojo::model::Model::::layout() + } + + fn schema(self: @ContractState) -> dojo::model::introspect::Ty { + dojo::model::introspect::Introspect::::ty() + } + } + + #[abi(embed_v0)] + impl bad_model_bad_version_typeImpl of Ibad_model_bad_version_type{ + fn ensure_abi(self: @ContractState, model: BadModelBadVersionType) { + } + } +#[event] +#[derive(Drop, starknet::Event)] +pub enum Event {} + + +#[phantom] +pub struct Storage { +} + +#[derive(Drop, Copy)] +pub struct StorageStorageBase { +} +impl StorageStorageImpl of starknet::storage::StorageTrait { + type BaseType = StorageStorageBase; + fn storage(self: starknet::storage::FlattenedStorage) -> StorageStorageBase { + StorageStorageBase { + } + } +} +#[derive(Drop, Copy)] +pub struct StorageStorageBaseMut { +} +impl StorageStorageMutImpl of starknet::storage::StorageTraitMut { + type BaseType = StorageStorageBaseMut; + fn storage_mut(self: starknet::storage::FlattenedStorage>) -> StorageStorageBaseMut { + StorageStorageBaseMut { + } + } +} + +pub struct ContractState { +} + +impl ContractStateDrop of Drop {} + +impl ContractStateDeref of core::ops::SnapshotDeref { + type Target = starknet::storage::FlattenedStorage; + fn snapshot_deref(self: @ContractState) -> starknet::storage::FlattenedStorage { + starknet::storage::FlattenedStorage {} + } +} +impl ContractStateDerefMut of core::ops::DerefMut { + type Target = starknet::storage::FlattenedStorage> ; + fn deref_mut(ref self: ContractState) -> starknet::storage::FlattenedStorage> { + starknet::storage::FlattenedStorage {} + } +} +pub fn unsafe_new_contract_state() -> ContractState { + ContractState { + } +} + +// TODO(Gil): This generates duplicate diagnostics because of the plugin system, squash the duplicates into one. +#[deprecated( + feature: "deprecated_legacy_map", + note: "Use `starknet::storage::Map` instead." +)] +use starknet::storage::Map as LegacyMap; + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__DojoModelImpl__name(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = DojoModelImpl::name(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__DojoModelImpl__namespace(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = DojoModelImpl::namespace(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__DojoModelImpl__tag(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = DojoModelImpl::tag(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__DojoModelImpl__version(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = DojoModelImpl::version(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__DojoModelImpl__selector(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = DojoModelImpl::selector(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__DojoModelImpl__name_hash(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = DojoModelImpl::name_hash(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__DojoModelImpl__namespace_hash(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = DojoModelImpl::namespace_hash(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__DojoModelImpl__unpacked_size(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = DojoModelImpl::unpacked_size(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::>::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__DojoModelImpl__packed_size(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = DojoModelImpl::packed_size(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::>::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__DojoModelImpl__layout(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = DojoModelImpl::layout(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__DojoModelImpl__schema(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = DojoModelImpl::schema(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__bad_model_bad_version_typeImpl__ensure_abi(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + let __arg_model = core::option::OptionTraitImpl::expect( + core::serde::Serde::::deserialize(ref data), + 'Failed to deserialize param #1' + ); + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + bad_model_bad_version_typeImpl::ensure_abi(@contract_state, __arg_model); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::array::ArrayTrait::span(@arr) +} + + +pub mod __external { + pub use super::__wrapper__DojoModelImpl__name as name; + pub use super::__wrapper__DojoModelImpl__namespace as namespace; + pub use super::__wrapper__DojoModelImpl__tag as tag; + pub use super::__wrapper__DojoModelImpl__version as version; + pub use super::__wrapper__DojoModelImpl__selector as selector; + pub use super::__wrapper__DojoModelImpl__name_hash as name_hash; + pub use super::__wrapper__DojoModelImpl__namespace_hash as namespace_hash; + pub use super::__wrapper__DojoModelImpl__unpacked_size as unpacked_size; + pub use super::__wrapper__DojoModelImpl__packed_size as packed_size; + pub use super::__wrapper__DojoModelImpl__layout as layout; + pub use super::__wrapper__DojoModelImpl__schema as schema; + pub use super::__wrapper__bad_model_bad_version_typeImpl__ensure_abi as ensure_abi; +} +pub mod __l1_handler { +} +pub mod __constructor { +} + impl ContractStateEventEmitter of starknet::event::EventEmitter< + ContractState, Event + > { + fn emit>( + ref self: ContractState, event: S + ) { + let event: Event = core::traits::Into::into(event); + let mut keys = Default::::default(); + let mut data = Default::::default(); + starknet::Event::append_keys_and_data(@event, ref keys, ref data); + starknet::SyscallResultTrait::unwrap_syscall( + starknet::syscalls::emit_event_syscall( + core::array::ArrayTrait::span(@keys), + core::array::ArrayTrait::span(@data), + ) + ) + } + } +impl EventDrop of core::traits::Drop::; +impl EventIsEvent of starknet::Event { + fn append_keys_and_data( + self: @Event, ref keys: Array, ref data: Array + ) { + match self { + } + } + fn deserialize( + ref keys: Span, ref data: Span, + ) -> Option { + let __selector__ = *core::array::SpanTrait::pop_front(ref keys)?; + Option::None + } +} +impl StorageStorageBaseDrop of core::traits::Drop::; +impl StorageStorageBaseCopy of core::traits::Copy::; +impl StorageStorageBaseMutDrop of core::traits::Drop::; +impl StorageStorageBaseMutCopy of core::traits::Copy::; +} + +impl BadModelNoVersionValueIntrospect<> of dojo::model::introspect::Introspect> { + #[inline(always)] + fn size() -> Option { + dojo::model::introspect::Introspect::::size() + } + + fn layout() -> dojo::model::Layout { + dojo::model::Layout::Struct( + array![ + dojo::model::FieldLayout { + selector: 578691550836206188651404750433984985630363913126316857592149308417275000080, + layout: dojo::model::introspect::Introspect::::layout() + } + ].span() + ) + } + + #[inline(always)] + fn ty() -> dojo::model::introspect::Ty { + dojo::model::introspect::Ty::Struct( + dojo::model::introspect::Struct { + name: 'BadModelNoVersionValue', + attrs: array![].span(), + children: array![ + dojo::model::introspect::Member { + name: 'id', + attrs: array!['key'].span(), + ty: dojo::model::introspect::Introspect::::ty() + }, +dojo::model::introspect::Member { + name: 'v', + attrs: array![].span(), + ty: dojo::model::introspect::Introspect::::ty() + } + + ].span() + } + ) + } +} + +#[derive(Drop, Serde)] +pub struct BadModelNoVersionValueEntity { + __id: felt252, // private field + pub v: Vec3, + +} + +#[generate_trait] +pub impl BadModelNoVersionValueEntityStoreImpl of BadModelNoVersionValueEntityStore { + fn get(world: dojo::world::IWorldDispatcher, entity_id: felt252) -> BadModelNoVersionValueEntity { + BadModelNoVersionValueModelEntityImpl::get(world, entity_id) + } + + fn update(self: @BadModelNoVersionValueEntity, world: dojo::world::IWorldDispatcher) { + dojo::model::ModelEntity::::update_entity(self, world); + } + + fn delete(self: @BadModelNoVersionValueEntity, world: dojo::world::IWorldDispatcher) { + dojo::model::ModelEntity::::delete_entity(self, world); + } + + + fn get_v(world: dojo::world::IWorldDispatcher, entity_id: felt252) -> Vec3 { + let mut values = dojo::model::ModelEntity::::get_member( + world, + entity_id, + 578691550836206188651404750433984985630363913126316857592149308417275000080 + ); + let field_value = core::serde::Serde::::deserialize(ref values); + + if core::option::OptionTrait::::is_none(@field_value) { + panic!( + "Field `BadModelNoVersionValue::v`: deserialization failed." + ); + } + + core::option::OptionTrait::::unwrap(field_value) + } + + fn set_v(self: @BadModelNoVersionValueEntity, world: dojo::world::IWorldDispatcher, value: Vec3) { + let mut serialized = core::array::ArrayTrait::new(); + core::serde::Serde::serialize(@value, ref serialized); + + self.set_member( + world, + 578691550836206188651404750433984985630363913126316857592149308417275000080, + serialized.span() + ); + } + +} + +#[generate_trait] +pub impl BadModelNoVersionValueStoreImpl of BadModelNoVersionValueStore { + fn entity_id_from_keys(id: felt252) -> felt252 { + let mut serialized = core::array::ArrayTrait::new(); + core::array::ArrayTrait::append(ref serialized, id); + + core::poseidon::poseidon_hash_span(serialized.span()) + } + + fn from_values(ref keys: Span, ref values: Span) -> BadModelNoVersionValue { + let mut serialized = core::array::ArrayTrait::new(); + serialized.append_span(keys); + serialized.append_span(values); + let mut serialized = core::array::ArrayTrait::span(@serialized); + + let entity = core::serde::Serde::::deserialize(ref serialized); + + if core::option::OptionTrait::::is_none(@entity) { + panic!( + "Model `BadModelNoVersionValue`: deserialization failed. Ensure the length of the keys tuple is matching the number of #[key] fields in the model struct." + ); + } + + core::option::OptionTrait::::unwrap(entity) + } + + fn get(world: dojo::world::IWorldDispatcher, id: felt252) -> BadModelNoVersionValue { + let mut serialized = core::array::ArrayTrait::new(); + core::array::ArrayTrait::append(ref serialized, id); + + + dojo::model::Model::::get(world, serialized.span()) + } + + fn set(self: @BadModelNoVersionValue, world: dojo::world::IWorldDispatcher) { + dojo::model::Model::::set_model(self, world); + } + + fn delete(self: @BadModelNoVersionValue, world: dojo::world::IWorldDispatcher) { + dojo::model::Model::::delete_model(self, world); + } + + + fn get_v(world: dojo::world::IWorldDispatcher, id: felt252) -> Vec3 { + let mut serialized = core::array::ArrayTrait::new(); + core::array::ArrayTrait::append(ref serialized, id); + + + let mut values = dojo::model::Model::::get_member( + world, + serialized.span(), + 578691550836206188651404750433984985630363913126316857592149308417275000080 + ); + + let field_value = core::serde::Serde::::deserialize(ref values); + + if core::option::OptionTrait::::is_none(@field_value) { + panic!( + "Field `BadModelNoVersionValue::v`: deserialization failed." + ); + } + + core::option::OptionTrait::::unwrap(field_value) + } + + fn set_v(self: @BadModelNoVersionValue, world: dojo::world::IWorldDispatcher, value: Vec3) { + let mut serialized = core::array::ArrayTrait::new(); + core::serde::Serde::serialize(@value, ref serialized); + + self.set_member( + world, + 578691550836206188651404750433984985630363913126316857592149308417275000080, + serialized.span() + ); + } + +} + +pub impl BadModelNoVersionValueModelEntityImpl of dojo::model::ModelEntity { + fn id(self: @BadModelNoVersionValueEntity) -> felt252 { + *self.__id + } + + fn values(self: @BadModelNoVersionValueEntity) -> Span { + let mut serialized = core::array::ArrayTrait::new(); + core::serde::Serde::serialize(self.v, ref serialized); + + core::array::ArrayTrait::span(@serialized) + } + + fn from_values(entity_id: felt252, ref values: Span) -> BadModelNoVersionValueEntity { + let mut serialized = array![entity_id]; + serialized.append_span(values); + let mut serialized = core::array::ArrayTrait::span(@serialized); + + let entity_values = core::serde::Serde::::deserialize(ref serialized); + if core::option::OptionTrait::::is_none(@entity_values) { + panic!( + "ModelEntity `BadModelNoVersionValueEntity`: deserialization failed." + ); + } + core::option::OptionTrait::::unwrap(entity_values) + } + + fn get(world: dojo::world::IWorldDispatcher, entity_id: felt252) -> BadModelNoVersionValueEntity { + let mut values = dojo::world::IWorldDispatcherTrait::entity( + world, + dojo::model::Model::::selector(), + dojo::model::ModelIndex::Id(entity_id), + dojo::model::Model::::layout() + ); + Self::from_values(entity_id, ref values) + } + + fn update_entity(self: @BadModelNoVersionValueEntity, world: dojo::world::IWorldDispatcher) { + dojo::world::IWorldDispatcherTrait::set_entity( + world, + dojo::model::Model::::selector(), + dojo::model::ModelIndex::Id(self.id()), + self.values(), + dojo::model::Model::::layout() + ); + } + + fn delete_entity(self: @BadModelNoVersionValueEntity, world: dojo::world::IWorldDispatcher) { + dojo::world::IWorldDispatcherTrait::delete_entity( + world, + dojo::model::Model::::selector(), + dojo::model::ModelIndex::Id(self.id()), + dojo::model::Model::::layout() + ); + } + + fn get_member( + world: dojo::world::IWorldDispatcher, + entity_id: felt252, + member_id: felt252, + ) -> Span { + match dojo::utils::find_model_field_layout(dojo::model::Model::::layout(), member_id) { + Option::Some(field_layout) => { + dojo::world::IWorldDispatcherTrait::entity( + world, + dojo::model::Model::::selector(), + dojo::model::ModelIndex::MemberId((entity_id, member_id)), + field_layout + ) + }, + Option::None => core::panic_with_felt252('bad member id') + } + } + + fn set_member( + self: @BadModelNoVersionValueEntity, + world: dojo::world::IWorldDispatcher, + member_id: felt252, + values: Span, + ) { + match dojo::utils::find_model_field_layout(dojo::model::Model::::layout(), member_id) { + Option::Some(field_layout) => { + dojo::world::IWorldDispatcherTrait::set_entity( + world, + dojo::model::Model::::selector(), + dojo::model::ModelIndex::MemberId((self.id(), member_id)), + values, + field_layout + ) + }, + Option::None => core::panic_with_felt252('bad member id') + } + } +} + +pub impl BadModelNoVersionValueModelImpl of dojo::model::Model { + fn get(world: dojo::world::IWorldDispatcher, keys: Span) -> BadModelNoVersionValue { + let mut values = dojo::world::IWorldDispatcherTrait::entity( + world, + Self::selector(), + dojo::model::ModelIndex::Keys(keys), + Self::layout() + ); + let mut _keys = keys; + + BadModelNoVersionValueStore::from_values(ref _keys, ref values) + } + + fn set_model( + self: @BadModelNoVersionValue, + world: dojo::world::IWorldDispatcher + ) { + dojo::world::IWorldDispatcherTrait::set_entity( + world, + Self::selector(), + dojo::model::ModelIndex::Keys(Self::keys(self)), + Self::values(self), + Self::layout() + ); + } + + fn delete_model( + self: @BadModelNoVersionValue, + world: dojo::world::IWorldDispatcher + ) { + dojo::world::IWorldDispatcherTrait::delete_entity( + world, + Self::selector(), + dojo::model::ModelIndex::Keys(Self::keys(self)), + Self::layout() + ); + } + + fn get_member( + world: dojo::world::IWorldDispatcher, + keys: Span, + member_id: felt252 + ) -> Span { + match dojo::utils::find_model_field_layout(Self::layout(), member_id) { + Option::Some(field_layout) => { + let entity_id = dojo::utils::entity_id_from_keys(keys); + dojo::world::IWorldDispatcherTrait::entity( + world, + Self::selector(), + dojo::model::ModelIndex::MemberId((entity_id, member_id)), + field_layout + ) + }, + Option::None => core::panic_with_felt252('bad member id') + } + } + + fn set_member( + self: @BadModelNoVersionValue, + world: dojo::world::IWorldDispatcher, + member_id: felt252, + values: Span + ) { + match dojo::utils::find_model_field_layout(Self::layout(), member_id) { + Option::Some(field_layout) => { + dojo::world::IWorldDispatcherTrait::set_entity( + world, + Self::selector(), + dojo::model::ModelIndex::MemberId((self.entity_id(), member_id)), + values, + field_layout + ) + }, + Option::None => core::panic_with_felt252('bad member id') + } + } + + #[inline(always)] + fn name() -> ByteArray { + "BadModelNoVersionValue" + } + + #[inline(always)] + fn namespace() -> ByteArray { + "dojo_test" + } + + #[inline(always)] + fn tag() -> ByteArray { + "dojo_test-BadModelNoVersionValue" + } + + #[inline(always)] + fn version() -> u8 { + 1 + } + + #[inline(always)] + fn selector() -> felt252 { + 2174173236757861924887576251338889271361403293870377278593064770381730742730 + } + + #[inline(always)] + fn instance_selector(self: @BadModelNoVersionValue) -> felt252 { + Self::selector() + } + + #[inline(always)] + fn name_hash() -> felt252 { + 2459365230136118590954025890011480023818926626380754992635699340900694864996 + } + + #[inline(always)] + fn namespace_hash() -> felt252 { + 1452123528942907587532668415362544424816022573043154497385993678618948064048 + } + + #[inline(always)] + fn entity_id(self: @BadModelNoVersionValue) -> felt252 { + core::poseidon::poseidon_hash_span(self.keys()) + } + + #[inline(always)] + fn keys(self: @BadModelNoVersionValue) -> Span { + let mut serialized = core::array::ArrayTrait::new(); + core::array::ArrayTrait::append(ref serialized, *self.id); + + core::array::ArrayTrait::span(@serialized) + } + + #[inline(always)] + fn values(self: @BadModelNoVersionValue) -> Span { + let mut serialized = core::array::ArrayTrait::new(); + core::serde::Serde::serialize(self.v, ref serialized); + + core::array::ArrayTrait::span(@serialized) + } + + #[inline(always)] + fn layout() -> dojo::model::Layout { + dojo::model::introspect::Introspect::::layout() + } + + #[inline(always)] + fn instance_layout(self: @BadModelNoVersionValue) -> dojo::model::Layout { + Self::layout() + } + + #[inline(always)] + fn packed_size() -> Option { + dojo::model::layout::compute_packed_size(Self::layout()) + } +} + +#[starknet::interface] +pub trait Ibad_model_no_version_value { + fn ensure_abi(self: @T, model: BadModelNoVersionValue); +} + +#[starknet::contract] +pub mod bad_model_no_version_value { + use super::BadModelNoVersionValue; + use super::Ibad_model_no_version_value; + + #[abi(embed_v0)] + impl DojoModelImpl of dojo::model::IModel{ + fn name(self: @ContractState) -> ByteArray { + "BadModelNoVersionValue" + } + + fn namespace(self: @ContractState) -> ByteArray { + "dojo_test" + } + + fn tag(self: @ContractState) -> ByteArray { + "dojo_test-BadModelNoVersionValue" + } + + fn version(self: @ContractState) -> u8 { + 1 + } + + fn selector(self: @ContractState) -> felt252 { + 2174173236757861924887576251338889271361403293870377278593064770381730742730 + } + + fn name_hash(self: @ContractState) -> felt252 { + 2459365230136118590954025890011480023818926626380754992635699340900694864996 + } + + fn namespace_hash(self: @ContractState) -> felt252 { + 1452123528942907587532668415362544424816022573043154497385993678618948064048 + } + + fn unpacked_size(self: @ContractState) -> Option { + dojo::model::introspect::Introspect::::size() + } + + fn packed_size(self: @ContractState) -> Option { + dojo::model::Model::::packed_size() + } + + fn layout(self: @ContractState) -> dojo::model::Layout { + dojo::model::Model::::layout() + } + + fn schema(self: @ContractState) -> dojo::model::introspect::Ty { + dojo::model::introspect::Introspect::::ty() + } + } + + #[abi(embed_v0)] + impl bad_model_no_version_valueImpl of Ibad_model_no_version_value{ + fn ensure_abi(self: @ContractState, model: BadModelNoVersionValue) { + } + } +#[event] +#[derive(Drop, starknet::Event)] +pub enum Event {} + + +#[phantom] +pub struct Storage { +} + +#[derive(Drop, Copy)] +pub struct StorageStorageBase { +} +impl StorageStorageImpl of starknet::storage::StorageTrait { + type BaseType = StorageStorageBase; + fn storage(self: starknet::storage::FlattenedStorage) -> StorageStorageBase { + StorageStorageBase { + } + } +} +#[derive(Drop, Copy)] +pub struct StorageStorageBaseMut { +} +impl StorageStorageMutImpl of starknet::storage::StorageTraitMut { + type BaseType = StorageStorageBaseMut; + fn storage_mut(self: starknet::storage::FlattenedStorage>) -> StorageStorageBaseMut { + StorageStorageBaseMut { + } + } +} + +pub struct ContractState { +} + +impl ContractStateDrop of Drop {} + +impl ContractStateDeref of core::ops::SnapshotDeref { + type Target = starknet::storage::FlattenedStorage; + fn snapshot_deref(self: @ContractState) -> starknet::storage::FlattenedStorage { + starknet::storage::FlattenedStorage {} + } +} +impl ContractStateDerefMut of core::ops::DerefMut { + type Target = starknet::storage::FlattenedStorage> ; + fn deref_mut(ref self: ContractState) -> starknet::storage::FlattenedStorage> { + starknet::storage::FlattenedStorage {} + } +} +pub fn unsafe_new_contract_state() -> ContractState { + ContractState { + } +} + +// TODO(Gil): This generates duplicate diagnostics because of the plugin system, squash the duplicates into one. +#[deprecated( + feature: "deprecated_legacy_map", + note: "Use `starknet::storage::Map` instead." +)] +use starknet::storage::Map as LegacyMap; + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__DojoModelImpl__name(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = DojoModelImpl::name(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__DojoModelImpl__namespace(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = DojoModelImpl::namespace(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__DojoModelImpl__tag(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = DojoModelImpl::tag(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__DojoModelImpl__version(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = DojoModelImpl::version(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__DojoModelImpl__selector(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = DojoModelImpl::selector(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__DojoModelImpl__name_hash(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = DojoModelImpl::name_hash(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__DojoModelImpl__namespace_hash(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = DojoModelImpl::namespace_hash(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__DojoModelImpl__unpacked_size(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = DojoModelImpl::unpacked_size(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::>::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__DojoModelImpl__packed_size(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = DojoModelImpl::packed_size(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::>::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__DojoModelImpl__layout(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = DojoModelImpl::layout(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__DojoModelImpl__schema(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = DojoModelImpl::schema(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__bad_model_no_version_valueImpl__ensure_abi(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + let __arg_model = core::option::OptionTraitImpl::expect( + core::serde::Serde::::deserialize(ref data), + 'Failed to deserialize param #1' + ); + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + bad_model_no_version_valueImpl::ensure_abi(@contract_state, __arg_model); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::array::ArrayTrait::span(@arr) +} + + +pub mod __external { + pub use super::__wrapper__DojoModelImpl__name as name; + pub use super::__wrapper__DojoModelImpl__namespace as namespace; + pub use super::__wrapper__DojoModelImpl__tag as tag; + pub use super::__wrapper__DojoModelImpl__version as version; + pub use super::__wrapper__DojoModelImpl__selector as selector; + pub use super::__wrapper__DojoModelImpl__name_hash as name_hash; + pub use super::__wrapper__DojoModelImpl__namespace_hash as namespace_hash; + pub use super::__wrapper__DojoModelImpl__unpacked_size as unpacked_size; + pub use super::__wrapper__DojoModelImpl__packed_size as packed_size; + pub use super::__wrapper__DojoModelImpl__layout as layout; + pub use super::__wrapper__DojoModelImpl__schema as schema; + pub use super::__wrapper__bad_model_no_version_valueImpl__ensure_abi as ensure_abi; +} +pub mod __l1_handler { +} +pub mod __constructor { +} + impl ContractStateEventEmitter of starknet::event::EventEmitter< + ContractState, Event + > { + fn emit>( + ref self: ContractState, event: S + ) { + let event: Event = core::traits::Into::into(event); + let mut keys = Default::::default(); + let mut data = Default::::default(); + starknet::Event::append_keys_and_data(@event, ref keys, ref data); + starknet::SyscallResultTrait::unwrap_syscall( + starknet::syscalls::emit_event_syscall( + core::array::ArrayTrait::span(@keys), + core::array::ArrayTrait::span(@data), + ) + ) + } + } +impl EventDrop of core::traits::Drop::; +impl EventIsEvent of starknet::Event { + fn append_keys_and_data( + self: @Event, ref keys: Array, ref data: Array + ) { + match self { + } + } + fn deserialize( + ref keys: Span, ref data: Span, + ) -> Option { + let __selector__ = *core::array::SpanTrait::pop_front(ref keys)?; + Option::None + } +} +impl StorageStorageBaseDrop of core::traits::Drop::; +impl StorageStorageBaseCopy of core::traits::Copy::; +impl StorageStorageBaseMutDrop of core::traits::Drop::; +impl StorageStorageBaseMutCopy of core::traits::Copy::; +} + +impl BadModelUnexpectedArgWithValueIntrospect<> of dojo::model::introspect::Introspect> { + #[inline(always)] + fn size() -> Option { + dojo::model::introspect::Introspect::::size() + } + + fn layout() -> dojo::model::Layout { + dojo::model::Layout::Struct( + array![ + dojo::model::FieldLayout { + selector: 578691550836206188651404750433984985630363913126316857592149308417275000080, + layout: dojo::model::introspect::Introspect::::layout() + } + ].span() + ) + } + + #[inline(always)] + fn ty() -> dojo::model::introspect::Ty { + dojo::model::introspect::Ty::Struct( + dojo::model::introspect::Struct { + name: 'BadModelUnexpectedArgWithValue', + attrs: array![].span(), + children: array![ + dojo::model::introspect::Member { + name: 'id', + attrs: array!['key'].span(), + ty: dojo::model::introspect::Introspect::::ty() + }, +dojo::model::introspect::Member { + name: 'v', + attrs: array![].span(), + ty: dojo::model::introspect::Introspect::::ty() + } + + ].span() + } + ) + } +} + +#[derive(Drop, Serde)] +pub struct BadModelUnexpectedArgWithValueEntity { + __id: felt252, // private field + pub v: Vec3, + +} + +#[generate_trait] +pub impl BadModelUnexpectedArgWithValueEntityStoreImpl of BadModelUnexpectedArgWithValueEntityStore { + fn get(world: dojo::world::IWorldDispatcher, entity_id: felt252) -> BadModelUnexpectedArgWithValueEntity { + BadModelUnexpectedArgWithValueModelEntityImpl::get(world, entity_id) + } + + fn update(self: @BadModelUnexpectedArgWithValueEntity, world: dojo::world::IWorldDispatcher) { + dojo::model::ModelEntity::::update_entity(self, world); + } + + fn delete(self: @BadModelUnexpectedArgWithValueEntity, world: dojo::world::IWorldDispatcher) { + dojo::model::ModelEntity::::delete_entity(self, world); + } + + + fn get_v(world: dojo::world::IWorldDispatcher, entity_id: felt252) -> Vec3 { + let mut values = dojo::model::ModelEntity::::get_member( + world, + entity_id, + 578691550836206188651404750433984985630363913126316857592149308417275000080 + ); + let field_value = core::serde::Serde::::deserialize(ref values); + + if core::option::OptionTrait::::is_none(@field_value) { + panic!( + "Field `BadModelUnexpectedArgWithValue::v`: deserialization failed." + ); + } + + core::option::OptionTrait::::unwrap(field_value) + } + + fn set_v(self: @BadModelUnexpectedArgWithValueEntity, world: dojo::world::IWorldDispatcher, value: Vec3) { + let mut serialized = core::array::ArrayTrait::new(); + core::serde::Serde::serialize(@value, ref serialized); + + self.set_member( + world, + 578691550836206188651404750433984985630363913126316857592149308417275000080, + serialized.span() + ); + } + +} + +#[generate_trait] +pub impl BadModelUnexpectedArgWithValueStoreImpl of BadModelUnexpectedArgWithValueStore { + fn entity_id_from_keys(id: felt252) -> felt252 { + let mut serialized = core::array::ArrayTrait::new(); + core::array::ArrayTrait::append(ref serialized, id); + + core::poseidon::poseidon_hash_span(serialized.span()) + } + + fn from_values(ref keys: Span, ref values: Span) -> BadModelUnexpectedArgWithValue { + let mut serialized = core::array::ArrayTrait::new(); + serialized.append_span(keys); + serialized.append_span(values); + let mut serialized = core::array::ArrayTrait::span(@serialized); + + let entity = core::serde::Serde::::deserialize(ref serialized); + + if core::option::OptionTrait::::is_none(@entity) { + panic!( + "Model `BadModelUnexpectedArgWithValue`: deserialization failed. Ensure the length of the keys tuple is matching the number of #[key] fields in the model struct." + ); + } + + core::option::OptionTrait::::unwrap(entity) + } + + fn get(world: dojo::world::IWorldDispatcher, id: felt252) -> BadModelUnexpectedArgWithValue { + let mut serialized = core::array::ArrayTrait::new(); + core::array::ArrayTrait::append(ref serialized, id); + + + dojo::model::Model::::get(world, serialized.span()) + } + + fn set(self: @BadModelUnexpectedArgWithValue, world: dojo::world::IWorldDispatcher) { + dojo::model::Model::::set_model(self, world); + } + + fn delete(self: @BadModelUnexpectedArgWithValue, world: dojo::world::IWorldDispatcher) { + dojo::model::Model::::delete_model(self, world); + } + + + fn get_v(world: dojo::world::IWorldDispatcher, id: felt252) -> Vec3 { + let mut serialized = core::array::ArrayTrait::new(); + core::array::ArrayTrait::append(ref serialized, id); + + + let mut values = dojo::model::Model::::get_member( + world, + serialized.span(), + 578691550836206188651404750433984985630363913126316857592149308417275000080 + ); + + let field_value = core::serde::Serde::::deserialize(ref values); + + if core::option::OptionTrait::::is_none(@field_value) { + panic!( + "Field `BadModelUnexpectedArgWithValue::v`: deserialization failed." + ); + } + + core::option::OptionTrait::::unwrap(field_value) + } + + fn set_v(self: @BadModelUnexpectedArgWithValue, world: dojo::world::IWorldDispatcher, value: Vec3) { + let mut serialized = core::array::ArrayTrait::new(); + core::serde::Serde::serialize(@value, ref serialized); + + self.set_member( + world, + 578691550836206188651404750433984985630363913126316857592149308417275000080, + serialized.span() + ); + } + +} + +pub impl BadModelUnexpectedArgWithValueModelEntityImpl of dojo::model::ModelEntity { + fn id(self: @BadModelUnexpectedArgWithValueEntity) -> felt252 { + *self.__id + } + + fn values(self: @BadModelUnexpectedArgWithValueEntity) -> Span { + let mut serialized = core::array::ArrayTrait::new(); + core::serde::Serde::serialize(self.v, ref serialized); + + core::array::ArrayTrait::span(@serialized) + } + + fn from_values(entity_id: felt252, ref values: Span) -> BadModelUnexpectedArgWithValueEntity { + let mut serialized = array![entity_id]; + serialized.append_span(values); + let mut serialized = core::array::ArrayTrait::span(@serialized); + + let entity_values = core::serde::Serde::::deserialize(ref serialized); + if core::option::OptionTrait::::is_none(@entity_values) { + panic!( + "ModelEntity `BadModelUnexpectedArgWithValueEntity`: deserialization failed." + ); + } + core::option::OptionTrait::::unwrap(entity_values) + } + + fn get(world: dojo::world::IWorldDispatcher, entity_id: felt252) -> BadModelUnexpectedArgWithValueEntity { + let mut values = dojo::world::IWorldDispatcherTrait::entity( + world, + dojo::model::Model::::selector(), + dojo::model::ModelIndex::Id(entity_id), + dojo::model::Model::::layout() + ); + Self::from_values(entity_id, ref values) + } + + fn update_entity(self: @BadModelUnexpectedArgWithValueEntity, world: dojo::world::IWorldDispatcher) { + dojo::world::IWorldDispatcherTrait::set_entity( + world, + dojo::model::Model::::selector(), + dojo::model::ModelIndex::Id(self.id()), + self.values(), + dojo::model::Model::::layout() + ); + } + + fn delete_entity(self: @BadModelUnexpectedArgWithValueEntity, world: dojo::world::IWorldDispatcher) { + dojo::world::IWorldDispatcherTrait::delete_entity( + world, + dojo::model::Model::::selector(), + dojo::model::ModelIndex::Id(self.id()), + dojo::model::Model::::layout() + ); + } + + fn get_member( + world: dojo::world::IWorldDispatcher, + entity_id: felt252, + member_id: felt252, + ) -> Span { + match dojo::utils::find_model_field_layout(dojo::model::Model::::layout(), member_id) { + Option::Some(field_layout) => { + dojo::world::IWorldDispatcherTrait::entity( + world, + dojo::model::Model::::selector(), + dojo::model::ModelIndex::MemberId((entity_id, member_id)), + field_layout + ) + }, + Option::None => core::panic_with_felt252('bad member id') + } + } + + fn set_member( + self: @BadModelUnexpectedArgWithValueEntity, + world: dojo::world::IWorldDispatcher, + member_id: felt252, + values: Span, + ) { + match dojo::utils::find_model_field_layout(dojo::model::Model::::layout(), member_id) { + Option::Some(field_layout) => { + dojo::world::IWorldDispatcherTrait::set_entity( + world, + dojo::model::Model::::selector(), + dojo::model::ModelIndex::MemberId((self.id(), member_id)), + values, + field_layout + ) + }, + Option::None => core::panic_with_felt252('bad member id') + } + } +} + +pub impl BadModelUnexpectedArgWithValueModelImpl of dojo::model::Model { + fn get(world: dojo::world::IWorldDispatcher, keys: Span) -> BadModelUnexpectedArgWithValue { + let mut values = dojo::world::IWorldDispatcherTrait::entity( + world, + Self::selector(), + dojo::model::ModelIndex::Keys(keys), + Self::layout() + ); + let mut _keys = keys; + + BadModelUnexpectedArgWithValueStore::from_values(ref _keys, ref values) + } + + fn set_model( + self: @BadModelUnexpectedArgWithValue, + world: dojo::world::IWorldDispatcher + ) { + dojo::world::IWorldDispatcherTrait::set_entity( + world, + Self::selector(), + dojo::model::ModelIndex::Keys(Self::keys(self)), + Self::values(self), + Self::layout() + ); + } + + fn delete_model( + self: @BadModelUnexpectedArgWithValue, + world: dojo::world::IWorldDispatcher + ) { + dojo::world::IWorldDispatcherTrait::delete_entity( + world, + Self::selector(), + dojo::model::ModelIndex::Keys(Self::keys(self)), + Self::layout() + ); + } + + fn get_member( + world: dojo::world::IWorldDispatcher, + keys: Span, + member_id: felt252 + ) -> Span { + match dojo::utils::find_model_field_layout(Self::layout(), member_id) { + Option::Some(field_layout) => { + let entity_id = dojo::utils::entity_id_from_keys(keys); + dojo::world::IWorldDispatcherTrait::entity( + world, + Self::selector(), + dojo::model::ModelIndex::MemberId((entity_id, member_id)), + field_layout + ) + }, + Option::None => core::panic_with_felt252('bad member id') + } + } + + fn set_member( + self: @BadModelUnexpectedArgWithValue, + world: dojo::world::IWorldDispatcher, + member_id: felt252, + values: Span + ) { + match dojo::utils::find_model_field_layout(Self::layout(), member_id) { + Option::Some(field_layout) => { + dojo::world::IWorldDispatcherTrait::set_entity( + world, + Self::selector(), + dojo::model::ModelIndex::MemberId((self.entity_id(), member_id)), + values, + field_layout + ) + }, + Option::None => core::panic_with_felt252('bad member id') + } + } + + #[inline(always)] + fn name() -> ByteArray { + "BadModelUnexpectedArgWithValue" + } + + #[inline(always)] + fn namespace() -> ByteArray { + "dojo_test" + } + + #[inline(always)] + fn tag() -> ByteArray { + "dojo_test-BadModelUnexpectedArgWithValue" + } + + #[inline(always)] + fn version() -> u8 { + 1 + } + + #[inline(always)] + fn selector() -> felt252 { + 1774601905279008934284028706234273692471613779453192873246657851412081197776 + } + + #[inline(always)] + fn instance_selector(self: @BadModelUnexpectedArgWithValue) -> felt252 { + Self::selector() + } + + #[inline(always)] + fn name_hash() -> felt252 { + 3586339245084542986020591057627093254376225984628310828088084183494435682971 + } + + #[inline(always)] + fn namespace_hash() -> felt252 { + 1452123528942907587532668415362544424816022573043154497385993678618948064048 + } + + #[inline(always)] + fn entity_id(self: @BadModelUnexpectedArgWithValue) -> felt252 { + core::poseidon::poseidon_hash_span(self.keys()) + } + + #[inline(always)] + fn keys(self: @BadModelUnexpectedArgWithValue) -> Span { + let mut serialized = core::array::ArrayTrait::new(); + core::array::ArrayTrait::append(ref serialized, *self.id); + + core::array::ArrayTrait::span(@serialized) + } + + #[inline(always)] + fn values(self: @BadModelUnexpectedArgWithValue) -> Span { + let mut serialized = core::array::ArrayTrait::new(); + core::serde::Serde::serialize(self.v, ref serialized); + + core::array::ArrayTrait::span(@serialized) + } + + #[inline(always)] + fn layout() -> dojo::model::Layout { + dojo::model::introspect::Introspect::::layout() + } + + #[inline(always)] + fn instance_layout(self: @BadModelUnexpectedArgWithValue) -> dojo::model::Layout { + Self::layout() + } + + #[inline(always)] + fn packed_size() -> Option { + dojo::model::layout::compute_packed_size(Self::layout()) + } +} + +#[starknet::interface] +pub trait Ibad_model_unexpected_arg_with_value { + fn ensure_abi(self: @T, model: BadModelUnexpectedArgWithValue); +} + +#[starknet::contract] +pub mod bad_model_unexpected_arg_with_value { + use super::BadModelUnexpectedArgWithValue; + use super::Ibad_model_unexpected_arg_with_value; + + #[abi(embed_v0)] + impl DojoModelImpl of dojo::model::IModel{ + fn name(self: @ContractState) -> ByteArray { + "BadModelUnexpectedArgWithValue" + } + + fn namespace(self: @ContractState) -> ByteArray { + "dojo_test" + } + + fn tag(self: @ContractState) -> ByteArray { + "dojo_test-BadModelUnexpectedArgWithValue" + } + + fn version(self: @ContractState) -> u8 { + 1 + } + + fn selector(self: @ContractState) -> felt252 { + 1774601905279008934284028706234273692471613779453192873246657851412081197776 + } + + fn name_hash(self: @ContractState) -> felt252 { + 3586339245084542986020591057627093254376225984628310828088084183494435682971 + } + + fn namespace_hash(self: @ContractState) -> felt252 { + 1452123528942907587532668415362544424816022573043154497385993678618948064048 + } + + fn unpacked_size(self: @ContractState) -> Option { + dojo::model::introspect::Introspect::::size() + } + + fn packed_size(self: @ContractState) -> Option { + dojo::model::Model::::packed_size() + } + + fn layout(self: @ContractState) -> dojo::model::Layout { + dojo::model::Model::::layout() + } + + fn schema(self: @ContractState) -> dojo::model::introspect::Ty { + dojo::model::introspect::Introspect::::ty() + } + } + + #[abi(embed_v0)] + impl bad_model_unexpected_arg_with_valueImpl of Ibad_model_unexpected_arg_with_value{ + fn ensure_abi(self: @ContractState, model: BadModelUnexpectedArgWithValue) { + } + } +#[event] +#[derive(Drop, starknet::Event)] +pub enum Event {} + + +#[phantom] +pub struct Storage { +} + +#[derive(Drop, Copy)] +pub struct StorageStorageBase { +} +impl StorageStorageImpl of starknet::storage::StorageTrait { + type BaseType = StorageStorageBase; + fn storage(self: starknet::storage::FlattenedStorage) -> StorageStorageBase { + StorageStorageBase { + } + } +} +#[derive(Drop, Copy)] +pub struct StorageStorageBaseMut { +} +impl StorageStorageMutImpl of starknet::storage::StorageTraitMut { + type BaseType = StorageStorageBaseMut; + fn storage_mut(self: starknet::storage::FlattenedStorage>) -> StorageStorageBaseMut { + StorageStorageBaseMut { + } + } +} + +pub struct ContractState { +} + +impl ContractStateDrop of Drop {} + +impl ContractStateDeref of core::ops::SnapshotDeref { + type Target = starknet::storage::FlattenedStorage; + fn snapshot_deref(self: @ContractState) -> starknet::storage::FlattenedStorage { + starknet::storage::FlattenedStorage {} + } +} +impl ContractStateDerefMut of core::ops::DerefMut { + type Target = starknet::storage::FlattenedStorage> ; + fn deref_mut(ref self: ContractState) -> starknet::storage::FlattenedStorage> { + starknet::storage::FlattenedStorage {} + } +} +pub fn unsafe_new_contract_state() -> ContractState { + ContractState { + } +} + +// TODO(Gil): This generates duplicate diagnostics because of the plugin system, squash the duplicates into one. +#[deprecated( + feature: "deprecated_legacy_map", + note: "Use `starknet::storage::Map` instead." +)] +use starknet::storage::Map as LegacyMap; + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__DojoModelImpl__name(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = DojoModelImpl::name(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__DojoModelImpl__namespace(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = DojoModelImpl::namespace(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__DojoModelImpl__tag(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = DojoModelImpl::tag(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__DojoModelImpl__version(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = DojoModelImpl::version(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__DojoModelImpl__selector(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = DojoModelImpl::selector(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__DojoModelImpl__name_hash(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = DojoModelImpl::name_hash(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__DojoModelImpl__namespace_hash(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = DojoModelImpl::namespace_hash(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__DojoModelImpl__unpacked_size(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = DojoModelImpl::unpacked_size(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::>::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__DojoModelImpl__packed_size(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = DojoModelImpl::packed_size(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::>::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__DojoModelImpl__layout(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = DojoModelImpl::layout(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__DojoModelImpl__schema(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = DojoModelImpl::schema(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__bad_model_unexpected_arg_with_valueImpl__ensure_abi(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + let __arg_model = core::option::OptionTraitImpl::expect( + core::serde::Serde::::deserialize(ref data), + 'Failed to deserialize param #1' + ); + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + bad_model_unexpected_arg_with_valueImpl::ensure_abi(@contract_state, __arg_model); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::array::ArrayTrait::span(@arr) +} + + +pub mod __external { + pub use super::__wrapper__DojoModelImpl__name as name; + pub use super::__wrapper__DojoModelImpl__namespace as namespace; + pub use super::__wrapper__DojoModelImpl__tag as tag; + pub use super::__wrapper__DojoModelImpl__version as version; + pub use super::__wrapper__DojoModelImpl__selector as selector; + pub use super::__wrapper__DojoModelImpl__name_hash as name_hash; + pub use super::__wrapper__DojoModelImpl__namespace_hash as namespace_hash; + pub use super::__wrapper__DojoModelImpl__unpacked_size as unpacked_size; + pub use super::__wrapper__DojoModelImpl__packed_size as packed_size; + pub use super::__wrapper__DojoModelImpl__layout as layout; + pub use super::__wrapper__DojoModelImpl__schema as schema; + pub use super::__wrapper__bad_model_unexpected_arg_with_valueImpl__ensure_abi as ensure_abi; +} +pub mod __l1_handler { +} +pub mod __constructor { +} + impl ContractStateEventEmitter of starknet::event::EventEmitter< + ContractState, Event + > { + fn emit>( + ref self: ContractState, event: S + ) { + let event: Event = core::traits::Into::into(event); + let mut keys = Default::::default(); + let mut data = Default::::default(); + starknet::Event::append_keys_and_data(@event, ref keys, ref data); + starknet::SyscallResultTrait::unwrap_syscall( + starknet::syscalls::emit_event_syscall( + core::array::ArrayTrait::span(@keys), + core::array::ArrayTrait::span(@data), + ) + ) + } + } +impl EventDrop of core::traits::Drop::; +impl EventIsEvent of starknet::Event { + fn append_keys_and_data( + self: @Event, ref keys: Array, ref data: Array + ) { + match self { + } + } + fn deserialize( + ref keys: Span, ref data: Span, + ) -> Option { + let __selector__ = *core::array::SpanTrait::pop_front(ref keys)?; + Option::None + } +} +impl StorageStorageBaseDrop of core::traits::Drop::; +impl StorageStorageBaseCopy of core::traits::Copy::; +impl StorageStorageBaseMutDrop of core::traits::Drop::; +impl StorageStorageBaseMutCopy of core::traits::Copy::; +} + +impl BadModelUnexpectedArgIntrospect<> of dojo::model::introspect::Introspect> { + #[inline(always)] + fn size() -> Option { + dojo::model::introspect::Introspect::::size() + } + + fn layout() -> dojo::model::Layout { + dojo::model::Layout::Struct( + array![ + dojo::model::FieldLayout { + selector: 578691550836206188651404750433984985630363913126316857592149308417275000080, + layout: dojo::model::introspect::Introspect::::layout() + } + ].span() + ) + } + + #[inline(always)] + fn ty() -> dojo::model::introspect::Ty { + dojo::model::introspect::Ty::Struct( + dojo::model::introspect::Struct { + name: 'BadModelUnexpectedArg', + attrs: array![].span(), + children: array![ + dojo::model::introspect::Member { + name: 'id', + attrs: array!['key'].span(), + ty: dojo::model::introspect::Introspect::::ty() + }, +dojo::model::introspect::Member { + name: 'v', + attrs: array![].span(), + ty: dojo::model::introspect::Introspect::::ty() + } + + ].span() + } + ) + } +} + +#[derive(Drop, Serde)] +pub struct BadModelUnexpectedArgEntity { + __id: felt252, // private field + pub v: Vec3, + +} + +#[generate_trait] +pub impl BadModelUnexpectedArgEntityStoreImpl of BadModelUnexpectedArgEntityStore { + fn get(world: dojo::world::IWorldDispatcher, entity_id: felt252) -> BadModelUnexpectedArgEntity { + BadModelUnexpectedArgModelEntityImpl::get(world, entity_id) + } + + fn update(self: @BadModelUnexpectedArgEntity, world: dojo::world::IWorldDispatcher) { + dojo::model::ModelEntity::::update_entity(self, world); + } + + fn delete(self: @BadModelUnexpectedArgEntity, world: dojo::world::IWorldDispatcher) { + dojo::model::ModelEntity::::delete_entity(self, world); + } + + + fn get_v(world: dojo::world::IWorldDispatcher, entity_id: felt252) -> Vec3 { + let mut values = dojo::model::ModelEntity::::get_member( + world, + entity_id, + 578691550836206188651404750433984985630363913126316857592149308417275000080 + ); + let field_value = core::serde::Serde::::deserialize(ref values); + + if core::option::OptionTrait::::is_none(@field_value) { + panic!( + "Field `BadModelUnexpectedArg::v`: deserialization failed." + ); + } + + core::option::OptionTrait::::unwrap(field_value) + } + + fn set_v(self: @BadModelUnexpectedArgEntity, world: dojo::world::IWorldDispatcher, value: Vec3) { + let mut serialized = core::array::ArrayTrait::new(); + core::serde::Serde::serialize(@value, ref serialized); + + self.set_member( + world, + 578691550836206188651404750433984985630363913126316857592149308417275000080, + serialized.span() + ); + } + +} + +#[generate_trait] +pub impl BadModelUnexpectedArgStoreImpl of BadModelUnexpectedArgStore { + fn entity_id_from_keys(id: felt252) -> felt252 { + let mut serialized = core::array::ArrayTrait::new(); + core::array::ArrayTrait::append(ref serialized, id); + + core::poseidon::poseidon_hash_span(serialized.span()) + } + + fn from_values(ref keys: Span, ref values: Span) -> BadModelUnexpectedArg { + let mut serialized = core::array::ArrayTrait::new(); + serialized.append_span(keys); + serialized.append_span(values); + let mut serialized = core::array::ArrayTrait::span(@serialized); + + let entity = core::serde::Serde::::deserialize(ref serialized); + + if core::option::OptionTrait::::is_none(@entity) { + panic!( + "Model `BadModelUnexpectedArg`: deserialization failed. Ensure the length of the keys tuple is matching the number of #[key] fields in the model struct." + ); + } + + core::option::OptionTrait::::unwrap(entity) + } + + fn get(world: dojo::world::IWorldDispatcher, id: felt252) -> BadModelUnexpectedArg { + let mut serialized = core::array::ArrayTrait::new(); + core::array::ArrayTrait::append(ref serialized, id); + + + dojo::model::Model::::get(world, serialized.span()) + } + + fn set(self: @BadModelUnexpectedArg, world: dojo::world::IWorldDispatcher) { + dojo::model::Model::::set_model(self, world); + } + + fn delete(self: @BadModelUnexpectedArg, world: dojo::world::IWorldDispatcher) { + dojo::model::Model::::delete_model(self, world); + } + + + fn get_v(world: dojo::world::IWorldDispatcher, id: felt252) -> Vec3 { + let mut serialized = core::array::ArrayTrait::new(); + core::array::ArrayTrait::append(ref serialized, id); + + + let mut values = dojo::model::Model::::get_member( + world, + serialized.span(), + 578691550836206188651404750433984985630363913126316857592149308417275000080 + ); + + let field_value = core::serde::Serde::::deserialize(ref values); + + if core::option::OptionTrait::::is_none(@field_value) { + panic!( + "Field `BadModelUnexpectedArg::v`: deserialization failed." + ); + } + + core::option::OptionTrait::::unwrap(field_value) + } + + fn set_v(self: @BadModelUnexpectedArg, world: dojo::world::IWorldDispatcher, value: Vec3) { + let mut serialized = core::array::ArrayTrait::new(); + core::serde::Serde::serialize(@value, ref serialized); + + self.set_member( + world, + 578691550836206188651404750433984985630363913126316857592149308417275000080, + serialized.span() + ); + } + +} + +pub impl BadModelUnexpectedArgModelEntityImpl of dojo::model::ModelEntity { + fn id(self: @BadModelUnexpectedArgEntity) -> felt252 { + *self.__id + } + + fn values(self: @BadModelUnexpectedArgEntity) -> Span { + let mut serialized = core::array::ArrayTrait::new(); + core::serde::Serde::serialize(self.v, ref serialized); + + core::array::ArrayTrait::span(@serialized) + } + + fn from_values(entity_id: felt252, ref values: Span) -> BadModelUnexpectedArgEntity { + let mut serialized = array![entity_id]; + serialized.append_span(values); + let mut serialized = core::array::ArrayTrait::span(@serialized); + + let entity_values = core::serde::Serde::::deserialize(ref serialized); + if core::option::OptionTrait::::is_none(@entity_values) { + panic!( + "ModelEntity `BadModelUnexpectedArgEntity`: deserialization failed." + ); + } + core::option::OptionTrait::::unwrap(entity_values) + } + + fn get(world: dojo::world::IWorldDispatcher, entity_id: felt252) -> BadModelUnexpectedArgEntity { + let mut values = dojo::world::IWorldDispatcherTrait::entity( + world, + dojo::model::Model::::selector(), + dojo::model::ModelIndex::Id(entity_id), + dojo::model::Model::::layout() + ); + Self::from_values(entity_id, ref values) + } + + fn update_entity(self: @BadModelUnexpectedArgEntity, world: dojo::world::IWorldDispatcher) { + dojo::world::IWorldDispatcherTrait::set_entity( + world, + dojo::model::Model::::selector(), + dojo::model::ModelIndex::Id(self.id()), + self.values(), + dojo::model::Model::::layout() + ); + } + + fn delete_entity(self: @BadModelUnexpectedArgEntity, world: dojo::world::IWorldDispatcher) { + dojo::world::IWorldDispatcherTrait::delete_entity( + world, + dojo::model::Model::::selector(), + dojo::model::ModelIndex::Id(self.id()), + dojo::model::Model::::layout() + ); + } + + fn get_member( + world: dojo::world::IWorldDispatcher, + entity_id: felt252, + member_id: felt252, + ) -> Span { + match dojo::utils::find_model_field_layout(dojo::model::Model::::layout(), member_id) { + Option::Some(field_layout) => { + dojo::world::IWorldDispatcherTrait::entity( + world, + dojo::model::Model::::selector(), + dojo::model::ModelIndex::MemberId((entity_id, member_id)), + field_layout + ) + }, + Option::None => core::panic_with_felt252('bad member id') + } + } + + fn set_member( + self: @BadModelUnexpectedArgEntity, + world: dojo::world::IWorldDispatcher, + member_id: felt252, + values: Span, + ) { + match dojo::utils::find_model_field_layout(dojo::model::Model::::layout(), member_id) { + Option::Some(field_layout) => { + dojo::world::IWorldDispatcherTrait::set_entity( + world, + dojo::model::Model::::selector(), + dojo::model::ModelIndex::MemberId((self.id(), member_id)), + values, + field_layout + ) + }, + Option::None => core::panic_with_felt252('bad member id') + } + } +} + +pub impl BadModelUnexpectedArgModelImpl of dojo::model::Model { + fn get(world: dojo::world::IWorldDispatcher, keys: Span) -> BadModelUnexpectedArg { + let mut values = dojo::world::IWorldDispatcherTrait::entity( + world, + Self::selector(), + dojo::model::ModelIndex::Keys(keys), + Self::layout() + ); + let mut _keys = keys; + + BadModelUnexpectedArgStore::from_values(ref _keys, ref values) + } + + fn set_model( + self: @BadModelUnexpectedArg, + world: dojo::world::IWorldDispatcher + ) { + dojo::world::IWorldDispatcherTrait::set_entity( + world, + Self::selector(), + dojo::model::ModelIndex::Keys(Self::keys(self)), + Self::values(self), + Self::layout() + ); + } + + fn delete_model( + self: @BadModelUnexpectedArg, + world: dojo::world::IWorldDispatcher + ) { + dojo::world::IWorldDispatcherTrait::delete_entity( + world, + Self::selector(), + dojo::model::ModelIndex::Keys(Self::keys(self)), + Self::layout() + ); + } + + fn get_member( + world: dojo::world::IWorldDispatcher, + keys: Span, + member_id: felt252 + ) -> Span { + match dojo::utils::find_model_field_layout(Self::layout(), member_id) { + Option::Some(field_layout) => { + let entity_id = dojo::utils::entity_id_from_keys(keys); + dojo::world::IWorldDispatcherTrait::entity( + world, + Self::selector(), + dojo::model::ModelIndex::MemberId((entity_id, member_id)), + field_layout + ) + }, + Option::None => core::panic_with_felt252('bad member id') + } + } + + fn set_member( + self: @BadModelUnexpectedArg, + world: dojo::world::IWorldDispatcher, + member_id: felt252, + values: Span + ) { + match dojo::utils::find_model_field_layout(Self::layout(), member_id) { + Option::Some(field_layout) => { + dojo::world::IWorldDispatcherTrait::set_entity( + world, + Self::selector(), + dojo::model::ModelIndex::MemberId((self.entity_id(), member_id)), + values, + field_layout + ) + }, + Option::None => core::panic_with_felt252('bad member id') + } + } + + #[inline(always)] + fn name() -> ByteArray { + "BadModelUnexpectedArg" + } + + #[inline(always)] + fn namespace() -> ByteArray { + "dojo_test" + } + + #[inline(always)] + fn tag() -> ByteArray { + "dojo_test-BadModelUnexpectedArg" + } + + #[inline(always)] + fn version() -> u8 { + 1 + } + + #[inline(always)] + fn selector() -> felt252 { + 285468224541147509570785281966044474829506125602814945625270991330973673529 + } + + #[inline(always)] + fn instance_selector(self: @BadModelUnexpectedArg) -> felt252 { + Self::selector() + } + + #[inline(always)] + fn name_hash() -> felt252 { + 246403407829267991441535935236143476032296881039254363860883767387993960270 + } + + #[inline(always)] + fn namespace_hash() -> felt252 { + 1452123528942907587532668415362544424816022573043154497385993678618948064048 + } + + #[inline(always)] + fn entity_id(self: @BadModelUnexpectedArg) -> felt252 { + core::poseidon::poseidon_hash_span(self.keys()) + } + + #[inline(always)] + fn keys(self: @BadModelUnexpectedArg) -> Span { + let mut serialized = core::array::ArrayTrait::new(); + core::array::ArrayTrait::append(ref serialized, *self.id); + + core::array::ArrayTrait::span(@serialized) + } + + #[inline(always)] + fn values(self: @BadModelUnexpectedArg) -> Span { + let mut serialized = core::array::ArrayTrait::new(); + core::serde::Serde::serialize(self.v, ref serialized); + + core::array::ArrayTrait::span(@serialized) + } + + #[inline(always)] + fn layout() -> dojo::model::Layout { + dojo::model::introspect::Introspect::::layout() + } + + #[inline(always)] + fn instance_layout(self: @BadModelUnexpectedArg) -> dojo::model::Layout { + Self::layout() + } + + #[inline(always)] + fn packed_size() -> Option { + dojo::model::layout::compute_packed_size(Self::layout()) + } +} + +#[starknet::interface] +pub trait Ibad_model_unexpected_arg { + fn ensure_abi(self: @T, model: BadModelUnexpectedArg); +} + +#[starknet::contract] +pub mod bad_model_unexpected_arg { + use super::BadModelUnexpectedArg; + use super::Ibad_model_unexpected_arg; + + #[abi(embed_v0)] + impl DojoModelImpl of dojo::model::IModel{ + fn name(self: @ContractState) -> ByteArray { + "BadModelUnexpectedArg" + } + + fn namespace(self: @ContractState) -> ByteArray { + "dojo_test" + } + + fn tag(self: @ContractState) -> ByteArray { + "dojo_test-BadModelUnexpectedArg" + } + + fn version(self: @ContractState) -> u8 { + 1 + } + + fn selector(self: @ContractState) -> felt252 { + 285468224541147509570785281966044474829506125602814945625270991330973673529 + } + + fn name_hash(self: @ContractState) -> felt252 { + 246403407829267991441535935236143476032296881039254363860883767387993960270 + } + + fn namespace_hash(self: @ContractState) -> felt252 { + 1452123528942907587532668415362544424816022573043154497385993678618948064048 + } + + fn unpacked_size(self: @ContractState) -> Option { + dojo::model::introspect::Introspect::::size() + } + + fn packed_size(self: @ContractState) -> Option { + dojo::model::Model::::packed_size() + } + + fn layout(self: @ContractState) -> dojo::model::Layout { + dojo::model::Model::::layout() + } + + fn schema(self: @ContractState) -> dojo::model::introspect::Ty { + dojo::model::introspect::Introspect::::ty() + } + } + + #[abi(embed_v0)] + impl bad_model_unexpected_argImpl of Ibad_model_unexpected_arg{ + fn ensure_abi(self: @ContractState, model: BadModelUnexpectedArg) { + } + } +#[event] +#[derive(Drop, starknet::Event)] +pub enum Event {} + + +#[phantom] +pub struct Storage { +} + +#[derive(Drop, Copy)] +pub struct StorageStorageBase { +} +impl StorageStorageImpl of starknet::storage::StorageTrait { + type BaseType = StorageStorageBase; + fn storage(self: starknet::storage::FlattenedStorage) -> StorageStorageBase { + StorageStorageBase { + } + } +} +#[derive(Drop, Copy)] +pub struct StorageStorageBaseMut { +} +impl StorageStorageMutImpl of starknet::storage::StorageTraitMut { + type BaseType = StorageStorageBaseMut; + fn storage_mut(self: starknet::storage::FlattenedStorage>) -> StorageStorageBaseMut { + StorageStorageBaseMut { + } + } +} + +pub struct ContractState { +} + +impl ContractStateDrop of Drop {} + +impl ContractStateDeref of core::ops::SnapshotDeref { + type Target = starknet::storage::FlattenedStorage; + fn snapshot_deref(self: @ContractState) -> starknet::storage::FlattenedStorage { + starknet::storage::FlattenedStorage {} + } +} +impl ContractStateDerefMut of core::ops::DerefMut { + type Target = starknet::storage::FlattenedStorage> ; + fn deref_mut(ref self: ContractState) -> starknet::storage::FlattenedStorage> { + starknet::storage::FlattenedStorage {} + } +} +pub fn unsafe_new_contract_state() -> ContractState { + ContractState { + } +} + +// TODO(Gil): This generates duplicate diagnostics because of the plugin system, squash the duplicates into one. +#[deprecated( + feature: "deprecated_legacy_map", + note: "Use `starknet::storage::Map` instead." +)] +use starknet::storage::Map as LegacyMap; + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__DojoModelImpl__name(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = DojoModelImpl::name(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__DojoModelImpl__namespace(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = DojoModelImpl::namespace(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__DojoModelImpl__tag(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = DojoModelImpl::tag(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__DojoModelImpl__version(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = DojoModelImpl::version(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__DojoModelImpl__selector(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = DojoModelImpl::selector(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__DojoModelImpl__name_hash(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = DojoModelImpl::name_hash(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__DojoModelImpl__namespace_hash(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = DojoModelImpl::namespace_hash(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__DojoModelImpl__unpacked_size(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = DojoModelImpl::unpacked_size(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::>::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__DojoModelImpl__packed_size(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = DojoModelImpl::packed_size(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::>::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__DojoModelImpl__layout(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = DojoModelImpl::layout(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__DojoModelImpl__schema(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = DojoModelImpl::schema(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__bad_model_unexpected_argImpl__ensure_abi(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + let __arg_model = core::option::OptionTraitImpl::expect( + core::serde::Serde::::deserialize(ref data), + 'Failed to deserialize param #1' + ); + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + bad_model_unexpected_argImpl::ensure_abi(@contract_state, __arg_model); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::array::ArrayTrait::span(@arr) +} + + +pub mod __external { + pub use super::__wrapper__DojoModelImpl__name as name; + pub use super::__wrapper__DojoModelImpl__namespace as namespace; + pub use super::__wrapper__DojoModelImpl__tag as tag; + pub use super::__wrapper__DojoModelImpl__version as version; + pub use super::__wrapper__DojoModelImpl__selector as selector; + pub use super::__wrapper__DojoModelImpl__name_hash as name_hash; + pub use super::__wrapper__DojoModelImpl__namespace_hash as namespace_hash; + pub use super::__wrapper__DojoModelImpl__unpacked_size as unpacked_size; + pub use super::__wrapper__DojoModelImpl__packed_size as packed_size; + pub use super::__wrapper__DojoModelImpl__layout as layout; + pub use super::__wrapper__DojoModelImpl__schema as schema; + pub use super::__wrapper__bad_model_unexpected_argImpl__ensure_abi as ensure_abi; +} +pub mod __l1_handler { +} +pub mod __constructor { +} + impl ContractStateEventEmitter of starknet::event::EventEmitter< + ContractState, Event + > { + fn emit>( + ref self: ContractState, event: S + ) { + let event: Event = core::traits::Into::into(event); + let mut keys = Default::::default(); + let mut data = Default::::default(); + starknet::Event::append_keys_and_data(@event, ref keys, ref data); + starknet::SyscallResultTrait::unwrap_syscall( + starknet::syscalls::emit_event_syscall( + core::array::ArrayTrait::span(@keys), + core::array::ArrayTrait::span(@data), + ) + ) + } + } +impl EventDrop of core::traits::Drop::; +impl EventIsEvent of starknet::Event { + fn append_keys_and_data( + self: @Event, ref keys: Array, ref data: Array + ) { + match self { + } + } + fn deserialize( + ref keys: Span, ref data: Span, + ) -> Option { + let __selector__ = *core::array::SpanTrait::pop_front(ref keys)?; + Option::None + } +} +impl StorageStorageBaseDrop of core::traits::Drop::; +impl StorageStorageBaseCopy of core::traits::Copy::; +impl StorageStorageBaseMutDrop of core::traits::Drop::; +impl StorageStorageBaseMutCopy of core::traits::Copy::; +} + +impl BadModelNotSupportedVersionIntrospect<> of dojo::model::introspect::Introspect> { + #[inline(always)] + fn size() -> Option { + dojo::model::introspect::Introspect::::size() + } + + fn layout() -> dojo::model::Layout { + dojo::model::Layout::Struct( + array![ + dojo::model::FieldLayout { + selector: 578691550836206188651404750433984985630363913126316857592149308417275000080, + layout: dojo::model::introspect::Introspect::::layout() + } + ].span() + ) + } + + #[inline(always)] + fn ty() -> dojo::model::introspect::Ty { + dojo::model::introspect::Ty::Struct( + dojo::model::introspect::Struct { + name: 'BadModelNotSupportedVersion', + attrs: array![].span(), + children: array![ + dojo::model::introspect::Member { + name: 'id', + attrs: array!['key'].span(), + ty: dojo::model::introspect::Introspect::::ty() + }, +dojo::model::introspect::Member { + name: 'v', + attrs: array![].span(), + ty: dojo::model::introspect::Introspect::::ty() + } + + ].span() + } + ) + } +} + +#[derive(Drop, Serde)] +pub struct BadModelNotSupportedVersionEntity { + __id: felt252, // private field + pub v: Vec3, + +} + +#[generate_trait] +pub impl BadModelNotSupportedVersionEntityStoreImpl of BadModelNotSupportedVersionEntityStore { + fn get(world: dojo::world::IWorldDispatcher, entity_id: felt252) -> BadModelNotSupportedVersionEntity { + BadModelNotSupportedVersionModelEntityImpl::get(world, entity_id) + } + + fn update(self: @BadModelNotSupportedVersionEntity, world: dojo::world::IWorldDispatcher) { + dojo::model::ModelEntity::::update_entity(self, world); + } + + fn delete(self: @BadModelNotSupportedVersionEntity, world: dojo::world::IWorldDispatcher) { + dojo::model::ModelEntity::::delete_entity(self, world); + } + + + fn get_v(world: dojo::world::IWorldDispatcher, entity_id: felt252) -> Vec3 { + let mut values = dojo::model::ModelEntity::::get_member( + world, + entity_id, + 578691550836206188651404750433984985630363913126316857592149308417275000080 + ); + let field_value = core::serde::Serde::::deserialize(ref values); + + if core::option::OptionTrait::::is_none(@field_value) { + panic!( + "Field `BadModelNotSupportedVersion::v`: deserialization failed." + ); + } + + core::option::OptionTrait::::unwrap(field_value) + } + + fn set_v(self: @BadModelNotSupportedVersionEntity, world: dojo::world::IWorldDispatcher, value: Vec3) { + let mut serialized = core::array::ArrayTrait::new(); + core::serde::Serde::serialize(@value, ref serialized); + + self.set_member( + world, + 578691550836206188651404750433984985630363913126316857592149308417275000080, + serialized.span() + ); + } + +} + +#[generate_trait] +pub impl BadModelNotSupportedVersionStoreImpl of BadModelNotSupportedVersionStore { + fn entity_id_from_keys(id: felt252) -> felt252 { + let mut serialized = core::array::ArrayTrait::new(); + core::array::ArrayTrait::append(ref serialized, id); + + core::poseidon::poseidon_hash_span(serialized.span()) + } + + fn from_values(ref keys: Span, ref values: Span) -> BadModelNotSupportedVersion { + let mut serialized = core::array::ArrayTrait::new(); + serialized.append_span(keys); + serialized.append_span(values); + let mut serialized = core::array::ArrayTrait::span(@serialized); + + let entity = core::serde::Serde::::deserialize(ref serialized); + + if core::option::OptionTrait::::is_none(@entity) { + panic!( + "Model `BadModelNotSupportedVersion`: deserialization failed. Ensure the length of the keys tuple is matching the number of #[key] fields in the model struct." + ); + } + + core::option::OptionTrait::::unwrap(entity) + } + + fn get(world: dojo::world::IWorldDispatcher, id: felt252) -> BadModelNotSupportedVersion { + let mut serialized = core::array::ArrayTrait::new(); + core::array::ArrayTrait::append(ref serialized, id); + + + dojo::model::Model::::get(world, serialized.span()) + } + + fn set(self: @BadModelNotSupportedVersion, world: dojo::world::IWorldDispatcher) { + dojo::model::Model::::set_model(self, world); + } + + fn delete(self: @BadModelNotSupportedVersion, world: dojo::world::IWorldDispatcher) { + dojo::model::Model::::delete_model(self, world); + } + + + fn get_v(world: dojo::world::IWorldDispatcher, id: felt252) -> Vec3 { + let mut serialized = core::array::ArrayTrait::new(); + core::array::ArrayTrait::append(ref serialized, id); + + + let mut values = dojo::model::Model::::get_member( + world, + serialized.span(), + 578691550836206188651404750433984985630363913126316857592149308417275000080 + ); + + let field_value = core::serde::Serde::::deserialize(ref values); + + if core::option::OptionTrait::::is_none(@field_value) { + panic!( + "Field `BadModelNotSupportedVersion::v`: deserialization failed." + ); + } + + core::option::OptionTrait::::unwrap(field_value) + } + + fn set_v(self: @BadModelNotSupportedVersion, world: dojo::world::IWorldDispatcher, value: Vec3) { + let mut serialized = core::array::ArrayTrait::new(); + core::serde::Serde::serialize(@value, ref serialized); + + self.set_member( + world, + 578691550836206188651404750433984985630363913126316857592149308417275000080, + serialized.span() + ); + } + +} + +pub impl BadModelNotSupportedVersionModelEntityImpl of dojo::model::ModelEntity { + fn id(self: @BadModelNotSupportedVersionEntity) -> felt252 { + *self.__id + } + + fn values(self: @BadModelNotSupportedVersionEntity) -> Span { + let mut serialized = core::array::ArrayTrait::new(); + core::serde::Serde::serialize(self.v, ref serialized); + + core::array::ArrayTrait::span(@serialized) + } + + fn from_values(entity_id: felt252, ref values: Span) -> BadModelNotSupportedVersionEntity { + let mut serialized = array![entity_id]; + serialized.append_span(values); + let mut serialized = core::array::ArrayTrait::span(@serialized); + + let entity_values = core::serde::Serde::::deserialize(ref serialized); + if core::option::OptionTrait::::is_none(@entity_values) { + panic!( + "ModelEntity `BadModelNotSupportedVersionEntity`: deserialization failed." + ); + } + core::option::OptionTrait::::unwrap(entity_values) + } + + fn get(world: dojo::world::IWorldDispatcher, entity_id: felt252) -> BadModelNotSupportedVersionEntity { + let mut values = dojo::world::IWorldDispatcherTrait::entity( + world, + dojo::model::Model::::selector(), + dojo::model::ModelIndex::Id(entity_id), + dojo::model::Model::::layout() + ); + Self::from_values(entity_id, ref values) + } + + fn update_entity(self: @BadModelNotSupportedVersionEntity, world: dojo::world::IWorldDispatcher) { + dojo::world::IWorldDispatcherTrait::set_entity( + world, + dojo::model::Model::::selector(), + dojo::model::ModelIndex::Id(self.id()), + self.values(), + dojo::model::Model::::layout() + ); + } + + fn delete_entity(self: @BadModelNotSupportedVersionEntity, world: dojo::world::IWorldDispatcher) { + dojo::world::IWorldDispatcherTrait::delete_entity( + world, + dojo::model::Model::::selector(), + dojo::model::ModelIndex::Id(self.id()), + dojo::model::Model::::layout() + ); + } + + fn get_member( + world: dojo::world::IWorldDispatcher, + entity_id: felt252, + member_id: felt252, + ) -> Span { + match dojo::utils::find_model_field_layout(dojo::model::Model::::layout(), member_id) { + Option::Some(field_layout) => { + dojo::world::IWorldDispatcherTrait::entity( + world, + dojo::model::Model::::selector(), + dojo::model::ModelIndex::MemberId((entity_id, member_id)), + field_layout + ) + }, + Option::None => core::panic_with_felt252('bad member id') + } + } + + fn set_member( + self: @BadModelNotSupportedVersionEntity, + world: dojo::world::IWorldDispatcher, + member_id: felt252, + values: Span, + ) { + match dojo::utils::find_model_field_layout(dojo::model::Model::::layout(), member_id) { + Option::Some(field_layout) => { + dojo::world::IWorldDispatcherTrait::set_entity( + world, + dojo::model::Model::::selector(), + dojo::model::ModelIndex::MemberId((self.id(), member_id)), + values, + field_layout + ) + }, + Option::None => core::panic_with_felt252('bad member id') + } + } +} + +pub impl BadModelNotSupportedVersionModelImpl of dojo::model::Model { + fn get(world: dojo::world::IWorldDispatcher, keys: Span) -> BadModelNotSupportedVersion { + let mut values = dojo::world::IWorldDispatcherTrait::entity( + world, + Self::selector(), + dojo::model::ModelIndex::Keys(keys), + Self::layout() + ); + let mut _keys = keys; + + BadModelNotSupportedVersionStore::from_values(ref _keys, ref values) + } + + fn set_model( + self: @BadModelNotSupportedVersion, + world: dojo::world::IWorldDispatcher + ) { + dojo::world::IWorldDispatcherTrait::set_entity( + world, + Self::selector(), + dojo::model::ModelIndex::Keys(Self::keys(self)), + Self::values(self), + Self::layout() + ); + } + + fn delete_model( + self: @BadModelNotSupportedVersion, + world: dojo::world::IWorldDispatcher + ) { + dojo::world::IWorldDispatcherTrait::delete_entity( + world, + Self::selector(), + dojo::model::ModelIndex::Keys(Self::keys(self)), + Self::layout() + ); + } + + fn get_member( + world: dojo::world::IWorldDispatcher, + keys: Span, + member_id: felt252 + ) -> Span { + match dojo::utils::find_model_field_layout(Self::layout(), member_id) { + Option::Some(field_layout) => { + let entity_id = dojo::utils::entity_id_from_keys(keys); + dojo::world::IWorldDispatcherTrait::entity( + world, + Self::selector(), + dojo::model::ModelIndex::MemberId((entity_id, member_id)), + field_layout + ) + }, + Option::None => core::panic_with_felt252('bad member id') + } + } + + fn set_member( + self: @BadModelNotSupportedVersion, + world: dojo::world::IWorldDispatcher, + member_id: felt252, + values: Span + ) { + match dojo::utils::find_model_field_layout(Self::layout(), member_id) { + Option::Some(field_layout) => { + dojo::world::IWorldDispatcherTrait::set_entity( + world, + Self::selector(), + dojo::model::ModelIndex::MemberId((self.entity_id(), member_id)), + values, + field_layout + ) + }, + Option::None => core::panic_with_felt252('bad member id') + } + } + + #[inline(always)] + fn name() -> ByteArray { + "BadModelNotSupportedVersion" + } + + #[inline(always)] + fn namespace() -> ByteArray { + "dojo_test" + } + + #[inline(always)] + fn tag() -> ByteArray { + "dojo_test-BadModelNotSupportedVersion" + } + + #[inline(always)] + fn version() -> u8 { + 1 + } + + #[inline(always)] + fn selector() -> felt252 { + 3364830312705791335907422218790599751780160858399843169712719310945970157661 + } + + #[inline(always)] + fn instance_selector(self: @BadModelNotSupportedVersion) -> felt252 { + Self::selector() + } + + #[inline(always)] + fn name_hash() -> felt252 { + 1812257929012908024237871796629728977392496349235879470060252299886369485820 + } + + #[inline(always)] + fn namespace_hash() -> felt252 { + 1452123528942907587532668415362544424816022573043154497385993678618948064048 + } + + #[inline(always)] + fn entity_id(self: @BadModelNotSupportedVersion) -> felt252 { + core::poseidon::poseidon_hash_span(self.keys()) + } + + #[inline(always)] + fn keys(self: @BadModelNotSupportedVersion) -> Span { + let mut serialized = core::array::ArrayTrait::new(); + core::array::ArrayTrait::append(ref serialized, *self.id); + + core::array::ArrayTrait::span(@serialized) + } + + #[inline(always)] + fn values(self: @BadModelNotSupportedVersion) -> Span { + let mut serialized = core::array::ArrayTrait::new(); + core::serde::Serde::serialize(self.v, ref serialized); + + core::array::ArrayTrait::span(@serialized) + } + + #[inline(always)] + fn layout() -> dojo::model::Layout { + dojo::model::introspect::Introspect::::layout() + } + + #[inline(always)] + fn instance_layout(self: @BadModelNotSupportedVersion) -> dojo::model::Layout { + Self::layout() + } + + #[inline(always)] + fn packed_size() -> Option { + dojo::model::layout::compute_packed_size(Self::layout()) + } +} + +#[starknet::interface] +pub trait Ibad_model_not_supported_version { + fn ensure_abi(self: @T, model: BadModelNotSupportedVersion); +} + +#[starknet::contract] +pub mod bad_model_not_supported_version { + use super::BadModelNotSupportedVersion; + use super::Ibad_model_not_supported_version; + + #[abi(embed_v0)] + impl DojoModelImpl of dojo::model::IModel{ + fn name(self: @ContractState) -> ByteArray { + "BadModelNotSupportedVersion" + } + + fn namespace(self: @ContractState) -> ByteArray { + "dojo_test" + } + + fn tag(self: @ContractState) -> ByteArray { + "dojo_test-BadModelNotSupportedVersion" + } + + fn version(self: @ContractState) -> u8 { + 1 + } + + fn selector(self: @ContractState) -> felt252 { + 3364830312705791335907422218790599751780160858399843169712719310945970157661 + } + + fn name_hash(self: @ContractState) -> felt252 { + 1812257929012908024237871796629728977392496349235879470060252299886369485820 + } + + fn namespace_hash(self: @ContractState) -> felt252 { + 1452123528942907587532668415362544424816022573043154497385993678618948064048 + } + + fn unpacked_size(self: @ContractState) -> Option { + dojo::model::introspect::Introspect::::size() + } + + fn packed_size(self: @ContractState) -> Option { + dojo::model::Model::::packed_size() + } + + fn layout(self: @ContractState) -> dojo::model::Layout { + dojo::model::Model::::layout() + } + + fn schema(self: @ContractState) -> dojo::model::introspect::Ty { + dojo::model::introspect::Introspect::::ty() + } + } + + #[abi(embed_v0)] + impl bad_model_not_supported_versionImpl of Ibad_model_not_supported_version{ + fn ensure_abi(self: @ContractState, model: BadModelNotSupportedVersion) { + } + } +#[event] +#[derive(Drop, starknet::Event)] +pub enum Event {} + + +#[phantom] +pub struct Storage { +} + +#[derive(Drop, Copy)] +pub struct StorageStorageBase { +} +impl StorageStorageImpl of starknet::storage::StorageTrait { + type BaseType = StorageStorageBase; + fn storage(self: starknet::storage::FlattenedStorage) -> StorageStorageBase { + StorageStorageBase { + } + } +} +#[derive(Drop, Copy)] +pub struct StorageStorageBaseMut { +} +impl StorageStorageMutImpl of starknet::storage::StorageTraitMut { + type BaseType = StorageStorageBaseMut; + fn storage_mut(self: starknet::storage::FlattenedStorage>) -> StorageStorageBaseMut { + StorageStorageBaseMut { + } + } +} + +pub struct ContractState { +} + +impl ContractStateDrop of Drop {} + +impl ContractStateDeref of core::ops::SnapshotDeref { + type Target = starknet::storage::FlattenedStorage; + fn snapshot_deref(self: @ContractState) -> starknet::storage::FlattenedStorage { + starknet::storage::FlattenedStorage {} + } +} +impl ContractStateDerefMut of core::ops::DerefMut { + type Target = starknet::storage::FlattenedStorage> ; + fn deref_mut(ref self: ContractState) -> starknet::storage::FlattenedStorage> { + starknet::storage::FlattenedStorage {} + } +} +pub fn unsafe_new_contract_state() -> ContractState { + ContractState { + } +} + +// TODO(Gil): This generates duplicate diagnostics because of the plugin system, squash the duplicates into one. +#[deprecated( + feature: "deprecated_legacy_map", + note: "Use `starknet::storage::Map` instead." +)] +use starknet::storage::Map as LegacyMap; + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__DojoModelImpl__name(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = DojoModelImpl::name(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__DojoModelImpl__namespace(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = DojoModelImpl::namespace(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__DojoModelImpl__tag(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = DojoModelImpl::tag(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__DojoModelImpl__version(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = DojoModelImpl::version(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__DojoModelImpl__selector(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = DojoModelImpl::selector(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__DojoModelImpl__name_hash(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = DojoModelImpl::name_hash(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__DojoModelImpl__namespace_hash(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = DojoModelImpl::namespace_hash(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__DojoModelImpl__unpacked_size(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = DojoModelImpl::unpacked_size(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::>::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__DojoModelImpl__packed_size(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = DojoModelImpl::packed_size(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::>::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__DojoModelImpl__layout(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = DojoModelImpl::layout(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__DojoModelImpl__schema(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = DojoModelImpl::schema(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__bad_model_not_supported_versionImpl__ensure_abi(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + let __arg_model = core::option::OptionTraitImpl::expect( + core::serde::Serde::::deserialize(ref data), + 'Failed to deserialize param #1' + ); + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + bad_model_not_supported_versionImpl::ensure_abi(@contract_state, __arg_model); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::array::ArrayTrait::span(@arr) +} + + +pub mod __external { + pub use super::__wrapper__DojoModelImpl__name as name; + pub use super::__wrapper__DojoModelImpl__namespace as namespace; + pub use super::__wrapper__DojoModelImpl__tag as tag; + pub use super::__wrapper__DojoModelImpl__version as version; + pub use super::__wrapper__DojoModelImpl__selector as selector; + pub use super::__wrapper__DojoModelImpl__name_hash as name_hash; + pub use super::__wrapper__DojoModelImpl__namespace_hash as namespace_hash; + pub use super::__wrapper__DojoModelImpl__unpacked_size as unpacked_size; + pub use super::__wrapper__DojoModelImpl__packed_size as packed_size; + pub use super::__wrapper__DojoModelImpl__layout as layout; + pub use super::__wrapper__DojoModelImpl__schema as schema; + pub use super::__wrapper__bad_model_not_supported_versionImpl__ensure_abi as ensure_abi; +} +pub mod __l1_handler { +} +pub mod __constructor { +} + impl ContractStateEventEmitter of starknet::event::EventEmitter< + ContractState, Event + > { + fn emit>( + ref self: ContractState, event: S + ) { + let event: Event = core::traits::Into::into(event); + let mut keys = Default::::default(); + let mut data = Default::::default(); + starknet::Event::append_keys_and_data(@event, ref keys, ref data); + starknet::SyscallResultTrait::unwrap_syscall( + starknet::syscalls::emit_event_syscall( + core::array::ArrayTrait::span(@keys), + core::array::ArrayTrait::span(@data), + ) + ) + } + } +impl EventDrop of core::traits::Drop::; +impl EventIsEvent of starknet::Event { + fn append_keys_and_data( + self: @Event, ref keys: Array, ref data: Array + ) { + match self { + } + } + fn deserialize( + ref keys: Span, ref data: Span, + ) -> Option { + let __selector__ = *core::array::SpanTrait::pop_front(ref keys)?; + Option::None + } +} +impl StorageStorageBaseDrop of core::traits::Drop::; +impl StorageStorageBaseCopy of core::traits::Copy::; +impl StorageStorageBaseMutDrop of core::traits::Drop::; +impl StorageStorageBaseMutCopy of core::traits::Copy::; +} + +impl Modelv0Introspect<> of dojo::model::introspect::Introspect> { + #[inline(always)] + fn size() -> Option { + dojo::model::introspect::Introspect::::size() + } + + fn layout() -> dojo::model::Layout { + dojo::model::Layout::Struct( + array![ + dojo::model::FieldLayout { + selector: 578691550836206188651404750433984985630363913126316857592149308417275000080, + layout: dojo::model::introspect::Introspect::::layout() + } + ].span() + ) + } + + #[inline(always)] + fn ty() -> dojo::model::introspect::Ty { + dojo::model::introspect::Ty::Struct( + dojo::model::introspect::Struct { + name: 'Modelv0', + attrs: array![].span(), + children: array![ + dojo::model::introspect::Member { + name: 'id', + attrs: array!['key'].span(), + ty: dojo::model::introspect::Introspect::::ty() + }, +dojo::model::introspect::Member { + name: 'v', + attrs: array![].span(), + ty: dojo::model::introspect::Introspect::::ty() + } + + ].span() + } + ) + } +} + +#[derive(Drop, Serde)] +pub struct Modelv0Entity { + __id: felt252, // private field + pub v: Vec3, + +} + +#[generate_trait] +pub impl Modelv0EntityStoreImpl of Modelv0EntityStore { + fn get(world: dojo::world::IWorldDispatcher, entity_id: felt252) -> Modelv0Entity { + Modelv0ModelEntityImpl::get(world, entity_id) + } + + fn update(self: @Modelv0Entity, world: dojo::world::IWorldDispatcher) { + dojo::model::ModelEntity::::update_entity(self, world); + } + + fn delete(self: @Modelv0Entity, world: dojo::world::IWorldDispatcher) { + dojo::model::ModelEntity::::delete_entity(self, world); + } + + + fn get_v(world: dojo::world::IWorldDispatcher, entity_id: felt252) -> Vec3 { + let mut values = dojo::model::ModelEntity::::get_member( + world, + entity_id, + 578691550836206188651404750433984985630363913126316857592149308417275000080 + ); + let field_value = core::serde::Serde::::deserialize(ref values); + + if core::option::OptionTrait::::is_none(@field_value) { + panic!( + "Field `Modelv0::v`: deserialization failed." + ); + } + + core::option::OptionTrait::::unwrap(field_value) + } + + fn set_v(self: @Modelv0Entity, world: dojo::world::IWorldDispatcher, value: Vec3) { + let mut serialized = core::array::ArrayTrait::new(); + core::serde::Serde::serialize(@value, ref serialized); + + self.set_member( + world, + 578691550836206188651404750433984985630363913126316857592149308417275000080, + serialized.span() + ); + } + +} + +#[generate_trait] +pub impl Modelv0StoreImpl of Modelv0Store { + fn entity_id_from_keys(id: felt252) -> felt252 { + let mut serialized = core::array::ArrayTrait::new(); + core::array::ArrayTrait::append(ref serialized, id); + + core::poseidon::poseidon_hash_span(serialized.span()) + } + + fn from_values(ref keys: Span, ref values: Span) -> Modelv0 { + let mut serialized = core::array::ArrayTrait::new(); + serialized.append_span(keys); + serialized.append_span(values); + let mut serialized = core::array::ArrayTrait::span(@serialized); + + let entity = core::serde::Serde::::deserialize(ref serialized); + + if core::option::OptionTrait::::is_none(@entity) { + panic!( + "Model `Modelv0`: deserialization failed. Ensure the length of the keys tuple is matching the number of #[key] fields in the model struct." + ); + } + + core::option::OptionTrait::::unwrap(entity) + } + + fn get(world: dojo::world::IWorldDispatcher, id: felt252) -> Modelv0 { + let mut serialized = core::array::ArrayTrait::new(); + core::array::ArrayTrait::append(ref serialized, id); + + + dojo::model::Model::::get(world, serialized.span()) + } + + fn set(self: @Modelv0, world: dojo::world::IWorldDispatcher) { + dojo::model::Model::::set_model(self, world); + } + + fn delete(self: @Modelv0, world: dojo::world::IWorldDispatcher) { + dojo::model::Model::::delete_model(self, world); + } + + + fn get_v(world: dojo::world::IWorldDispatcher, id: felt252) -> Vec3 { + let mut serialized = core::array::ArrayTrait::new(); + core::array::ArrayTrait::append(ref serialized, id); + + + let mut values = dojo::model::Model::::get_member( + world, + serialized.span(), + 578691550836206188651404750433984985630363913126316857592149308417275000080 + ); + + let field_value = core::serde::Serde::::deserialize(ref values); + + if core::option::OptionTrait::::is_none(@field_value) { + panic!( + "Field `Modelv0::v`: deserialization failed." + ); + } + + core::option::OptionTrait::::unwrap(field_value) + } + + fn set_v(self: @Modelv0, world: dojo::world::IWorldDispatcher, value: Vec3) { + let mut serialized = core::array::ArrayTrait::new(); + core::serde::Serde::serialize(@value, ref serialized); + + self.set_member( + world, + 578691550836206188651404750433984985630363913126316857592149308417275000080, + serialized.span() + ); + } + +} + +pub impl Modelv0ModelEntityImpl of dojo::model::ModelEntity { + fn id(self: @Modelv0Entity) -> felt252 { + *self.__id + } + + fn values(self: @Modelv0Entity) -> Span { + let mut serialized = core::array::ArrayTrait::new(); + core::serde::Serde::serialize(self.v, ref serialized); + + core::array::ArrayTrait::span(@serialized) + } + + fn from_values(entity_id: felt252, ref values: Span) -> Modelv0Entity { + let mut serialized = array![entity_id]; + serialized.append_span(values); + let mut serialized = core::array::ArrayTrait::span(@serialized); + + let entity_values = core::serde::Serde::::deserialize(ref serialized); + if core::option::OptionTrait::::is_none(@entity_values) { + panic!( + "ModelEntity `Modelv0Entity`: deserialization failed." + ); + } + core::option::OptionTrait::::unwrap(entity_values) + } + + fn get(world: dojo::world::IWorldDispatcher, entity_id: felt252) -> Modelv0Entity { + let mut values = dojo::world::IWorldDispatcherTrait::entity( + world, + dojo::model::Model::::selector(), + dojo::model::ModelIndex::Id(entity_id), + dojo::model::Model::::layout() + ); + Self::from_values(entity_id, ref values) + } + + fn update_entity(self: @Modelv0Entity, world: dojo::world::IWorldDispatcher) { + dojo::world::IWorldDispatcherTrait::set_entity( + world, + dojo::model::Model::::selector(), + dojo::model::ModelIndex::Id(self.id()), + self.values(), + dojo::model::Model::::layout() + ); + } + + fn delete_entity(self: @Modelv0Entity, world: dojo::world::IWorldDispatcher) { + dojo::world::IWorldDispatcherTrait::delete_entity( + world, + dojo::model::Model::::selector(), + dojo::model::ModelIndex::Id(self.id()), + dojo::model::Model::::layout() + ); + } + + fn get_member( + world: dojo::world::IWorldDispatcher, + entity_id: felt252, + member_id: felt252, + ) -> Span { + match dojo::utils::find_model_field_layout(dojo::model::Model::::layout(), member_id) { + Option::Some(field_layout) => { + dojo::world::IWorldDispatcherTrait::entity( + world, + dojo::model::Model::::selector(), + dojo::model::ModelIndex::MemberId((entity_id, member_id)), + field_layout + ) + }, + Option::None => core::panic_with_felt252('bad member id') + } + } + + fn set_member( + self: @Modelv0Entity, + world: dojo::world::IWorldDispatcher, + member_id: felt252, + values: Span, + ) { + match dojo::utils::find_model_field_layout(dojo::model::Model::::layout(), member_id) { + Option::Some(field_layout) => { + dojo::world::IWorldDispatcherTrait::set_entity( + world, + dojo::model::Model::::selector(), + dojo::model::ModelIndex::MemberId((self.id(), member_id)), + values, + field_layout + ) + }, + Option::None => core::panic_with_felt252('bad member id') + } + } +} + +pub impl Modelv0ModelImpl of dojo::model::Model { + fn get(world: dojo::world::IWorldDispatcher, keys: Span) -> Modelv0 { + let mut values = dojo::world::IWorldDispatcherTrait::entity( + world, + Self::selector(), + dojo::model::ModelIndex::Keys(keys), + Self::layout() + ); + let mut _keys = keys; + + Modelv0Store::from_values(ref _keys, ref values) + } + + fn set_model( + self: @Modelv0, + world: dojo::world::IWorldDispatcher + ) { + dojo::world::IWorldDispatcherTrait::set_entity( + world, + Self::selector(), + dojo::model::ModelIndex::Keys(Self::keys(self)), + Self::values(self), + Self::layout() + ); + } + + fn delete_model( + self: @Modelv0, + world: dojo::world::IWorldDispatcher + ) { + dojo::world::IWorldDispatcherTrait::delete_entity( + world, + Self::selector(), + dojo::model::ModelIndex::Keys(Self::keys(self)), + Self::layout() + ); + } + + fn get_member( + world: dojo::world::IWorldDispatcher, + keys: Span, + member_id: felt252 + ) -> Span { + match dojo::utils::find_model_field_layout(Self::layout(), member_id) { + Option::Some(field_layout) => { + let entity_id = dojo::utils::entity_id_from_keys(keys); + dojo::world::IWorldDispatcherTrait::entity( + world, + Self::selector(), + dojo::model::ModelIndex::MemberId((entity_id, member_id)), + field_layout + ) + }, + Option::None => core::panic_with_felt252('bad member id') + } + } + + fn set_member( + self: @Modelv0, + world: dojo::world::IWorldDispatcher, + member_id: felt252, + values: Span + ) { + match dojo::utils::find_model_field_layout(Self::layout(), member_id) { + Option::Some(field_layout) => { + dojo::world::IWorldDispatcherTrait::set_entity( + world, + Self::selector(), + dojo::model::ModelIndex::MemberId((self.entity_id(), member_id)), + values, + field_layout + ) + }, + Option::None => core::panic_with_felt252('bad member id') + } + } + + #[inline(always)] + fn name() -> ByteArray { + "Modelv0" + } + + #[inline(always)] + fn namespace() -> ByteArray { + "dojo_test" + } + + #[inline(always)] + fn tag() -> ByteArray { + "dojo_test-Modelv0" + } + + #[inline(always)] + fn version() -> u8 { + 0 + } + + #[inline(always)] + fn selector() -> felt252 { + "Modelv0" + } + + #[inline(always)] + fn instance_selector(self: @Modelv0) -> felt252 { + Self::selector() + } + + #[inline(always)] + fn name_hash() -> felt252 { + 2212879130471315306779111820244908968466545702031328551192231795237740448313 + } + + #[inline(always)] + fn namespace_hash() -> felt252 { + 1452123528942907587532668415362544424816022573043154497385993678618948064048 + } + + #[inline(always)] + fn entity_id(self: @Modelv0) -> felt252 { + core::poseidon::poseidon_hash_span(self.keys()) + } + + #[inline(always)] + fn keys(self: @Modelv0) -> Span { + let mut serialized = core::array::ArrayTrait::new(); + core::array::ArrayTrait::append(ref serialized, *self.id); + + core::array::ArrayTrait::span(@serialized) + } + + #[inline(always)] + fn values(self: @Modelv0) -> Span { + let mut serialized = core::array::ArrayTrait::new(); + core::serde::Serde::serialize(self.v, ref serialized); + + core::array::ArrayTrait::span(@serialized) + } + + #[inline(always)] + fn layout() -> dojo::model::Layout { + dojo::model::introspect::Introspect::::layout() + } + + #[inline(always)] + fn instance_layout(self: @Modelv0) -> dojo::model::Layout { + Self::layout() + } + + #[inline(always)] + fn packed_size() -> Option { + dojo::model::layout::compute_packed_size(Self::layout()) + } +} + +#[starknet::interface] +pub trait Imodelv_0 { + fn ensure_abi(self: @T, model: Modelv0); +} + +#[starknet::contract] +pub mod modelv_0 { + use super::Modelv0; + use super::Imodelv_0; + + #[abi(embed_v0)] + impl DojoModelImpl of dojo::model::IModel{ + fn name(self: @ContractState) -> ByteArray { + "Modelv0" + } + + fn namespace(self: @ContractState) -> ByteArray { + "dojo_test" + } + + fn tag(self: @ContractState) -> ByteArray { + "dojo_test-Modelv0" + } + + fn version(self: @ContractState) -> u8 { + 0 + } + + fn selector(self: @ContractState) -> felt252 { + "Modelv0" + } + + fn name_hash(self: @ContractState) -> felt252 { + 2212879130471315306779111820244908968466545702031328551192231795237740448313 + } + + fn namespace_hash(self: @ContractState) -> felt252 { + 1452123528942907587532668415362544424816022573043154497385993678618948064048 + } + + fn unpacked_size(self: @ContractState) -> Option { + dojo::model::introspect::Introspect::::size() + } + + fn packed_size(self: @ContractState) -> Option { + dojo::model::Model::::packed_size() + } + + fn layout(self: @ContractState) -> dojo::model::Layout { + dojo::model::Model::::layout() + } + + fn schema(self: @ContractState) -> dojo::model::introspect::Ty { + dojo::model::introspect::Introspect::::ty() + } + } + + #[abi(embed_v0)] + impl modelv_0Impl of Imodelv_0{ + fn ensure_abi(self: @ContractState, model: Modelv0) { + } + } +#[event] +#[derive(Drop, starknet::Event)] +pub enum Event {} + + +#[phantom] +pub struct Storage { +} + +#[derive(Drop, Copy)] +pub struct StorageStorageBase { +} +impl StorageStorageImpl of starknet::storage::StorageTrait { + type BaseType = StorageStorageBase; + fn storage(self: starknet::storage::FlattenedStorage) -> StorageStorageBase { + StorageStorageBase { + } + } +} +#[derive(Drop, Copy)] +pub struct StorageStorageBaseMut { +} +impl StorageStorageMutImpl of starknet::storage::StorageTraitMut { + type BaseType = StorageStorageBaseMut; + fn storage_mut(self: starknet::storage::FlattenedStorage>) -> StorageStorageBaseMut { + StorageStorageBaseMut { + } + } +} + +pub struct ContractState { +} + +impl ContractStateDrop of Drop {} + +impl ContractStateDeref of core::ops::SnapshotDeref { + type Target = starknet::storage::FlattenedStorage; + fn snapshot_deref(self: @ContractState) -> starknet::storage::FlattenedStorage { + starknet::storage::FlattenedStorage {} + } +} +impl ContractStateDerefMut of core::ops::DerefMut { + type Target = starknet::storage::FlattenedStorage> ; + fn deref_mut(ref self: ContractState) -> starknet::storage::FlattenedStorage> { + starknet::storage::FlattenedStorage {} + } +} +pub fn unsafe_new_contract_state() -> ContractState { + ContractState { + } +} + +// TODO(Gil): This generates duplicate diagnostics because of the plugin system, squash the duplicates into one. +#[deprecated( + feature: "deprecated_legacy_map", + note: "Use `starknet::storage::Map` instead." +)] +use starknet::storage::Map as LegacyMap; + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__DojoModelImpl__name(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = DojoModelImpl::name(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__DojoModelImpl__namespace(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = DojoModelImpl::namespace(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__DojoModelImpl__tag(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = DojoModelImpl::tag(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__DojoModelImpl__version(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = DojoModelImpl::version(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__DojoModelImpl__selector(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = DojoModelImpl::selector(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__DojoModelImpl__name_hash(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = DojoModelImpl::name_hash(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__DojoModelImpl__namespace_hash(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = DojoModelImpl::namespace_hash(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__DojoModelImpl__unpacked_size(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = DojoModelImpl::unpacked_size(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::>::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__DojoModelImpl__packed_size(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = DojoModelImpl::packed_size(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::>::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__DojoModelImpl__layout(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = DojoModelImpl::layout(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__DojoModelImpl__schema(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = DojoModelImpl::schema(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__modelv_0Impl__ensure_abi(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + let __arg_model = core::option::OptionTraitImpl::expect( + core::serde::Serde::::deserialize(ref data), + 'Failed to deserialize param #1' + ); + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + modelv_0Impl::ensure_abi(@contract_state, __arg_model); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::array::ArrayTrait::span(@arr) +} + + +pub mod __external { + pub use super::__wrapper__DojoModelImpl__name as name; + pub use super::__wrapper__DojoModelImpl__namespace as namespace; + pub use super::__wrapper__DojoModelImpl__tag as tag; + pub use super::__wrapper__DojoModelImpl__version as version; + pub use super::__wrapper__DojoModelImpl__selector as selector; + pub use super::__wrapper__DojoModelImpl__name_hash as name_hash; + pub use super::__wrapper__DojoModelImpl__namespace_hash as namespace_hash; + pub use super::__wrapper__DojoModelImpl__unpacked_size as unpacked_size; + pub use super::__wrapper__DojoModelImpl__packed_size as packed_size; + pub use super::__wrapper__DojoModelImpl__layout as layout; + pub use super::__wrapper__DojoModelImpl__schema as schema; + pub use super::__wrapper__modelv_0Impl__ensure_abi as ensure_abi; +} +pub mod __l1_handler { +} +pub mod __constructor { +} + impl ContractStateEventEmitter of starknet::event::EventEmitter< + ContractState, Event + > { + fn emit>( + ref self: ContractState, event: S + ) { + let event: Event = core::traits::Into::into(event); + let mut keys = Default::::default(); + let mut data = Default::::default(); + starknet::Event::append_keys_and_data(@event, ref keys, ref data); + starknet::SyscallResultTrait::unwrap_syscall( + starknet::syscalls::emit_event_syscall( + core::array::ArrayTrait::span(@keys), + core::array::ArrayTrait::span(@data), + ) + ) + } + } +impl EventDrop of core::traits::Drop::; +impl EventIsEvent of starknet::Event { + fn append_keys_and_data( + self: @Event, ref keys: Array, ref data: Array + ) { + match self { + } + } + fn deserialize( + ref keys: Span, ref data: Span, + ) -> Option { + let __selector__ = *core::array::SpanTrait::pop_front(ref keys)?; + Option::None + } +} +impl StorageStorageBaseDrop of core::traits::Drop::; +impl StorageStorageBaseCopy of core::traits::Copy::; +impl StorageStorageBaseMutDrop of core::traits::Drop::; +impl StorageStorageBaseMutCopy of core::traits::Copy::; +} + +impl ModelWithBadNamespaceFormatIntrospect<> of dojo::model::introspect::Introspect> { + #[inline(always)] + fn size() -> Option { + dojo::model::introspect::Introspect::::size() + } + + fn layout() -> dojo::model::Layout { + dojo::model::Layout::Struct( + array![ + dojo::model::FieldLayout { + selector: 578691550836206188651404750433984985630363913126316857592149308417275000080, + layout: dojo::model::introspect::Introspect::::layout() + } + ].span() + ) + } + + #[inline(always)] + fn ty() -> dojo::model::introspect::Ty { + dojo::model::introspect::Ty::Struct( + dojo::model::introspect::Struct { + name: 'ModelWithBadNamespaceFormat', + attrs: array![].span(), + children: array![ + dojo::model::introspect::Member { + name: 'id', + attrs: array!['key'].span(), + ty: dojo::model::introspect::Introspect::::ty() + }, +dojo::model::introspect::Member { + name: 'v', + attrs: array![].span(), + ty: dojo::model::introspect::Introspect::::ty() + } + + ].span() + } + ) + } +} + +#[derive(Drop, Serde)] +pub struct ModelWithBadNamespaceFormatEntity { + __id: felt252, // private field + pub v: Vec3, + +} + +#[generate_trait] +pub impl ModelWithBadNamespaceFormatEntityStoreImpl of ModelWithBadNamespaceFormatEntityStore { + fn get(world: dojo::world::IWorldDispatcher, entity_id: felt252) -> ModelWithBadNamespaceFormatEntity { + ModelWithBadNamespaceFormatModelEntityImpl::get(world, entity_id) + } + + fn update(self: @ModelWithBadNamespaceFormatEntity, world: dojo::world::IWorldDispatcher) { + dojo::model::ModelEntity::::update_entity(self, world); + } + + fn delete(self: @ModelWithBadNamespaceFormatEntity, world: dojo::world::IWorldDispatcher) { + dojo::model::ModelEntity::::delete_entity(self, world); + } + + + fn get_v(world: dojo::world::IWorldDispatcher, entity_id: felt252) -> Vec3 { + let mut values = dojo::model::ModelEntity::::get_member( + world, + entity_id, + 578691550836206188651404750433984985630363913126316857592149308417275000080 + ); + let field_value = core::serde::Serde::::deserialize(ref values); + + if core::option::OptionTrait::::is_none(@field_value) { + panic!( + "Field `ModelWithBadNamespaceFormat::v`: deserialization failed." + ); + } + + core::option::OptionTrait::::unwrap(field_value) + } + + fn set_v(self: @ModelWithBadNamespaceFormatEntity, world: dojo::world::IWorldDispatcher, value: Vec3) { + let mut serialized = core::array::ArrayTrait::new(); + core::serde::Serde::serialize(@value, ref serialized); + + self.set_member( + world, + 578691550836206188651404750433984985630363913126316857592149308417275000080, + serialized.span() + ); + } + +} + +#[generate_trait] +pub impl ModelWithBadNamespaceFormatStoreImpl of ModelWithBadNamespaceFormatStore { + fn entity_id_from_keys(id: felt252) -> felt252 { + let mut serialized = core::array::ArrayTrait::new(); + core::array::ArrayTrait::append(ref serialized, id); + + core::poseidon::poseidon_hash_span(serialized.span()) + } + + fn from_values(ref keys: Span, ref values: Span) -> ModelWithBadNamespaceFormat { + let mut serialized = core::array::ArrayTrait::new(); + serialized.append_span(keys); + serialized.append_span(values); + let mut serialized = core::array::ArrayTrait::span(@serialized); + + let entity = core::serde::Serde::::deserialize(ref serialized); + + if core::option::OptionTrait::::is_none(@entity) { + panic!( + "Model `ModelWithBadNamespaceFormat`: deserialization failed. Ensure the length of the keys tuple is matching the number of #[key] fields in the model struct." + ); + } + + core::option::OptionTrait::::unwrap(entity) + } + + fn get(world: dojo::world::IWorldDispatcher, id: felt252) -> ModelWithBadNamespaceFormat { + let mut serialized = core::array::ArrayTrait::new(); + core::array::ArrayTrait::append(ref serialized, id); + + + dojo::model::Model::::get(world, serialized.span()) + } + + fn set(self: @ModelWithBadNamespaceFormat, world: dojo::world::IWorldDispatcher) { + dojo::model::Model::::set_model(self, world); + } + + fn delete(self: @ModelWithBadNamespaceFormat, world: dojo::world::IWorldDispatcher) { + dojo::model::Model::::delete_model(self, world); + } + + + fn get_v(world: dojo::world::IWorldDispatcher, id: felt252) -> Vec3 { + let mut serialized = core::array::ArrayTrait::new(); + core::array::ArrayTrait::append(ref serialized, id); + + + let mut values = dojo::model::Model::::get_member( + world, + serialized.span(), + 578691550836206188651404750433984985630363913126316857592149308417275000080 + ); + + let field_value = core::serde::Serde::::deserialize(ref values); + + if core::option::OptionTrait::::is_none(@field_value) { + panic!( + "Field `ModelWithBadNamespaceFormat::v`: deserialization failed." + ); + } + + core::option::OptionTrait::::unwrap(field_value) + } + + fn set_v(self: @ModelWithBadNamespaceFormat, world: dojo::world::IWorldDispatcher, value: Vec3) { + let mut serialized = core::array::ArrayTrait::new(); + core::serde::Serde::serialize(@value, ref serialized); + + self.set_member( + world, + 578691550836206188651404750433984985630363913126316857592149308417275000080, + serialized.span() + ); + } + +} + +pub impl ModelWithBadNamespaceFormatModelEntityImpl of dojo::model::ModelEntity { + fn id(self: @ModelWithBadNamespaceFormatEntity) -> felt252 { + *self.__id + } + + fn values(self: @ModelWithBadNamespaceFormatEntity) -> Span { + let mut serialized = core::array::ArrayTrait::new(); + core::serde::Serde::serialize(self.v, ref serialized); + + core::array::ArrayTrait::span(@serialized) + } + + fn from_values(entity_id: felt252, ref values: Span) -> ModelWithBadNamespaceFormatEntity { + let mut serialized = array![entity_id]; + serialized.append_span(values); + let mut serialized = core::array::ArrayTrait::span(@serialized); + + let entity_values = core::serde::Serde::::deserialize(ref serialized); + if core::option::OptionTrait::::is_none(@entity_values) { + panic!( + "ModelEntity `ModelWithBadNamespaceFormatEntity`: deserialization failed." + ); + } + core::option::OptionTrait::::unwrap(entity_values) + } + + fn get(world: dojo::world::IWorldDispatcher, entity_id: felt252) -> ModelWithBadNamespaceFormatEntity { + let mut values = dojo::world::IWorldDispatcherTrait::entity( + world, + dojo::model::Model::::selector(), + dojo::model::ModelIndex::Id(entity_id), + dojo::model::Model::::layout() + ); + Self::from_values(entity_id, ref values) + } + + fn update_entity(self: @ModelWithBadNamespaceFormatEntity, world: dojo::world::IWorldDispatcher) { + dojo::world::IWorldDispatcherTrait::set_entity( + world, + dojo::model::Model::::selector(), + dojo::model::ModelIndex::Id(self.id()), + self.values(), + dojo::model::Model::::layout() + ); + } + + fn delete_entity(self: @ModelWithBadNamespaceFormatEntity, world: dojo::world::IWorldDispatcher) { + dojo::world::IWorldDispatcherTrait::delete_entity( + world, + dojo::model::Model::::selector(), + dojo::model::ModelIndex::Id(self.id()), + dojo::model::Model::::layout() + ); + } + + fn get_member( + world: dojo::world::IWorldDispatcher, + entity_id: felt252, + member_id: felt252, + ) -> Span { + match dojo::utils::find_model_field_layout(dojo::model::Model::::layout(), member_id) { + Option::Some(field_layout) => { + dojo::world::IWorldDispatcherTrait::entity( + world, + dojo::model::Model::::selector(), + dojo::model::ModelIndex::MemberId((entity_id, member_id)), + field_layout + ) + }, + Option::None => core::panic_with_felt252('bad member id') + } + } + + fn set_member( + self: @ModelWithBadNamespaceFormatEntity, + world: dojo::world::IWorldDispatcher, + member_id: felt252, + values: Span, + ) { + match dojo::utils::find_model_field_layout(dojo::model::Model::::layout(), member_id) { + Option::Some(field_layout) => { + dojo::world::IWorldDispatcherTrait::set_entity( + world, + dojo::model::Model::::selector(), + dojo::model::ModelIndex::MemberId((self.id(), member_id)), + values, + field_layout + ) + }, + Option::None => core::panic_with_felt252('bad member id') + } + } +} + +pub impl ModelWithBadNamespaceFormatModelImpl of dojo::model::Model { + fn get(world: dojo::world::IWorldDispatcher, keys: Span) -> ModelWithBadNamespaceFormat { + let mut values = dojo::world::IWorldDispatcherTrait::entity( + world, + Self::selector(), + dojo::model::ModelIndex::Keys(keys), + Self::layout() + ); + let mut _keys = keys; + + ModelWithBadNamespaceFormatStore::from_values(ref _keys, ref values) + } + + fn set_model( + self: @ModelWithBadNamespaceFormat, + world: dojo::world::IWorldDispatcher + ) { + dojo::world::IWorldDispatcherTrait::set_entity( + world, + Self::selector(), + dojo::model::ModelIndex::Keys(Self::keys(self)), + Self::values(self), + Self::layout() + ); + } + + fn delete_model( + self: @ModelWithBadNamespaceFormat, + world: dojo::world::IWorldDispatcher + ) { + dojo::world::IWorldDispatcherTrait::delete_entity( + world, + Self::selector(), + dojo::model::ModelIndex::Keys(Self::keys(self)), + Self::layout() + ); + } + + fn get_member( + world: dojo::world::IWorldDispatcher, + keys: Span, + member_id: felt252 + ) -> Span { + match dojo::utils::find_model_field_layout(Self::layout(), member_id) { + Option::Some(field_layout) => { + let entity_id = dojo::utils::entity_id_from_keys(keys); + dojo::world::IWorldDispatcherTrait::entity( + world, + Self::selector(), + dojo::model::ModelIndex::MemberId((entity_id, member_id)), + field_layout + ) + }, + Option::None => core::panic_with_felt252('bad member id') + } + } + + fn set_member( + self: @ModelWithBadNamespaceFormat, + world: dojo::world::IWorldDispatcher, + member_id: felt252, + values: Span + ) { + match dojo::utils::find_model_field_layout(Self::layout(), member_id) { + Option::Some(field_layout) => { + dojo::world::IWorldDispatcherTrait::set_entity( + world, + Self::selector(), + dojo::model::ModelIndex::MemberId((self.entity_id(), member_id)), + values, + field_layout + ) + }, + Option::None => core::panic_with_felt252('bad member id') + } + } + + #[inline(always)] + fn name() -> ByteArray { + "ModelWithBadNamespaceFormat" + } + + #[inline(always)] + fn namespace() -> ByteArray { + "dojo_test" + } + + #[inline(always)] + fn tag() -> ByteArray { + "dojo_test-ModelWithBadNamespaceFormat" + } + + #[inline(always)] + fn version() -> u8 { + 1 + } + + #[inline(always)] + fn selector() -> felt252 { + 3339335350336894195883884955409923858499485801033572582237787132047489035817 + } + + #[inline(always)] + fn instance_selector(self: @ModelWithBadNamespaceFormat) -> felt252 { + Self::selector() + } + + #[inline(always)] + fn name_hash() -> felt252 { + 513559242384681567568052881519197161166285694153303371154270254637843894159 + } + + #[inline(always)] + fn namespace_hash() -> felt252 { + 1452123528942907587532668415362544424816022573043154497385993678618948064048 + } + + #[inline(always)] + fn entity_id(self: @ModelWithBadNamespaceFormat) -> felt252 { + core::poseidon::poseidon_hash_span(self.keys()) + } + + #[inline(always)] + fn keys(self: @ModelWithBadNamespaceFormat) -> Span { + let mut serialized = core::array::ArrayTrait::new(); + core::array::ArrayTrait::append(ref serialized, *self.id); + + core::array::ArrayTrait::span(@serialized) + } + + #[inline(always)] + fn values(self: @ModelWithBadNamespaceFormat) -> Span { + let mut serialized = core::array::ArrayTrait::new(); + core::serde::Serde::serialize(self.v, ref serialized); + + core::array::ArrayTrait::span(@serialized) + } + + #[inline(always)] + fn layout() -> dojo::model::Layout { + dojo::model::introspect::Introspect::::layout() + } + + #[inline(always)] + fn instance_layout(self: @ModelWithBadNamespaceFormat) -> dojo::model::Layout { + Self::layout() + } + + #[inline(always)] + fn packed_size() -> Option { + dojo::model::layout::compute_packed_size(Self::layout()) + } +} + +#[starknet::interface] +pub trait Imodel_with_bad_namespace_format { + fn ensure_abi(self: @T, model: ModelWithBadNamespaceFormat); +} + +#[starknet::contract] +pub mod model_with_bad_namespace_format { + use super::ModelWithBadNamespaceFormat; + use super::Imodel_with_bad_namespace_format; + + #[abi(embed_v0)] + impl DojoModelImpl of dojo::model::IModel{ + fn name(self: @ContractState) -> ByteArray { + "ModelWithBadNamespaceFormat" + } + + fn namespace(self: @ContractState) -> ByteArray { + "dojo_test" + } + + fn tag(self: @ContractState) -> ByteArray { + "dojo_test-ModelWithBadNamespaceFormat" + } + + fn version(self: @ContractState) -> u8 { + 1 + } + + fn selector(self: @ContractState) -> felt252 { + 3339335350336894195883884955409923858499485801033572582237787132047489035817 + } + + fn name_hash(self: @ContractState) -> felt252 { + 513559242384681567568052881519197161166285694153303371154270254637843894159 + } + + fn namespace_hash(self: @ContractState) -> felt252 { + 1452123528942907587532668415362544424816022573043154497385993678618948064048 + } + + fn unpacked_size(self: @ContractState) -> Option { + dojo::model::introspect::Introspect::::size() + } + + fn packed_size(self: @ContractState) -> Option { + dojo::model::Model::::packed_size() + } + + fn layout(self: @ContractState) -> dojo::model::Layout { + dojo::model::Model::::layout() + } + + fn schema(self: @ContractState) -> dojo::model::introspect::Ty { + dojo::model::introspect::Introspect::::ty() + } + } + + #[abi(embed_v0)] + impl model_with_bad_namespace_formatImpl of Imodel_with_bad_namespace_format{ + fn ensure_abi(self: @ContractState, model: ModelWithBadNamespaceFormat) { + } + } +#[event] +#[derive(Drop, starknet::Event)] +pub enum Event {} + + +#[phantom] +pub struct Storage { +} + +#[derive(Drop, Copy)] +pub struct StorageStorageBase { +} +impl StorageStorageImpl of starknet::storage::StorageTrait { + type BaseType = StorageStorageBase; + fn storage(self: starknet::storage::FlattenedStorage) -> StorageStorageBase { + StorageStorageBase { + } + } +} +#[derive(Drop, Copy)] +pub struct StorageStorageBaseMut { +} +impl StorageStorageMutImpl of starknet::storage::StorageTraitMut { + type BaseType = StorageStorageBaseMut; + fn storage_mut(self: starknet::storage::FlattenedStorage>) -> StorageStorageBaseMut { + StorageStorageBaseMut { + } + } +} + +pub struct ContractState { +} + +impl ContractStateDrop of Drop {} + +impl ContractStateDeref of core::ops::SnapshotDeref { + type Target = starknet::storage::FlattenedStorage; + fn snapshot_deref(self: @ContractState) -> starknet::storage::FlattenedStorage { + starknet::storage::FlattenedStorage {} + } +} +impl ContractStateDerefMut of core::ops::DerefMut { + type Target = starknet::storage::FlattenedStorage> ; + fn deref_mut(ref self: ContractState) -> starknet::storage::FlattenedStorage> { + starknet::storage::FlattenedStorage {} + } +} +pub fn unsafe_new_contract_state() -> ContractState { + ContractState { + } +} + +// TODO(Gil): This generates duplicate diagnostics because of the plugin system, squash the duplicates into one. +#[deprecated( + feature: "deprecated_legacy_map", + note: "Use `starknet::storage::Map` instead." +)] +use starknet::storage::Map as LegacyMap; + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__DojoModelImpl__name(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = DojoModelImpl::name(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__DojoModelImpl__namespace(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = DojoModelImpl::namespace(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__DojoModelImpl__tag(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = DojoModelImpl::tag(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__DojoModelImpl__version(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = DojoModelImpl::version(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__DojoModelImpl__selector(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = DojoModelImpl::selector(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__DojoModelImpl__name_hash(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = DojoModelImpl::name_hash(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__DojoModelImpl__namespace_hash(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = DojoModelImpl::namespace_hash(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__DojoModelImpl__unpacked_size(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = DojoModelImpl::unpacked_size(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::>::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__DojoModelImpl__packed_size(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = DojoModelImpl::packed_size(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::>::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__DojoModelImpl__layout(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = DojoModelImpl::layout(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__DojoModelImpl__schema(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = DojoModelImpl::schema(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__model_with_bad_namespace_formatImpl__ensure_abi(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + let __arg_model = core::option::OptionTraitImpl::expect( + core::serde::Serde::::deserialize(ref data), + 'Failed to deserialize param #1' + ); + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + model_with_bad_namespace_formatImpl::ensure_abi(@contract_state, __arg_model); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::array::ArrayTrait::span(@arr) +} + + +pub mod __external { + pub use super::__wrapper__DojoModelImpl__name as name; + pub use super::__wrapper__DojoModelImpl__namespace as namespace; + pub use super::__wrapper__DojoModelImpl__tag as tag; + pub use super::__wrapper__DojoModelImpl__version as version; + pub use super::__wrapper__DojoModelImpl__selector as selector; + pub use super::__wrapper__DojoModelImpl__name_hash as name_hash; + pub use super::__wrapper__DojoModelImpl__namespace_hash as namespace_hash; + pub use super::__wrapper__DojoModelImpl__unpacked_size as unpacked_size; + pub use super::__wrapper__DojoModelImpl__packed_size as packed_size; + pub use super::__wrapper__DojoModelImpl__layout as layout; + pub use super::__wrapper__DojoModelImpl__schema as schema; + pub use super::__wrapper__model_with_bad_namespace_formatImpl__ensure_abi as ensure_abi; +} +pub mod __l1_handler { +} +pub mod __constructor { +} + impl ContractStateEventEmitter of starknet::event::EventEmitter< + ContractState, Event + > { + fn emit>( + ref self: ContractState, event: S + ) { + let event: Event = core::traits::Into::into(event); + let mut keys = Default::::default(); + let mut data = Default::::default(); + starknet::Event::append_keys_and_data(@event, ref keys, ref data); + starknet::SyscallResultTrait::unwrap_syscall( + starknet::syscalls::emit_event_syscall( + core::array::ArrayTrait::span(@keys), + core::array::ArrayTrait::span(@data), + ) + ) + } + } +impl EventDrop of core::traits::Drop::; +impl EventIsEvent of starknet::Event { + fn append_keys_and_data( + self: @Event, ref keys: Array, ref data: Array + ) { + match self { + } + } + fn deserialize( + ref keys: Span, ref data: Span, + ) -> Option { + let __selector__ = *core::array::SpanTrait::pop_front(ref keys)?; + Option::None + } +} +impl StorageStorageBaseDrop of core::traits::Drop::; +impl StorageStorageBaseCopy of core::traits::Copy::; +impl StorageStorageBaseMutDrop of core::traits::Drop::; +impl StorageStorageBaseMutCopy of core::traits::Copy::; +} + +impl ModelWithShortStringNamespaceIntrospect<> of dojo::model::introspect::Introspect> { + #[inline(always)] + fn size() -> Option { + dojo::model::introspect::Introspect::::size() + } + + fn layout() -> dojo::model::Layout { + dojo::model::Layout::Struct( + array![ + dojo::model::FieldLayout { + selector: 578691550836206188651404750433984985630363913126316857592149308417275000080, + layout: dojo::model::introspect::Introspect::::layout() + } + ].span() + ) + } + + #[inline(always)] + fn ty() -> dojo::model::introspect::Ty { + dojo::model::introspect::Ty::Struct( + dojo::model::introspect::Struct { + name: 'ModelWithShortStringNamespace', + attrs: array![].span(), + children: array![ + dojo::model::introspect::Member { + name: 'id', + attrs: array!['key'].span(), + ty: dojo::model::introspect::Introspect::::ty() + }, +dojo::model::introspect::Member { + name: 'v', + attrs: array![].span(), + ty: dojo::model::introspect::Introspect::::ty() + } + + ].span() + } + ) + } +} + +#[derive(Drop, Serde)] +pub struct ModelWithShortStringNamespaceEntity { + __id: felt252, // private field + pub v: Vec3, + +} + +#[generate_trait] +pub impl ModelWithShortStringNamespaceEntityStoreImpl of ModelWithShortStringNamespaceEntityStore { + fn get(world: dojo::world::IWorldDispatcher, entity_id: felt252) -> ModelWithShortStringNamespaceEntity { + ModelWithShortStringNamespaceModelEntityImpl::get(world, entity_id) + } + + fn update(self: @ModelWithShortStringNamespaceEntity, world: dojo::world::IWorldDispatcher) { + dojo::model::ModelEntity::::update_entity(self, world); + } + + fn delete(self: @ModelWithShortStringNamespaceEntity, world: dojo::world::IWorldDispatcher) { + dojo::model::ModelEntity::::delete_entity(self, world); + } + + + fn get_v(world: dojo::world::IWorldDispatcher, entity_id: felt252) -> Vec3 { + let mut values = dojo::model::ModelEntity::::get_member( + world, + entity_id, + 578691550836206188651404750433984985630363913126316857592149308417275000080 + ); + let field_value = core::serde::Serde::::deserialize(ref values); + + if core::option::OptionTrait::::is_none(@field_value) { + panic!( + "Field `ModelWithShortStringNamespace::v`: deserialization failed." + ); + } + + core::option::OptionTrait::::unwrap(field_value) + } + + fn set_v(self: @ModelWithShortStringNamespaceEntity, world: dojo::world::IWorldDispatcher, value: Vec3) { + let mut serialized = core::array::ArrayTrait::new(); + core::serde::Serde::serialize(@value, ref serialized); + + self.set_member( + world, + 578691550836206188651404750433984985630363913126316857592149308417275000080, + serialized.span() + ); + } + +} + +#[generate_trait] +pub impl ModelWithShortStringNamespaceStoreImpl of ModelWithShortStringNamespaceStore { + fn entity_id_from_keys(id: felt252) -> felt252 { + let mut serialized = core::array::ArrayTrait::new(); + core::array::ArrayTrait::append(ref serialized, id); + + core::poseidon::poseidon_hash_span(serialized.span()) + } + + fn from_values(ref keys: Span, ref values: Span) -> ModelWithShortStringNamespace { + let mut serialized = core::array::ArrayTrait::new(); + serialized.append_span(keys); + serialized.append_span(values); + let mut serialized = core::array::ArrayTrait::span(@serialized); + + let entity = core::serde::Serde::::deserialize(ref serialized); + + if core::option::OptionTrait::::is_none(@entity) { + panic!( + "Model `ModelWithShortStringNamespace`: deserialization failed. Ensure the length of the keys tuple is matching the number of #[key] fields in the model struct." + ); + } + + core::option::OptionTrait::::unwrap(entity) + } + + fn get(world: dojo::world::IWorldDispatcher, id: felt252) -> ModelWithShortStringNamespace { + let mut serialized = core::array::ArrayTrait::new(); + core::array::ArrayTrait::append(ref serialized, id); + + + dojo::model::Model::::get(world, serialized.span()) + } + + fn set(self: @ModelWithShortStringNamespace, world: dojo::world::IWorldDispatcher) { + dojo::model::Model::::set_model(self, world); + } + + fn delete(self: @ModelWithShortStringNamespace, world: dojo::world::IWorldDispatcher) { + dojo::model::Model::::delete_model(self, world); + } + + + fn get_v(world: dojo::world::IWorldDispatcher, id: felt252) -> Vec3 { + let mut serialized = core::array::ArrayTrait::new(); + core::array::ArrayTrait::append(ref serialized, id); + + + let mut values = dojo::model::Model::::get_member( + world, + serialized.span(), + 578691550836206188651404750433984985630363913126316857592149308417275000080 + ); + + let field_value = core::serde::Serde::::deserialize(ref values); + + if core::option::OptionTrait::::is_none(@field_value) { + panic!( + "Field `ModelWithShortStringNamespace::v`: deserialization failed." + ); + } + + core::option::OptionTrait::::unwrap(field_value) + } + + fn set_v(self: @ModelWithShortStringNamespace, world: dojo::world::IWorldDispatcher, value: Vec3) { + let mut serialized = core::array::ArrayTrait::new(); + core::serde::Serde::serialize(@value, ref serialized); + + self.set_member( + world, + 578691550836206188651404750433984985630363913126316857592149308417275000080, + serialized.span() + ); + } + +} + +pub impl ModelWithShortStringNamespaceModelEntityImpl of dojo::model::ModelEntity { + fn id(self: @ModelWithShortStringNamespaceEntity) -> felt252 { + *self.__id + } + + fn values(self: @ModelWithShortStringNamespaceEntity) -> Span { + let mut serialized = core::array::ArrayTrait::new(); + core::serde::Serde::serialize(self.v, ref serialized); + + core::array::ArrayTrait::span(@serialized) + } + + fn from_values(entity_id: felt252, ref values: Span) -> ModelWithShortStringNamespaceEntity { + let mut serialized = array![entity_id]; + serialized.append_span(values); + let mut serialized = core::array::ArrayTrait::span(@serialized); + + let entity_values = core::serde::Serde::::deserialize(ref serialized); + if core::option::OptionTrait::::is_none(@entity_values) { + panic!( + "ModelEntity `ModelWithShortStringNamespaceEntity`: deserialization failed." + ); + } + core::option::OptionTrait::::unwrap(entity_values) + } + + fn get(world: dojo::world::IWorldDispatcher, entity_id: felt252) -> ModelWithShortStringNamespaceEntity { + let mut values = dojo::world::IWorldDispatcherTrait::entity( + world, + dojo::model::Model::::selector(), + dojo::model::ModelIndex::Id(entity_id), + dojo::model::Model::::layout() + ); + Self::from_values(entity_id, ref values) + } + + fn update_entity(self: @ModelWithShortStringNamespaceEntity, world: dojo::world::IWorldDispatcher) { + dojo::world::IWorldDispatcherTrait::set_entity( + world, + dojo::model::Model::::selector(), + dojo::model::ModelIndex::Id(self.id()), + self.values(), + dojo::model::Model::::layout() + ); + } + + fn delete_entity(self: @ModelWithShortStringNamespaceEntity, world: dojo::world::IWorldDispatcher) { + dojo::world::IWorldDispatcherTrait::delete_entity( + world, + dojo::model::Model::::selector(), + dojo::model::ModelIndex::Id(self.id()), + dojo::model::Model::::layout() + ); + } + + fn get_member( + world: dojo::world::IWorldDispatcher, + entity_id: felt252, + member_id: felt252, + ) -> Span { + match dojo::utils::find_model_field_layout(dojo::model::Model::::layout(), member_id) { + Option::Some(field_layout) => { + dojo::world::IWorldDispatcherTrait::entity( + world, + dojo::model::Model::::selector(), + dojo::model::ModelIndex::MemberId((entity_id, member_id)), + field_layout + ) + }, + Option::None => core::panic_with_felt252('bad member id') + } + } + + fn set_member( + self: @ModelWithShortStringNamespaceEntity, + world: dojo::world::IWorldDispatcher, + member_id: felt252, + values: Span, + ) { + match dojo::utils::find_model_field_layout(dojo::model::Model::::layout(), member_id) { + Option::Some(field_layout) => { + dojo::world::IWorldDispatcherTrait::set_entity( + world, + dojo::model::Model::::selector(), + dojo::model::ModelIndex::MemberId((self.id(), member_id)), + values, + field_layout + ) + }, + Option::None => core::panic_with_felt252('bad member id') + } + } +} + +pub impl ModelWithShortStringNamespaceModelImpl of dojo::model::Model { + fn get(world: dojo::world::IWorldDispatcher, keys: Span) -> ModelWithShortStringNamespace { + let mut values = dojo::world::IWorldDispatcherTrait::entity( + world, + Self::selector(), + dojo::model::ModelIndex::Keys(keys), + Self::layout() + ); + let mut _keys = keys; + + ModelWithShortStringNamespaceStore::from_values(ref _keys, ref values) + } + + fn set_model( + self: @ModelWithShortStringNamespace, + world: dojo::world::IWorldDispatcher + ) { + dojo::world::IWorldDispatcherTrait::set_entity( + world, + Self::selector(), + dojo::model::ModelIndex::Keys(Self::keys(self)), + Self::values(self), + Self::layout() + ); + } + + fn delete_model( + self: @ModelWithShortStringNamespace, + world: dojo::world::IWorldDispatcher + ) { + dojo::world::IWorldDispatcherTrait::delete_entity( + world, + Self::selector(), + dojo::model::ModelIndex::Keys(Self::keys(self)), + Self::layout() + ); + } + + fn get_member( + world: dojo::world::IWorldDispatcher, + keys: Span, + member_id: felt252 + ) -> Span { + match dojo::utils::find_model_field_layout(Self::layout(), member_id) { + Option::Some(field_layout) => { + let entity_id = dojo::utils::entity_id_from_keys(keys); + dojo::world::IWorldDispatcherTrait::entity( + world, + Self::selector(), + dojo::model::ModelIndex::MemberId((entity_id, member_id)), + field_layout + ) + }, + Option::None => core::panic_with_felt252('bad member id') + } + } + + fn set_member( + self: @ModelWithShortStringNamespace, + world: dojo::world::IWorldDispatcher, + member_id: felt252, + values: Span + ) { + match dojo::utils::find_model_field_layout(Self::layout(), member_id) { + Option::Some(field_layout) => { + dojo::world::IWorldDispatcherTrait::set_entity( + world, + Self::selector(), + dojo::model::ModelIndex::MemberId((self.entity_id(), member_id)), + values, + field_layout + ) + }, + Option::None => core::panic_with_felt252('bad member id') + } + } + + #[inline(always)] + fn name() -> ByteArray { + "ModelWithShortStringNamespace" + } + + #[inline(always)] + fn namespace() -> ByteArray { + "dojo_test" + } + + #[inline(always)] + fn tag() -> ByteArray { + "dojo_test-ModelWithShortStringNamespace" + } + + #[inline(always)] + fn version() -> u8 { + 1 + } + + #[inline(always)] + fn selector() -> felt252 { + 3563011140946869267852628778244415212055246902495528859686589254859279333005 + } + + #[inline(always)] + fn instance_selector(self: @ModelWithShortStringNamespace) -> felt252 { + Self::selector() + } + + #[inline(always)] + fn name_hash() -> felt252 { + 4646597166239297873853881466258165424425132957303541470648153031188639878 + } + + #[inline(always)] + fn namespace_hash() -> felt252 { + 1452123528942907587532668415362544424816022573043154497385993678618948064048 + } + + #[inline(always)] + fn entity_id(self: @ModelWithShortStringNamespace) -> felt252 { + core::poseidon::poseidon_hash_span(self.keys()) + } + + #[inline(always)] + fn keys(self: @ModelWithShortStringNamespace) -> Span { + let mut serialized = core::array::ArrayTrait::new(); + core::array::ArrayTrait::append(ref serialized, *self.id); + + core::array::ArrayTrait::span(@serialized) + } + + #[inline(always)] + fn values(self: @ModelWithShortStringNamespace) -> Span { + let mut serialized = core::array::ArrayTrait::new(); + core::serde::Serde::serialize(self.v, ref serialized); + + core::array::ArrayTrait::span(@serialized) + } + + #[inline(always)] + fn layout() -> dojo::model::Layout { + dojo::model::introspect::Introspect::::layout() + } + + #[inline(always)] + fn instance_layout(self: @ModelWithShortStringNamespace) -> dojo::model::Layout { + Self::layout() + } + + #[inline(always)] + fn packed_size() -> Option { + dojo::model::layout::compute_packed_size(Self::layout()) + } +} + +#[starknet::interface] +pub trait Imodel_with_short_string_namespace { + fn ensure_abi(self: @T, model: ModelWithShortStringNamespace); +} + +#[starknet::contract] +pub mod model_with_short_string_namespace { + use super::ModelWithShortStringNamespace; + use super::Imodel_with_short_string_namespace; + + #[abi(embed_v0)] + impl DojoModelImpl of dojo::model::IModel{ + fn name(self: @ContractState) -> ByteArray { + "ModelWithShortStringNamespace" + } + + fn namespace(self: @ContractState) -> ByteArray { + "dojo_test" + } + + fn tag(self: @ContractState) -> ByteArray { + "dojo_test-ModelWithShortStringNamespace" + } + + fn version(self: @ContractState) -> u8 { + 1 + } + + fn selector(self: @ContractState) -> felt252 { + 3563011140946869267852628778244415212055246902495528859686589254859279333005 + } + + fn name_hash(self: @ContractState) -> felt252 { + 4646597166239297873853881466258165424425132957303541470648153031188639878 + } + + fn namespace_hash(self: @ContractState) -> felt252 { + 1452123528942907587532668415362544424816022573043154497385993678618948064048 + } + + fn unpacked_size(self: @ContractState) -> Option { + dojo::model::introspect::Introspect::::size() + } + + fn packed_size(self: @ContractState) -> Option { + dojo::model::Model::::packed_size() + } + + fn layout(self: @ContractState) -> dojo::model::Layout { + dojo::model::Model::::layout() + } + + fn schema(self: @ContractState) -> dojo::model::introspect::Ty { + dojo::model::introspect::Introspect::::ty() + } + } + + #[abi(embed_v0)] + impl model_with_short_string_namespaceImpl of Imodel_with_short_string_namespace{ + fn ensure_abi(self: @ContractState, model: ModelWithShortStringNamespace) { + } + } +#[event] +#[derive(Drop, starknet::Event)] +pub enum Event {} + + +#[phantom] +pub struct Storage { +} + +#[derive(Drop, Copy)] +pub struct StorageStorageBase { +} +impl StorageStorageImpl of starknet::storage::StorageTrait { + type BaseType = StorageStorageBase; + fn storage(self: starknet::storage::FlattenedStorage) -> StorageStorageBase { + StorageStorageBase { + } + } +} +#[derive(Drop, Copy)] +pub struct StorageStorageBaseMut { +} +impl StorageStorageMutImpl of starknet::storage::StorageTraitMut { + type BaseType = StorageStorageBaseMut; + fn storage_mut(self: starknet::storage::FlattenedStorage>) -> StorageStorageBaseMut { + StorageStorageBaseMut { + } + } +} + +pub struct ContractState { +} + +impl ContractStateDrop of Drop {} + +impl ContractStateDeref of core::ops::SnapshotDeref { + type Target = starknet::storage::FlattenedStorage; + fn snapshot_deref(self: @ContractState) -> starknet::storage::FlattenedStorage { + starknet::storage::FlattenedStorage {} + } +} +impl ContractStateDerefMut of core::ops::DerefMut { + type Target = starknet::storage::FlattenedStorage> ; + fn deref_mut(ref self: ContractState) -> starknet::storage::FlattenedStorage> { + starknet::storage::FlattenedStorage {} + } +} +pub fn unsafe_new_contract_state() -> ContractState { + ContractState { + } +} + +// TODO(Gil): This generates duplicate diagnostics because of the plugin system, squash the duplicates into one. +#[deprecated( + feature: "deprecated_legacy_map", + note: "Use `starknet::storage::Map` instead." +)] +use starknet::storage::Map as LegacyMap; + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__DojoModelImpl__name(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = DojoModelImpl::name(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__DojoModelImpl__namespace(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = DojoModelImpl::namespace(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__DojoModelImpl__tag(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = DojoModelImpl::tag(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__DojoModelImpl__version(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = DojoModelImpl::version(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__DojoModelImpl__selector(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = DojoModelImpl::selector(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__DojoModelImpl__name_hash(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = DojoModelImpl::name_hash(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__DojoModelImpl__namespace_hash(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = DojoModelImpl::namespace_hash(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__DojoModelImpl__unpacked_size(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = DojoModelImpl::unpacked_size(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::>::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__DojoModelImpl__packed_size(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = DojoModelImpl::packed_size(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::>::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__DojoModelImpl__layout(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = DojoModelImpl::layout(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__DojoModelImpl__schema(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = DojoModelImpl::schema(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__model_with_short_string_namespaceImpl__ensure_abi(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + let __arg_model = core::option::OptionTraitImpl::expect( + core::serde::Serde::::deserialize(ref data), + 'Failed to deserialize param #1' + ); + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + model_with_short_string_namespaceImpl::ensure_abi(@contract_state, __arg_model); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::array::ArrayTrait::span(@arr) +} + + +pub mod __external { + pub use super::__wrapper__DojoModelImpl__name as name; + pub use super::__wrapper__DojoModelImpl__namespace as namespace; + pub use super::__wrapper__DojoModelImpl__tag as tag; + pub use super::__wrapper__DojoModelImpl__version as version; + pub use super::__wrapper__DojoModelImpl__selector as selector; + pub use super::__wrapper__DojoModelImpl__name_hash as name_hash; + pub use super::__wrapper__DojoModelImpl__namespace_hash as namespace_hash; + pub use super::__wrapper__DojoModelImpl__unpacked_size as unpacked_size; + pub use super::__wrapper__DojoModelImpl__packed_size as packed_size; + pub use super::__wrapper__DojoModelImpl__layout as layout; + pub use super::__wrapper__DojoModelImpl__schema as schema; + pub use super::__wrapper__model_with_short_string_namespaceImpl__ensure_abi as ensure_abi; +} +pub mod __l1_handler { +} +pub mod __constructor { +} + impl ContractStateEventEmitter of starknet::event::EventEmitter< + ContractState, Event + > { + fn emit>( + ref self: ContractState, event: S + ) { + let event: Event = core::traits::Into::into(event); + let mut keys = Default::::default(); + let mut data = Default::::default(); + starknet::Event::append_keys_and_data(@event, ref keys, ref data); + starknet::SyscallResultTrait::unwrap_syscall( + starknet::syscalls::emit_event_syscall( + core::array::ArrayTrait::span(@keys), + core::array::ArrayTrait::span(@data), + ) + ) + } + } +impl EventDrop of core::traits::Drop::; +impl EventIsEvent of starknet::Event { + fn append_keys_and_data( + self: @Event, ref keys: Array, ref data: Array + ) { + match self { + } + } + fn deserialize( + ref keys: Span, ref data: Span, + ) -> Option { + let __selector__ = *core::array::SpanTrait::pop_front(ref keys)?; + Option::None + } +} +impl StorageStorageBaseDrop of core::traits::Drop::; +impl StorageStorageBaseCopy of core::traits::Copy::; +impl StorageStorageBaseMutDrop of core::traits::Drop::; +impl StorageStorageBaseMutCopy of core::traits::Copy::; +} + +impl ModelWithStringNamespaceIntrospect<> of dojo::model::introspect::Introspect> { + #[inline(always)] + fn size() -> Option { + dojo::model::introspect::Introspect::::size() + } + + fn layout() -> dojo::model::Layout { + dojo::model::Layout::Struct( + array![ + dojo::model::FieldLayout { + selector: 578691550836206188651404750433984985630363913126316857592149308417275000080, + layout: dojo::model::introspect::Introspect::::layout() + } + ].span() + ) + } + + #[inline(always)] + fn ty() -> dojo::model::introspect::Ty { + dojo::model::introspect::Ty::Struct( + dojo::model::introspect::Struct { + name: 'ModelWithStringNamespace', + attrs: array![].span(), + children: array![ + dojo::model::introspect::Member { + name: 'id', + attrs: array!['key'].span(), + ty: dojo::model::introspect::Introspect::::ty() + }, +dojo::model::introspect::Member { + name: 'v', + attrs: array![].span(), + ty: dojo::model::introspect::Introspect::::ty() + } + + ].span() + } + ) + } +} + +#[derive(Drop, Serde)] +pub struct ModelWithStringNamespaceEntity { + __id: felt252, // private field + pub v: Vec3, + +} + +#[generate_trait] +pub impl ModelWithStringNamespaceEntityStoreImpl of ModelWithStringNamespaceEntityStore { + fn get(world: dojo::world::IWorldDispatcher, entity_id: felt252) -> ModelWithStringNamespaceEntity { + ModelWithStringNamespaceModelEntityImpl::get(world, entity_id) + } + + fn update(self: @ModelWithStringNamespaceEntity, world: dojo::world::IWorldDispatcher) { + dojo::model::ModelEntity::::update_entity(self, world); + } + + fn delete(self: @ModelWithStringNamespaceEntity, world: dojo::world::IWorldDispatcher) { + dojo::model::ModelEntity::::delete_entity(self, world); + } + + + fn get_v(world: dojo::world::IWorldDispatcher, entity_id: felt252) -> Vec3 { + let mut values = dojo::model::ModelEntity::::get_member( + world, + entity_id, + 578691550836206188651404750433984985630363913126316857592149308417275000080 + ); + let field_value = core::serde::Serde::::deserialize(ref values); + + if core::option::OptionTrait::::is_none(@field_value) { + panic!( + "Field `ModelWithStringNamespace::v`: deserialization failed." + ); + } + + core::option::OptionTrait::::unwrap(field_value) + } + + fn set_v(self: @ModelWithStringNamespaceEntity, world: dojo::world::IWorldDispatcher, value: Vec3) { + let mut serialized = core::array::ArrayTrait::new(); + core::serde::Serde::serialize(@value, ref serialized); + + self.set_member( + world, + 578691550836206188651404750433984985630363913126316857592149308417275000080, + serialized.span() + ); + } + +} + +#[generate_trait] +pub impl ModelWithStringNamespaceStoreImpl of ModelWithStringNamespaceStore { + fn entity_id_from_keys(id: felt252) -> felt252 { + let mut serialized = core::array::ArrayTrait::new(); + core::array::ArrayTrait::append(ref serialized, id); + + core::poseidon::poseidon_hash_span(serialized.span()) + } + + fn from_values(ref keys: Span, ref values: Span) -> ModelWithStringNamespace { + let mut serialized = core::array::ArrayTrait::new(); + serialized.append_span(keys); + serialized.append_span(values); + let mut serialized = core::array::ArrayTrait::span(@serialized); + + let entity = core::serde::Serde::::deserialize(ref serialized); + + if core::option::OptionTrait::::is_none(@entity) { + panic!( + "Model `ModelWithStringNamespace`: deserialization failed. Ensure the length of the keys tuple is matching the number of #[key] fields in the model struct." + ); + } + + core::option::OptionTrait::::unwrap(entity) + } + + fn get(world: dojo::world::IWorldDispatcher, id: felt252) -> ModelWithStringNamespace { + let mut serialized = core::array::ArrayTrait::new(); + core::array::ArrayTrait::append(ref serialized, id); + + + dojo::model::Model::::get(world, serialized.span()) + } + + fn set(self: @ModelWithStringNamespace, world: dojo::world::IWorldDispatcher) { + dojo::model::Model::::set_model(self, world); + } + + fn delete(self: @ModelWithStringNamespace, world: dojo::world::IWorldDispatcher) { + dojo::model::Model::::delete_model(self, world); + } + + + fn get_v(world: dojo::world::IWorldDispatcher, id: felt252) -> Vec3 { + let mut serialized = core::array::ArrayTrait::new(); + core::array::ArrayTrait::append(ref serialized, id); + + + let mut values = dojo::model::Model::::get_member( + world, + serialized.span(), + 578691550836206188651404750433984985630363913126316857592149308417275000080 + ); + + let field_value = core::serde::Serde::::deserialize(ref values); + + if core::option::OptionTrait::::is_none(@field_value) { + panic!( + "Field `ModelWithStringNamespace::v`: deserialization failed." + ); + } + + core::option::OptionTrait::::unwrap(field_value) + } + + fn set_v(self: @ModelWithStringNamespace, world: dojo::world::IWorldDispatcher, value: Vec3) { + let mut serialized = core::array::ArrayTrait::new(); + core::serde::Serde::serialize(@value, ref serialized); + + self.set_member( + world, + 578691550836206188651404750433984985630363913126316857592149308417275000080, + serialized.span() + ); + } + +} + +pub impl ModelWithStringNamespaceModelEntityImpl of dojo::model::ModelEntity { + fn id(self: @ModelWithStringNamespaceEntity) -> felt252 { + *self.__id + } + + fn values(self: @ModelWithStringNamespaceEntity) -> Span { + let mut serialized = core::array::ArrayTrait::new(); + core::serde::Serde::serialize(self.v, ref serialized); + + core::array::ArrayTrait::span(@serialized) + } + + fn from_values(entity_id: felt252, ref values: Span) -> ModelWithStringNamespaceEntity { + let mut serialized = array![entity_id]; + serialized.append_span(values); + let mut serialized = core::array::ArrayTrait::span(@serialized); + + let entity_values = core::serde::Serde::::deserialize(ref serialized); + if core::option::OptionTrait::::is_none(@entity_values) { + panic!( + "ModelEntity `ModelWithStringNamespaceEntity`: deserialization failed." + ); + } + core::option::OptionTrait::::unwrap(entity_values) + } + + fn get(world: dojo::world::IWorldDispatcher, entity_id: felt252) -> ModelWithStringNamespaceEntity { + let mut values = dojo::world::IWorldDispatcherTrait::entity( + world, + dojo::model::Model::::selector(), + dojo::model::ModelIndex::Id(entity_id), + dojo::model::Model::::layout() + ); + Self::from_values(entity_id, ref values) + } + + fn update_entity(self: @ModelWithStringNamespaceEntity, world: dojo::world::IWorldDispatcher) { + dojo::world::IWorldDispatcherTrait::set_entity( + world, + dojo::model::Model::::selector(), + dojo::model::ModelIndex::Id(self.id()), + self.values(), + dojo::model::Model::::layout() + ); + } + + fn delete_entity(self: @ModelWithStringNamespaceEntity, world: dojo::world::IWorldDispatcher) { + dojo::world::IWorldDispatcherTrait::delete_entity( + world, + dojo::model::Model::::selector(), + dojo::model::ModelIndex::Id(self.id()), + dojo::model::Model::::layout() + ); + } + + fn get_member( + world: dojo::world::IWorldDispatcher, + entity_id: felt252, + member_id: felt252, + ) -> Span { + match dojo::utils::find_model_field_layout(dojo::model::Model::::layout(), member_id) { + Option::Some(field_layout) => { + dojo::world::IWorldDispatcherTrait::entity( + world, + dojo::model::Model::::selector(), + dojo::model::ModelIndex::MemberId((entity_id, member_id)), + field_layout + ) + }, + Option::None => core::panic_with_felt252('bad member id') + } + } + + fn set_member( + self: @ModelWithStringNamespaceEntity, + world: dojo::world::IWorldDispatcher, + member_id: felt252, + values: Span, + ) { + match dojo::utils::find_model_field_layout(dojo::model::Model::::layout(), member_id) { + Option::Some(field_layout) => { + dojo::world::IWorldDispatcherTrait::set_entity( + world, + dojo::model::Model::::selector(), + dojo::model::ModelIndex::MemberId((self.id(), member_id)), + values, + field_layout + ) + }, + Option::None => core::panic_with_felt252('bad member id') + } + } +} + +pub impl ModelWithStringNamespaceModelImpl of dojo::model::Model { + fn get(world: dojo::world::IWorldDispatcher, keys: Span) -> ModelWithStringNamespace { + let mut values = dojo::world::IWorldDispatcherTrait::entity( + world, + Self::selector(), + dojo::model::ModelIndex::Keys(keys), + Self::layout() + ); + let mut _keys = keys; + + ModelWithStringNamespaceStore::from_values(ref _keys, ref values) + } + + fn set_model( + self: @ModelWithStringNamespace, + world: dojo::world::IWorldDispatcher + ) { + dojo::world::IWorldDispatcherTrait::set_entity( + world, + Self::selector(), + dojo::model::ModelIndex::Keys(Self::keys(self)), + Self::values(self), + Self::layout() + ); + } + + fn delete_model( + self: @ModelWithStringNamespace, + world: dojo::world::IWorldDispatcher + ) { + dojo::world::IWorldDispatcherTrait::delete_entity( + world, + Self::selector(), + dojo::model::ModelIndex::Keys(Self::keys(self)), + Self::layout() + ); + } + + fn get_member( + world: dojo::world::IWorldDispatcher, + keys: Span, + member_id: felt252 + ) -> Span { + match dojo::utils::find_model_field_layout(Self::layout(), member_id) { + Option::Some(field_layout) => { + let entity_id = dojo::utils::entity_id_from_keys(keys); + dojo::world::IWorldDispatcherTrait::entity( + world, + Self::selector(), + dojo::model::ModelIndex::MemberId((entity_id, member_id)), + field_layout + ) + }, + Option::None => core::panic_with_felt252('bad member id') + } + } + + fn set_member( + self: @ModelWithStringNamespace, + world: dojo::world::IWorldDispatcher, + member_id: felt252, + values: Span + ) { + match dojo::utils::find_model_field_layout(Self::layout(), member_id) { + Option::Some(field_layout) => { + dojo::world::IWorldDispatcherTrait::set_entity( + world, + Self::selector(), + dojo::model::ModelIndex::MemberId((self.entity_id(), member_id)), + values, + field_layout + ) + }, + Option::None => core::panic_with_felt252('bad member id') + } + } + + #[inline(always)] + fn name() -> ByteArray { + "ModelWithStringNamespace" + } + + #[inline(always)] + fn namespace() -> ByteArray { + "dojo_test" + } + + #[inline(always)] + fn tag() -> ByteArray { + "dojo_test-ModelWithStringNamespace" + } + + #[inline(always)] + fn version() -> u8 { + 1 + } + + #[inline(always)] + fn selector() -> felt252 { + 3428238780389029245974129676124052799610748885939447299287640410044966811336 + } + + #[inline(always)] + fn instance_selector(self: @ModelWithStringNamespace) -> felt252 { + Self::selector() + } + + #[inline(always)] + fn name_hash() -> felt252 { + 36187013840655350498900857372670392628596870210415176261336407419317644423 + } + + #[inline(always)] + fn namespace_hash() -> felt252 { + 1452123528942907587532668415362544424816022573043154497385993678618948064048 + } + + #[inline(always)] + fn entity_id(self: @ModelWithStringNamespace) -> felt252 { + core::poseidon::poseidon_hash_span(self.keys()) + } + + #[inline(always)] + fn keys(self: @ModelWithStringNamespace) -> Span { + let mut serialized = core::array::ArrayTrait::new(); + core::array::ArrayTrait::append(ref serialized, *self.id); + + core::array::ArrayTrait::span(@serialized) + } + + #[inline(always)] + fn values(self: @ModelWithStringNamespace) -> Span { + let mut serialized = core::array::ArrayTrait::new(); + core::serde::Serde::serialize(self.v, ref serialized); + + core::array::ArrayTrait::span(@serialized) + } + + #[inline(always)] + fn layout() -> dojo::model::Layout { + dojo::model::introspect::Introspect::::layout() + } + + #[inline(always)] + fn instance_layout(self: @ModelWithStringNamespace) -> dojo::model::Layout { + Self::layout() + } + + #[inline(always)] + fn packed_size() -> Option { + dojo::model::layout::compute_packed_size(Self::layout()) + } +} + +#[starknet::interface] +pub trait Imodel_with_string_namespace { + fn ensure_abi(self: @T, model: ModelWithStringNamespace); +} + +#[starknet::contract] +pub mod model_with_string_namespace { + use super::ModelWithStringNamespace; + use super::Imodel_with_string_namespace; + + #[abi(embed_v0)] + impl DojoModelImpl of dojo::model::IModel{ + fn name(self: @ContractState) -> ByteArray { + "ModelWithStringNamespace" + } + + fn namespace(self: @ContractState) -> ByteArray { + "dojo_test" + } + + fn tag(self: @ContractState) -> ByteArray { + "dojo_test-ModelWithStringNamespace" + } + + fn version(self: @ContractState) -> u8 { + 1 + } + + fn selector(self: @ContractState) -> felt252 { + 3428238780389029245974129676124052799610748885939447299287640410044966811336 + } + + fn name_hash(self: @ContractState) -> felt252 { + 36187013840655350498900857372670392628596870210415176261336407419317644423 + } + + fn namespace_hash(self: @ContractState) -> felt252 { + 1452123528942907587532668415362544424816022573043154497385993678618948064048 + } + + fn unpacked_size(self: @ContractState) -> Option { + dojo::model::introspect::Introspect::::size() + } + + fn packed_size(self: @ContractState) -> Option { + dojo::model::Model::::packed_size() + } + + fn layout(self: @ContractState) -> dojo::model::Layout { + dojo::model::Model::::layout() + } + + fn schema(self: @ContractState) -> dojo::model::introspect::Ty { + dojo::model::introspect::Introspect::::ty() + } + } + + #[abi(embed_v0)] + impl model_with_string_namespaceImpl of Imodel_with_string_namespace{ + fn ensure_abi(self: @ContractState, model: ModelWithStringNamespace) { + } + } +#[event] +#[derive(Drop, starknet::Event)] +pub enum Event {} + + +#[phantom] +pub struct Storage { +} + +#[derive(Drop, Copy)] +pub struct StorageStorageBase { +} +impl StorageStorageImpl of starknet::storage::StorageTrait { + type BaseType = StorageStorageBase; + fn storage(self: starknet::storage::FlattenedStorage) -> StorageStorageBase { + StorageStorageBase { + } + } +} +#[derive(Drop, Copy)] +pub struct StorageStorageBaseMut { +} +impl StorageStorageMutImpl of starknet::storage::StorageTraitMut { + type BaseType = StorageStorageBaseMut; + fn storage_mut(self: starknet::storage::FlattenedStorage>) -> StorageStorageBaseMut { + StorageStorageBaseMut { + } + } +} + +pub struct ContractState { +} + +impl ContractStateDrop of Drop {} + +impl ContractStateDeref of core::ops::SnapshotDeref { + type Target = starknet::storage::FlattenedStorage; + fn snapshot_deref(self: @ContractState) -> starknet::storage::FlattenedStorage { + starknet::storage::FlattenedStorage {} + } +} +impl ContractStateDerefMut of core::ops::DerefMut { + type Target = starknet::storage::FlattenedStorage> ; + fn deref_mut(ref self: ContractState) -> starknet::storage::FlattenedStorage> { + starknet::storage::FlattenedStorage {} + } +} +pub fn unsafe_new_contract_state() -> ContractState { + ContractState { + } +} + +// TODO(Gil): This generates duplicate diagnostics because of the plugin system, squash the duplicates into one. +#[deprecated( + feature: "deprecated_legacy_map", + note: "Use `starknet::storage::Map` instead." +)] +use starknet::storage::Map as LegacyMap; + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__DojoModelImpl__name(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = DojoModelImpl::name(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__DojoModelImpl__namespace(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = DojoModelImpl::namespace(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__DojoModelImpl__tag(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = DojoModelImpl::tag(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__DojoModelImpl__version(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = DojoModelImpl::version(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__DojoModelImpl__selector(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = DojoModelImpl::selector(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__DojoModelImpl__name_hash(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = DojoModelImpl::name_hash(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__DojoModelImpl__namespace_hash(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = DojoModelImpl::namespace_hash(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__DojoModelImpl__unpacked_size(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = DojoModelImpl::unpacked_size(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::>::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__DojoModelImpl__packed_size(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = DojoModelImpl::packed_size(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::>::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__DojoModelImpl__layout(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = DojoModelImpl::layout(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__DojoModelImpl__schema(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = DojoModelImpl::schema(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__model_with_string_namespaceImpl__ensure_abi(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + let __arg_model = core::option::OptionTraitImpl::expect( + core::serde::Serde::::deserialize(ref data), + 'Failed to deserialize param #1' + ); + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + model_with_string_namespaceImpl::ensure_abi(@contract_state, __arg_model); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::array::ArrayTrait::span(@arr) +} + + +pub mod __external { + pub use super::__wrapper__DojoModelImpl__name as name; + pub use super::__wrapper__DojoModelImpl__namespace as namespace; + pub use super::__wrapper__DojoModelImpl__tag as tag; + pub use super::__wrapper__DojoModelImpl__version as version; + pub use super::__wrapper__DojoModelImpl__selector as selector; + pub use super::__wrapper__DojoModelImpl__name_hash as name_hash; + pub use super::__wrapper__DojoModelImpl__namespace_hash as namespace_hash; + pub use super::__wrapper__DojoModelImpl__unpacked_size as unpacked_size; + pub use super::__wrapper__DojoModelImpl__packed_size as packed_size; + pub use super::__wrapper__DojoModelImpl__layout as layout; + pub use super::__wrapper__DojoModelImpl__schema as schema; + pub use super::__wrapper__model_with_string_namespaceImpl__ensure_abi as ensure_abi; +} +pub mod __l1_handler { +} +pub mod __constructor { +} + impl ContractStateEventEmitter of starknet::event::EventEmitter< + ContractState, Event + > { + fn emit>( + ref self: ContractState, event: S + ) { + let event: Event = core::traits::Into::into(event); + let mut keys = Default::::default(); + let mut data = Default::::default(); + starknet::Event::append_keys_and_data(@event, ref keys, ref data); + starknet::SyscallResultTrait::unwrap_syscall( + starknet::syscalls::emit_event_syscall( + core::array::ArrayTrait::span(@keys), + core::array::ArrayTrait::span(@data), + ) + ) + } + } +impl EventDrop of core::traits::Drop::; +impl EventIsEvent of starknet::Event { + fn append_keys_and_data( + self: @Event, ref keys: Array, ref data: Array + ) { + match self { + } + } + fn deserialize( + ref keys: Span, ref data: Span, + ) -> Option { + let __selector__ = *core::array::SpanTrait::pop_front(ref keys)?; + Option::None + } +} +impl StorageStorageBaseDrop of core::traits::Drop::; +impl StorageStorageBaseCopy of core::traits::Copy::; +impl StorageStorageBaseMutDrop of core::traits::Drop::; +impl StorageStorageBaseMutCopy of core::traits::Copy::; +} + +impl PositionIntrospect<> of dojo::model::introspect::Introspect> { + #[inline(always)] + fn size() -> Option { + dojo::model::introspect::Introspect::::size() + } + + fn layout() -> dojo::model::Layout { + dojo::model::Layout::Struct( + array![ + dojo::model::FieldLayout { + selector: 578691550836206188651404750433984985630363913126316857592149308417275000080, + layout: dojo::model::introspect::Introspect::::layout() + } + ].span() + ) + } + + #[inline(always)] + fn ty() -> dojo::model::introspect::Ty { + dojo::model::introspect::Ty::Struct( + dojo::model::introspect::Struct { + name: 'Position', + attrs: array![].span(), + children: array![ + dojo::model::introspect::Member { + name: 'id', + attrs: array!['key'].span(), + ty: dojo::model::introspect::Introspect::::ty() + }, +dojo::model::introspect::Member { + name: 'v', + attrs: array![].span(), + ty: dojo::model::introspect::Introspect::::ty() + } + + ].span() + } + ) + } +} + +#[derive(Drop, Serde)] +pub struct PositionEntity { + __id: felt252, // private field + pub v: Vec3, + +} + +#[generate_trait] +pub impl PositionEntityStoreImpl of PositionEntityStore { + fn get(world: dojo::world::IWorldDispatcher, entity_id: felt252) -> PositionEntity { + PositionModelEntityImpl::get(world, entity_id) + } + + fn update(self: @PositionEntity, world: dojo::world::IWorldDispatcher) { + dojo::model::ModelEntity::::update_entity(self, world); + } + + fn delete(self: @PositionEntity, world: dojo::world::IWorldDispatcher) { + dojo::model::ModelEntity::::delete_entity(self, world); + } + + + fn get_v(world: dojo::world::IWorldDispatcher, entity_id: felt252) -> Vec3 { + let mut values = dojo::model::ModelEntity::::get_member( + world, + entity_id, + 578691550836206188651404750433984985630363913126316857592149308417275000080 + ); + let field_value = core::serde::Serde::::deserialize(ref values); + + if core::option::OptionTrait::::is_none(@field_value) { + panic!( + "Field `Position::v`: deserialization failed." + ); + } + + core::option::OptionTrait::::unwrap(field_value) + } + + fn set_v(self: @PositionEntity, world: dojo::world::IWorldDispatcher, value: Vec3) { + let mut serialized = core::array::ArrayTrait::new(); + core::serde::Serde::serialize(@value, ref serialized); + + self.set_member( + world, + 578691550836206188651404750433984985630363913126316857592149308417275000080, + serialized.span() + ); + } + +} + +#[generate_trait] +pub impl PositionStoreImpl of PositionStore { + fn entity_id_from_keys(id: felt252) -> felt252 { + let mut serialized = core::array::ArrayTrait::new(); + core::array::ArrayTrait::append(ref serialized, id); + + core::poseidon::poseidon_hash_span(serialized.span()) + } + + fn from_values(ref keys: Span, ref values: Span) -> Position { + let mut serialized = core::array::ArrayTrait::new(); + serialized.append_span(keys); + serialized.append_span(values); + let mut serialized = core::array::ArrayTrait::span(@serialized); + + let entity = core::serde::Serde::::deserialize(ref serialized); + + if core::option::OptionTrait::::is_none(@entity) { + panic!( + "Model `Position`: deserialization failed. Ensure the length of the keys tuple is matching the number of #[key] fields in the model struct." + ); + } + + core::option::OptionTrait::::unwrap(entity) + } + + fn get(world: dojo::world::IWorldDispatcher, id: felt252) -> Position { + let mut serialized = core::array::ArrayTrait::new(); + core::array::ArrayTrait::append(ref serialized, id); + + + dojo::model::Model::::get(world, serialized.span()) + } + + fn set(self: @Position, world: dojo::world::IWorldDispatcher) { + dojo::model::Model::::set_model(self, world); + } + + fn delete(self: @Position, world: dojo::world::IWorldDispatcher) { + dojo::model::Model::::delete_model(self, world); + } + + + fn get_v(world: dojo::world::IWorldDispatcher, id: felt252) -> Vec3 { + let mut serialized = core::array::ArrayTrait::new(); + core::array::ArrayTrait::append(ref serialized, id); + + + let mut values = dojo::model::Model::::get_member( + world, + serialized.span(), + 578691550836206188651404750433984985630363913126316857592149308417275000080 + ); + + let field_value = core::serde::Serde::::deserialize(ref values); + + if core::option::OptionTrait::::is_none(@field_value) { + panic!( + "Field `Position::v`: deserialization failed." + ); + } + + core::option::OptionTrait::::unwrap(field_value) + } + + fn set_v(self: @Position, world: dojo::world::IWorldDispatcher, value: Vec3) { + let mut serialized = core::array::ArrayTrait::new(); + core::serde::Serde::serialize(@value, ref serialized); + + self.set_member( + world, + 578691550836206188651404750433984985630363913126316857592149308417275000080, + serialized.span() + ); + } + +} + +pub impl PositionModelEntityImpl of dojo::model::ModelEntity { + fn id(self: @PositionEntity) -> felt252 { + *self.__id + } + + fn values(self: @PositionEntity) -> Span { + let mut serialized = core::array::ArrayTrait::new(); + core::serde::Serde::serialize(self.v, ref serialized); + + core::array::ArrayTrait::span(@serialized) + } + + fn from_values(entity_id: felt252, ref values: Span) -> PositionEntity { + let mut serialized = array![entity_id]; + serialized.append_span(values); + let mut serialized = core::array::ArrayTrait::span(@serialized); + + let entity_values = core::serde::Serde::::deserialize(ref serialized); + if core::option::OptionTrait::::is_none(@entity_values) { + panic!( + "ModelEntity `PositionEntity`: deserialization failed." + ); + } + core::option::OptionTrait::::unwrap(entity_values) + } + + fn get(world: dojo::world::IWorldDispatcher, entity_id: felt252) -> PositionEntity { + let mut values = dojo::world::IWorldDispatcherTrait::entity( + world, + dojo::model::Model::::selector(), + dojo::model::ModelIndex::Id(entity_id), + dojo::model::Model::::layout() + ); + Self::from_values(entity_id, ref values) + } + + fn update_entity(self: @PositionEntity, world: dojo::world::IWorldDispatcher) { + dojo::world::IWorldDispatcherTrait::set_entity( + world, + dojo::model::Model::::selector(), + dojo::model::ModelIndex::Id(self.id()), + self.values(), + dojo::model::Model::::layout() + ); + } + + fn delete_entity(self: @PositionEntity, world: dojo::world::IWorldDispatcher) { + dojo::world::IWorldDispatcherTrait::delete_entity( + world, + dojo::model::Model::::selector(), + dojo::model::ModelIndex::Id(self.id()), + dojo::model::Model::::layout() + ); + } + + fn get_member( + world: dojo::world::IWorldDispatcher, + entity_id: felt252, + member_id: felt252, + ) -> Span { + match dojo::utils::find_model_field_layout(dojo::model::Model::::layout(), member_id) { + Option::Some(field_layout) => { + dojo::world::IWorldDispatcherTrait::entity( + world, + dojo::model::Model::::selector(), + dojo::model::ModelIndex::MemberId((entity_id, member_id)), + field_layout + ) + }, + Option::None => core::panic_with_felt252('bad member id') + } + } + + fn set_member( + self: @PositionEntity, + world: dojo::world::IWorldDispatcher, + member_id: felt252, + values: Span, + ) { + match dojo::utils::find_model_field_layout(dojo::model::Model::::layout(), member_id) { + Option::Some(field_layout) => { + dojo::world::IWorldDispatcherTrait::set_entity( + world, + dojo::model::Model::::selector(), + dojo::model::ModelIndex::MemberId((self.id(), member_id)), + values, + field_layout + ) + }, + Option::None => core::panic_with_felt252('bad member id') + } + } +} + +pub impl PositionModelImpl of dojo::model::Model { + fn get(world: dojo::world::IWorldDispatcher, keys: Span) -> Position { + let mut values = dojo::world::IWorldDispatcherTrait::entity( + world, + Self::selector(), + dojo::model::ModelIndex::Keys(keys), + Self::layout() + ); + let mut _keys = keys; + + PositionStore::from_values(ref _keys, ref values) + } + + fn set_model( + self: @Position, + world: dojo::world::IWorldDispatcher + ) { + dojo::world::IWorldDispatcherTrait::set_entity( + world, + Self::selector(), + dojo::model::ModelIndex::Keys(Self::keys(self)), + Self::values(self), + Self::layout() + ); + } + + fn delete_model( + self: @Position, + world: dojo::world::IWorldDispatcher + ) { + dojo::world::IWorldDispatcherTrait::delete_entity( + world, + Self::selector(), + dojo::model::ModelIndex::Keys(Self::keys(self)), + Self::layout() + ); + } + + fn get_member( + world: dojo::world::IWorldDispatcher, + keys: Span, + member_id: felt252 + ) -> Span { + match dojo::utils::find_model_field_layout(Self::layout(), member_id) { + Option::Some(field_layout) => { + let entity_id = dojo::utils::entity_id_from_keys(keys); + dojo::world::IWorldDispatcherTrait::entity( + world, + Self::selector(), + dojo::model::ModelIndex::MemberId((entity_id, member_id)), + field_layout + ) + }, + Option::None => core::panic_with_felt252('bad member id') + } + } + + fn set_member( + self: @Position, + world: dojo::world::IWorldDispatcher, + member_id: felt252, + values: Span + ) { + match dojo::utils::find_model_field_layout(Self::layout(), member_id) { + Option::Some(field_layout) => { + dojo::world::IWorldDispatcherTrait::set_entity( + world, + Self::selector(), + dojo::model::ModelIndex::MemberId((self.entity_id(), member_id)), + values, + field_layout + ) + }, + Option::None => core::panic_with_felt252('bad member id') + } + } + + #[inline(always)] + fn name() -> ByteArray { + "Position" + } + + #[inline(always)] + fn namespace() -> ByteArray { + "dojo_test" + } + + #[inline(always)] + fn tag() -> ByteArray { + "dojo_test-Position" + } + + #[inline(always)] + fn version() -> u8 { + 1 + } + + #[inline(always)] + fn selector() -> felt252 { + 1782729361185285637005619480739442196364037716000358448825261820703351159758 + } + + #[inline(always)] + fn instance_selector(self: @Position) -> felt252 { + Self::selector() + } + + #[inline(always)] + fn name_hash() -> felt252 { + 2899920299641094436341712346886623904698864491830316325765258522168980161362 + } + + #[inline(always)] + fn namespace_hash() -> felt252 { + 1452123528942907587532668415362544424816022573043154497385993678618948064048 + } + + #[inline(always)] + fn entity_id(self: @Position) -> felt252 { + core::poseidon::poseidon_hash_span(self.keys()) + } + + #[inline(always)] + fn keys(self: @Position) -> Span { + let mut serialized = core::array::ArrayTrait::new(); + core::array::ArrayTrait::append(ref serialized, *self.id); + + core::array::ArrayTrait::span(@serialized) + } + + #[inline(always)] + fn values(self: @Position) -> Span { + let mut serialized = core::array::ArrayTrait::new(); + core::serde::Serde::serialize(self.v, ref serialized); + + core::array::ArrayTrait::span(@serialized) + } + + #[inline(always)] + fn layout() -> dojo::model::Layout { + dojo::model::introspect::Introspect::::layout() + } + + #[inline(always)] + fn instance_layout(self: @Position) -> dojo::model::Layout { + Self::layout() + } + + #[inline(always)] + fn packed_size() -> Option { + dojo::model::layout::compute_packed_size(Self::layout()) + } +} + +#[starknet::interface] +pub trait Iposition { + fn ensure_abi(self: @T, model: Position); +} + +#[starknet::contract] +pub mod position { + use super::Position; + use super::Iposition; + + #[abi(embed_v0)] + impl DojoModelImpl of dojo::model::IModel{ + fn name(self: @ContractState) -> ByteArray { + "Position" + } + + fn namespace(self: @ContractState) -> ByteArray { + "dojo_test" + } + + fn tag(self: @ContractState) -> ByteArray { + "dojo_test-Position" + } + + fn version(self: @ContractState) -> u8 { + 1 + } + + fn selector(self: @ContractState) -> felt252 { + 1782729361185285637005619480739442196364037716000358448825261820703351159758 + } + + fn name_hash(self: @ContractState) -> felt252 { + 2899920299641094436341712346886623904698864491830316325765258522168980161362 + } + + fn namespace_hash(self: @ContractState) -> felt252 { + 1452123528942907587532668415362544424816022573043154497385993678618948064048 + } + + fn unpacked_size(self: @ContractState) -> Option { + dojo::model::introspect::Introspect::::size() + } + + fn packed_size(self: @ContractState) -> Option { + dojo::model::Model::::packed_size() + } + + fn layout(self: @ContractState) -> dojo::model::Layout { + dojo::model::Model::::layout() + } + + fn schema(self: @ContractState) -> dojo::model::introspect::Ty { + dojo::model::introspect::Introspect::::ty() + } + } + + #[abi(embed_v0)] + impl positionImpl of Iposition{ + fn ensure_abi(self: @ContractState, model: Position) { + } + } +#[event] +#[derive(Drop, starknet::Event)] +pub enum Event {} + + +#[phantom] +pub struct Storage { +} + +#[derive(Drop, Copy)] +pub struct StorageStorageBase { +} +impl StorageStorageImpl of starknet::storage::StorageTrait { + type BaseType = StorageStorageBase; + fn storage(self: starknet::storage::FlattenedStorage) -> StorageStorageBase { + StorageStorageBase { + } + } +} +#[derive(Drop, Copy)] +pub struct StorageStorageBaseMut { +} +impl StorageStorageMutImpl of starknet::storage::StorageTraitMut { + type BaseType = StorageStorageBaseMut; + fn storage_mut(self: starknet::storage::FlattenedStorage>) -> StorageStorageBaseMut { + StorageStorageBaseMut { + } + } +} + +pub struct ContractState { +} + +impl ContractStateDrop of Drop {} + +impl ContractStateDeref of core::ops::SnapshotDeref { + type Target = starknet::storage::FlattenedStorage; + fn snapshot_deref(self: @ContractState) -> starknet::storage::FlattenedStorage { + starknet::storage::FlattenedStorage {} + } +} +impl ContractStateDerefMut of core::ops::DerefMut { + type Target = starknet::storage::FlattenedStorage> ; + fn deref_mut(ref self: ContractState) -> starknet::storage::FlattenedStorage> { + starknet::storage::FlattenedStorage {} + } +} +pub fn unsafe_new_contract_state() -> ContractState { + ContractState { + } +} + +// TODO(Gil): This generates duplicate diagnostics because of the plugin system, squash the duplicates into one. +#[deprecated( + feature: "deprecated_legacy_map", + note: "Use `starknet::storage::Map` instead." +)] +use starknet::storage::Map as LegacyMap; + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__DojoModelImpl__name(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = DojoModelImpl::name(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__DojoModelImpl__namespace(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = DojoModelImpl::namespace(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__DojoModelImpl__tag(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = DojoModelImpl::tag(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__DojoModelImpl__version(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = DojoModelImpl::version(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__DojoModelImpl__selector(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = DojoModelImpl::selector(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__DojoModelImpl__name_hash(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = DojoModelImpl::name_hash(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__DojoModelImpl__namespace_hash(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = DojoModelImpl::namespace_hash(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__DojoModelImpl__unpacked_size(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = DojoModelImpl::unpacked_size(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::>::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__DojoModelImpl__packed_size(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = DojoModelImpl::packed_size(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::>::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__DojoModelImpl__layout(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = DojoModelImpl::layout(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__DojoModelImpl__schema(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = DojoModelImpl::schema(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__positionImpl__ensure_abi(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + let __arg_model = core::option::OptionTraitImpl::expect( + core::serde::Serde::::deserialize(ref data), + 'Failed to deserialize param #1' + ); + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + positionImpl::ensure_abi(@contract_state, __arg_model); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::array::ArrayTrait::span(@arr) +} + + +pub mod __external { + pub use super::__wrapper__DojoModelImpl__name as name; + pub use super::__wrapper__DojoModelImpl__namespace as namespace; + pub use super::__wrapper__DojoModelImpl__tag as tag; + pub use super::__wrapper__DojoModelImpl__version as version; + pub use super::__wrapper__DojoModelImpl__selector as selector; + pub use super::__wrapper__DojoModelImpl__name_hash as name_hash; + pub use super::__wrapper__DojoModelImpl__namespace_hash as namespace_hash; + pub use super::__wrapper__DojoModelImpl__unpacked_size as unpacked_size; + pub use super::__wrapper__DojoModelImpl__packed_size as packed_size; + pub use super::__wrapper__DojoModelImpl__layout as layout; + pub use super::__wrapper__DojoModelImpl__schema as schema; + pub use super::__wrapper__positionImpl__ensure_abi as ensure_abi; +} +pub mod __l1_handler { +} +pub mod __constructor { +} + impl ContractStateEventEmitter of starknet::event::EventEmitter< + ContractState, Event + > { + fn emit>( + ref self: ContractState, event: S + ) { + let event: Event = core::traits::Into::into(event); + let mut keys = Default::::default(); + let mut data = Default::::default(); + starknet::Event::append_keys_and_data(@event, ref keys, ref data); + starknet::SyscallResultTrait::unwrap_syscall( + starknet::syscalls::emit_event_syscall( + core::array::ArrayTrait::span(@keys), + core::array::ArrayTrait::span(@data), + ) + ) + } + } +impl EventDrop of core::traits::Drop::; +impl EventIsEvent of starknet::Event { + fn append_keys_and_data( + self: @Event, ref keys: Array, ref data: Array + ) { + match self { + } + } + fn deserialize( + ref keys: Span, ref data: Span, + ) -> Option { + let __selector__ = *core::array::SpanTrait::pop_front(ref keys)?; + Option::None + } +} +impl StorageStorageBaseDrop of core::traits::Drop::; +impl StorageStorageBaseCopy of core::traits::Copy::; +impl StorageStorageBaseMutDrop of core::traits::Drop::; +impl StorageStorageBaseMutCopy of core::traits::Copy::; +} + +impl RolesIntrospect<> of dojo::model::introspect::Introspect> { + #[inline(always)] + fn size() -> Option { + Option::None + } + + fn layout() -> dojo::model::Layout { + dojo::model::Layout::Struct( + array![ + dojo::model::FieldLayout { + selector: 387776731289756409274549987067854286905927440612427426920343953432870065647, + layout: dojo::model::introspect::Introspect:: +>::layout() + } + ].span() + ) + } + + #[inline(always)] + fn ty() -> dojo::model::introspect::Ty { + dojo::model::introspect::Ty::Struct( + dojo::model::introspect::Struct { + name: 'Roles', + attrs: array![].span(), + children: array![ + dojo::model::introspect::Member { + name: 'role_ids', + attrs: array![].span(), + ty: dojo::model::introspect::Ty::Array( + array![ + dojo::model::introspect::Introspect::::ty() + ].span() + ) + } + + ].span() + } + ) + } +} + +#[derive(Drop, Serde)] +pub struct RolesEntity { + __id: felt252, // private field + pub role_ids: Array, + +} + +#[generate_trait] +pub impl RolesEntityStoreImpl of RolesEntityStore { + fn get(world: dojo::world::IWorldDispatcher, entity_id: felt252) -> RolesEntity { + RolesModelEntityImpl::get(world, entity_id) + } + + fn update(self: @RolesEntity, world: dojo::world::IWorldDispatcher) { + dojo::model::ModelEntity::::update_entity(self, world); + } + + fn delete(self: @RolesEntity, world: dojo::world::IWorldDispatcher) { + dojo::model::ModelEntity::::delete_entity(self, world); + } + + + fn get_role_ids(world: dojo::world::IWorldDispatcher, entity_id: felt252) -> Array { + let mut values = dojo::model::ModelEntity::::get_member( + world, + entity_id, + 387776731289756409274549987067854286905927440612427426920343953432870065647 + ); + let field_value = core::serde::Serde::>::deserialize(ref values); + + if core::option::OptionTrait::>::is_none(@field_value) { + panic!( + "Field `Roles::role_ids`: deserialization failed." + ); + } + + core::option::OptionTrait::>::unwrap(field_value) + } + + fn set_role_ids(self: @RolesEntity, world: dojo::world::IWorldDispatcher, value: Array) { + let mut serialized = core::array::ArrayTrait::new(); + core::serde::Serde::serialize(@value, ref serialized); + + self.set_member( + world, + 387776731289756409274549987067854286905927440612427426920343953432870065647, + serialized.span() + ); + } + +} + +#[generate_trait] +pub impl RolesStoreImpl of RolesStore { + fn entity_id_from_keys() -> felt252 { + let mut serialized = core::array::ArrayTrait::new(); + + core::poseidon::poseidon_hash_span(serialized.span()) + } + + fn from_values(ref keys: Span, ref values: Span) -> Roles { + let mut serialized = core::array::ArrayTrait::new(); + serialized.append_span(keys); + serialized.append_span(values); + let mut serialized = core::array::ArrayTrait::span(@serialized); + + let entity = core::serde::Serde::::deserialize(ref serialized); + + if core::option::OptionTrait::::is_none(@entity) { + panic!( + "Model `Roles`: deserialization failed. Ensure the length of the keys tuple is matching the number of #[key] fields in the model struct." + ); + } + + core::option::OptionTrait::::unwrap(entity) + } + + fn get(world: dojo::world::IWorldDispatcher, ) -> Roles { + let mut serialized = core::array::ArrayTrait::new(); + + + dojo::model::Model::::get(world, serialized.span()) + } + + fn set(self: @Roles, world: dojo::world::IWorldDispatcher) { + dojo::model::Model::::set_model(self, world); + } + + fn delete(self: @Roles, world: dojo::world::IWorldDispatcher) { + dojo::model::Model::::delete_model(self, world); + } + + + fn get_role_ids(world: dojo::world::IWorldDispatcher, ) -> Array { + let mut serialized = core::array::ArrayTrait::new(); + + + let mut values = dojo::model::Model::::get_member( + world, + serialized.span(), + 387776731289756409274549987067854286905927440612427426920343953432870065647 + ); + + let field_value = core::serde::Serde::>::deserialize(ref values); + + if core::option::OptionTrait::>::is_none(@field_value) { + panic!( + "Field `Roles::role_ids`: deserialization failed." + ); + } + + core::option::OptionTrait::>::unwrap(field_value) + } + + fn set_role_ids(self: @Roles, world: dojo::world::IWorldDispatcher, value: Array) { + let mut serialized = core::array::ArrayTrait::new(); + core::serde::Serde::serialize(@value, ref serialized); + + self.set_member( + world, + 387776731289756409274549987067854286905927440612427426920343953432870065647, + serialized.span() + ); + } + +} + +pub impl RolesModelEntityImpl of dojo::model::ModelEntity { + fn id(self: @RolesEntity) -> felt252 { + *self.__id + } + + fn values(self: @RolesEntity) -> Span { + let mut serialized = core::array::ArrayTrait::new(); + core::serde::Serde::serialize(self.role_ids, ref serialized); + + core::array::ArrayTrait::span(@serialized) + } + + fn from_values(entity_id: felt252, ref values: Span) -> RolesEntity { + let mut serialized = array![entity_id]; + serialized.append_span(values); + let mut serialized = core::array::ArrayTrait::span(@serialized); + + let entity_values = core::serde::Serde::::deserialize(ref serialized); + if core::option::OptionTrait::::is_none(@entity_values) { + panic!( + "ModelEntity `RolesEntity`: deserialization failed." + ); + } + core::option::OptionTrait::::unwrap(entity_values) + } + + fn get(world: dojo::world::IWorldDispatcher, entity_id: felt252) -> RolesEntity { + let mut values = dojo::world::IWorldDispatcherTrait::entity( + world, + dojo::model::Model::::selector(), + dojo::model::ModelIndex::Id(entity_id), + dojo::model::Model::::layout() + ); + Self::from_values(entity_id, ref values) + } + + fn update_entity(self: @RolesEntity, world: dojo::world::IWorldDispatcher) { + dojo::world::IWorldDispatcherTrait::set_entity( + world, + dojo::model::Model::::selector(), + dojo::model::ModelIndex::Id(self.id()), + self.values(), + dojo::model::Model::::layout() + ); + } + + fn delete_entity(self: @RolesEntity, world: dojo::world::IWorldDispatcher) { + dojo::world::IWorldDispatcherTrait::delete_entity( + world, + dojo::model::Model::::selector(), + dojo::model::ModelIndex::Id(self.id()), + dojo::model::Model::::layout() + ); + } + + fn get_member( + world: dojo::world::IWorldDispatcher, + entity_id: felt252, + member_id: felt252, + ) -> Span { + match dojo::utils::find_model_field_layout(dojo::model::Model::::layout(), member_id) { + Option::Some(field_layout) => { + dojo::world::IWorldDispatcherTrait::entity( + world, + dojo::model::Model::::selector(), + dojo::model::ModelIndex::MemberId((entity_id, member_id)), + field_layout + ) + }, + Option::None => core::panic_with_felt252('bad member id') + } + } + + fn set_member( + self: @RolesEntity, + world: dojo::world::IWorldDispatcher, + member_id: felt252, + values: Span, + ) { + match dojo::utils::find_model_field_layout(dojo::model::Model::::layout(), member_id) { + Option::Some(field_layout) => { + dojo::world::IWorldDispatcherTrait::set_entity( + world, + dojo::model::Model::::selector(), + dojo::model::ModelIndex::MemberId((self.id(), member_id)), + values, + field_layout + ) + }, + Option::None => core::panic_with_felt252('bad member id') + } + } +} + +pub impl RolesModelImpl of dojo::model::Model { + fn get(world: dojo::world::IWorldDispatcher, keys: Span) -> Roles { + let mut values = dojo::world::IWorldDispatcherTrait::entity( + world, + Self::selector(), + dojo::model::ModelIndex::Keys(keys), + Self::layout() + ); + let mut _keys = keys; + + RolesStore::from_values(ref _keys, ref values) + } + + fn set_model( + self: @Roles, + world: dojo::world::IWorldDispatcher + ) { + dojo::world::IWorldDispatcherTrait::set_entity( + world, + Self::selector(), + dojo::model::ModelIndex::Keys(Self::keys(self)), + Self::values(self), + Self::layout() + ); + } + + fn delete_model( + self: @Roles, + world: dojo::world::IWorldDispatcher + ) { + dojo::world::IWorldDispatcherTrait::delete_entity( + world, + Self::selector(), + dojo::model::ModelIndex::Keys(Self::keys(self)), + Self::layout() + ); + } + + fn get_member( + world: dojo::world::IWorldDispatcher, + keys: Span, + member_id: felt252 + ) -> Span { + match dojo::utils::find_model_field_layout(Self::layout(), member_id) { + Option::Some(field_layout) => { + let entity_id = dojo::utils::entity_id_from_keys(keys); + dojo::world::IWorldDispatcherTrait::entity( + world, + Self::selector(), + dojo::model::ModelIndex::MemberId((entity_id, member_id)), + field_layout + ) + }, + Option::None => core::panic_with_felt252('bad member id') + } + } + + fn set_member( + self: @Roles, + world: dojo::world::IWorldDispatcher, + member_id: felt252, + values: Span + ) { + match dojo::utils::find_model_field_layout(Self::layout(), member_id) { + Option::Some(field_layout) => { + dojo::world::IWorldDispatcherTrait::set_entity( + world, + Self::selector(), + dojo::model::ModelIndex::MemberId((self.entity_id(), member_id)), + values, + field_layout + ) + }, + Option::None => core::panic_with_felt252('bad member id') + } + } + + #[inline(always)] + fn name() -> ByteArray { + "Roles" + } + + #[inline(always)] + fn namespace() -> ByteArray { + "dojo_test" + } + + #[inline(always)] + fn tag() -> ByteArray { + "dojo_test-Roles" + } + + #[inline(always)] + fn version() -> u8 { + 1 + } + + #[inline(always)] + fn selector() -> felt252 { + 3584099896964965841643389141246184155284218827427504603233100831001054183182 + } + + #[inline(always)] + fn instance_selector(self: @Roles) -> felt252 { + Self::selector() + } + + #[inline(always)] + fn name_hash() -> felt252 { + 2030971736961612564423689930729061756599290850089001157163423482274886199516 + } + + #[inline(always)] + fn namespace_hash() -> felt252 { + 1452123528942907587532668415362544424816022573043154497385993678618948064048 + } + + #[inline(always)] + fn entity_id(self: @Roles) -> felt252 { + core::poseidon::poseidon_hash_span(self.keys()) + } + + #[inline(always)] + fn keys(self: @Roles) -> Span { + let mut serialized = core::array::ArrayTrait::new(); + + core::array::ArrayTrait::span(@serialized) + } + + #[inline(always)] + fn values(self: @Roles) -> Span { + let mut serialized = core::array::ArrayTrait::new(); + core::serde::Serde::serialize(self.role_ids, ref serialized); + + core::array::ArrayTrait::span(@serialized) + } + + #[inline(always)] + fn layout() -> dojo::model::Layout { + dojo::model::introspect::Introspect::::layout() + } + + #[inline(always)] + fn instance_layout(self: @Roles) -> dojo::model::Layout { + Self::layout() + } + + #[inline(always)] + fn packed_size() -> Option { + dojo::model::layout::compute_packed_size(Self::layout()) + } +} + +#[starknet::interface] +pub trait Iroles { + fn ensure_abi(self: @T, model: Roles); +} + +#[starknet::contract] +pub mod roles { + use super::Roles; + use super::Iroles; + + #[abi(embed_v0)] + impl DojoModelImpl of dojo::model::IModel{ + fn name(self: @ContractState) -> ByteArray { + "Roles" + } + + fn namespace(self: @ContractState) -> ByteArray { + "dojo_test" + } + + fn tag(self: @ContractState) -> ByteArray { + "dojo_test-Roles" + } + + fn version(self: @ContractState) -> u8 { + 1 + } + + fn selector(self: @ContractState) -> felt252 { + 3584099896964965841643389141246184155284218827427504603233100831001054183182 + } + + fn name_hash(self: @ContractState) -> felt252 { + 2030971736961612564423689930729061756599290850089001157163423482274886199516 + } + + fn namespace_hash(self: @ContractState) -> felt252 { + 1452123528942907587532668415362544424816022573043154497385993678618948064048 + } + + fn unpacked_size(self: @ContractState) -> Option { + dojo::model::introspect::Introspect::::size() + } + + fn packed_size(self: @ContractState) -> Option { + dojo::model::Model::::packed_size() + } + + fn layout(self: @ContractState) -> dojo::model::Layout { + dojo::model::Model::::layout() + } + + fn schema(self: @ContractState) -> dojo::model::introspect::Ty { + dojo::model::introspect::Introspect::::ty() + } + } + + #[abi(embed_v0)] + impl rolesImpl of Iroles{ + fn ensure_abi(self: @ContractState, model: Roles) { + } + } +#[event] +#[derive(Drop, starknet::Event)] +pub enum Event {} + + +#[phantom] +pub struct Storage { +} + +#[derive(Drop, Copy)] +pub struct StorageStorageBase { +} +impl StorageStorageImpl of starknet::storage::StorageTrait { + type BaseType = StorageStorageBase; + fn storage(self: starknet::storage::FlattenedStorage) -> StorageStorageBase { + StorageStorageBase { + } + } +} +#[derive(Drop, Copy)] +pub struct StorageStorageBaseMut { +} +impl StorageStorageMutImpl of starknet::storage::StorageTraitMut { + type BaseType = StorageStorageBaseMut; + fn storage_mut(self: starknet::storage::FlattenedStorage>) -> StorageStorageBaseMut { + StorageStorageBaseMut { + } + } +} + +pub struct ContractState { +} + +impl ContractStateDrop of Drop {} + +impl ContractStateDeref of core::ops::SnapshotDeref { + type Target = starknet::storage::FlattenedStorage; + fn snapshot_deref(self: @ContractState) -> starknet::storage::FlattenedStorage { + starknet::storage::FlattenedStorage {} + } +} +impl ContractStateDerefMut of core::ops::DerefMut { + type Target = starknet::storage::FlattenedStorage> ; + fn deref_mut(ref self: ContractState) -> starknet::storage::FlattenedStorage> { + starknet::storage::FlattenedStorage {} + } +} +pub fn unsafe_new_contract_state() -> ContractState { + ContractState { + } +} + +// TODO(Gil): This generates duplicate diagnostics because of the plugin system, squash the duplicates into one. +#[deprecated( + feature: "deprecated_legacy_map", + note: "Use `starknet::storage::Map` instead." +)] +use starknet::storage::Map as LegacyMap; + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__DojoModelImpl__name(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = DojoModelImpl::name(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__DojoModelImpl__namespace(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = DojoModelImpl::namespace(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__DojoModelImpl__tag(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = DojoModelImpl::tag(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__DojoModelImpl__version(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = DojoModelImpl::version(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__DojoModelImpl__selector(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = DojoModelImpl::selector(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__DojoModelImpl__name_hash(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = DojoModelImpl::name_hash(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__DojoModelImpl__namespace_hash(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = DojoModelImpl::namespace_hash(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__DojoModelImpl__unpacked_size(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = DojoModelImpl::unpacked_size(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::>::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__DojoModelImpl__packed_size(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = DojoModelImpl::packed_size(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::>::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__DojoModelImpl__layout(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = DojoModelImpl::layout(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__DojoModelImpl__schema(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = DojoModelImpl::schema(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__rolesImpl__ensure_abi(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + let __arg_model = core::option::OptionTraitImpl::expect( + core::serde::Serde::::deserialize(ref data), + 'Failed to deserialize param #1' + ); + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + rolesImpl::ensure_abi(@contract_state, __arg_model); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::array::ArrayTrait::span(@arr) +} + + +pub mod __external { + pub use super::__wrapper__DojoModelImpl__name as name; + pub use super::__wrapper__DojoModelImpl__namespace as namespace; + pub use super::__wrapper__DojoModelImpl__tag as tag; + pub use super::__wrapper__DojoModelImpl__version as version; + pub use super::__wrapper__DojoModelImpl__selector as selector; + pub use super::__wrapper__DojoModelImpl__name_hash as name_hash; + pub use super::__wrapper__DojoModelImpl__namespace_hash as namespace_hash; + pub use super::__wrapper__DojoModelImpl__unpacked_size as unpacked_size; + pub use super::__wrapper__DojoModelImpl__packed_size as packed_size; + pub use super::__wrapper__DojoModelImpl__layout as layout; + pub use super::__wrapper__DojoModelImpl__schema as schema; + pub use super::__wrapper__rolesImpl__ensure_abi as ensure_abi; +} +pub mod __l1_handler { +} +pub mod __constructor { +} + impl ContractStateEventEmitter of starknet::event::EventEmitter< + ContractState, Event + > { + fn emit>( + ref self: ContractState, event: S + ) { + let event: Event = core::traits::Into::into(event); + let mut keys = Default::::default(); + let mut data = Default::::default(); + starknet::Event::append_keys_and_data(@event, ref keys, ref data); + starknet::SyscallResultTrait::unwrap_syscall( + starknet::syscalls::emit_event_syscall( + core::array::ArrayTrait::span(@keys), + core::array::ArrayTrait::span(@data), + ) + ) + } + } +impl EventDrop of core::traits::Drop::; +impl EventIsEvent of starknet::Event { + fn append_keys_and_data( + self: @Event, ref keys: Array, ref data: Array + ) { + match self { + } + } + fn deserialize( + ref keys: Span, ref data: Span, + ) -> Option { + let __selector__ = *core::array::SpanTrait::pop_front(ref keys)?; + Option::None + } +} +impl StorageStorageBaseDrop of core::traits::Drop::; +impl StorageStorageBaseCopy of core::traits::Copy::; +impl StorageStorageBaseMutDrop of core::traits::Drop::; +impl StorageStorageBaseMutCopy of core::traits::Copy::; +} + +impl OnlyKeyModelIntrospect<> of dojo::model::introspect::Introspect> { + #[inline(always)] + fn size() -> Option { + Option::None + } + + fn layout() -> dojo::model::Layout { + dojo::model::Layout::Struct( + array![ + + ].span() + ) + } + + #[inline(always)] + fn ty() -> dojo::model::introspect::Ty { + dojo::model::introspect::Ty::Struct( + dojo::model::introspect::Struct { + name: 'OnlyKeyModel', + attrs: array![].span(), + children: array![ + dojo::model::introspect::Member { + name: 'id', + attrs: array!['key'].span(), + ty: dojo::model::introspect::Introspect::::ty() + } + + ].span() + } + ) + } +} + +#[derive(Drop, Serde)] +pub struct OnlyKeyModelEntity { + __id: felt252, // private field + +} + +#[generate_trait] +pub impl OnlyKeyModelEntityStoreImpl of OnlyKeyModelEntityStore { + fn get(world: dojo::world::IWorldDispatcher, entity_id: felt252) -> OnlyKeyModelEntity { + OnlyKeyModelModelEntityImpl::get(world, entity_id) + } + + fn update(self: @OnlyKeyModelEntity, world: dojo::world::IWorldDispatcher) { + dojo::model::ModelEntity::::update_entity(self, world); + } + + fn delete(self: @OnlyKeyModelEntity, world: dojo::world::IWorldDispatcher) { + dojo::model::ModelEntity::::delete_entity(self, world); + } + + +} + +#[generate_trait] +pub impl OnlyKeyModelStoreImpl of OnlyKeyModelStore { + fn entity_id_from_keys(id: felt252) -> felt252 { + let mut serialized = core::array::ArrayTrait::new(); + core::array::ArrayTrait::append(ref serialized, id); + + core::poseidon::poseidon_hash_span(serialized.span()) + } + + fn from_values(ref keys: Span, ref values: Span) -> OnlyKeyModel { + let mut serialized = core::array::ArrayTrait::new(); + serialized.append_span(keys); + serialized.append_span(values); + let mut serialized = core::array::ArrayTrait::span(@serialized); + + let entity = core::serde::Serde::::deserialize(ref serialized); + + if core::option::OptionTrait::::is_none(@entity) { + panic!( + "Model `OnlyKeyModel`: deserialization failed. Ensure the length of the keys tuple is matching the number of #[key] fields in the model struct." + ); + } + + core::option::OptionTrait::::unwrap(entity) + } + + fn get(world: dojo::world::IWorldDispatcher, id: felt252) -> OnlyKeyModel { + let mut serialized = core::array::ArrayTrait::new(); + core::array::ArrayTrait::append(ref serialized, id); + + + dojo::model::Model::::get(world, serialized.span()) + } + + fn set(self: @OnlyKeyModel, world: dojo::world::IWorldDispatcher) { + dojo::model::Model::::set_model(self, world); + } + + fn delete(self: @OnlyKeyModel, world: dojo::world::IWorldDispatcher) { + dojo::model::Model::::delete_model(self, world); + } + + +} + +pub impl OnlyKeyModelModelEntityImpl of dojo::model::ModelEntity { + fn id(self: @OnlyKeyModelEntity) -> felt252 { + *self.__id + } + + fn values(self: @OnlyKeyModelEntity) -> Span { + let mut serialized = core::array::ArrayTrait::new(); + + core::array::ArrayTrait::span(@serialized) + } + + fn from_values(entity_id: felt252, ref values: Span) -> OnlyKeyModelEntity { + let mut serialized = array![entity_id]; + serialized.append_span(values); + let mut serialized = core::array::ArrayTrait::span(@serialized); + + let entity_values = core::serde::Serde::::deserialize(ref serialized); + if core::option::OptionTrait::::is_none(@entity_values) { + panic!( + "ModelEntity `OnlyKeyModelEntity`: deserialization failed." + ); + } + core::option::OptionTrait::::unwrap(entity_values) + } + + fn get(world: dojo::world::IWorldDispatcher, entity_id: felt252) -> OnlyKeyModelEntity { + let mut values = dojo::world::IWorldDispatcherTrait::entity( + world, + dojo::model::Model::::selector(), + dojo::model::ModelIndex::Id(entity_id), + dojo::model::Model::::layout() + ); + Self::from_values(entity_id, ref values) + } + + fn update_entity(self: @OnlyKeyModelEntity, world: dojo::world::IWorldDispatcher) { + dojo::world::IWorldDispatcherTrait::set_entity( + world, + dojo::model::Model::::selector(), + dojo::model::ModelIndex::Id(self.id()), + self.values(), + dojo::model::Model::::layout() + ); + } + + fn delete_entity(self: @OnlyKeyModelEntity, world: dojo::world::IWorldDispatcher) { + dojo::world::IWorldDispatcherTrait::delete_entity( + world, + dojo::model::Model::::selector(), + dojo::model::ModelIndex::Id(self.id()), + dojo::model::Model::::layout() + ); + } + + fn get_member( + world: dojo::world::IWorldDispatcher, + entity_id: felt252, + member_id: felt252, + ) -> Span { + match dojo::utils::find_model_field_layout(dojo::model::Model::::layout(), member_id) { + Option::Some(field_layout) => { + dojo::world::IWorldDispatcherTrait::entity( + world, + dojo::model::Model::::selector(), + dojo::model::ModelIndex::MemberId((entity_id, member_id)), + field_layout + ) + }, + Option::None => core::panic_with_felt252('bad member id') + } + } + + fn set_member( + self: @OnlyKeyModelEntity, + world: dojo::world::IWorldDispatcher, + member_id: felt252, + values: Span, + ) { + match dojo::utils::find_model_field_layout(dojo::model::Model::::layout(), member_id) { + Option::Some(field_layout) => { + dojo::world::IWorldDispatcherTrait::set_entity( + world, + dojo::model::Model::::selector(), + dojo::model::ModelIndex::MemberId((self.id(), member_id)), + values, + field_layout + ) + }, + Option::None => core::panic_with_felt252('bad member id') + } + } +} + +pub impl OnlyKeyModelModelImpl of dojo::model::Model { + fn get(world: dojo::world::IWorldDispatcher, keys: Span) -> OnlyKeyModel { + let mut values = dojo::world::IWorldDispatcherTrait::entity( + world, + Self::selector(), + dojo::model::ModelIndex::Keys(keys), + Self::layout() + ); + let mut _keys = keys; + + OnlyKeyModelStore::from_values(ref _keys, ref values) + } + + fn set_model( + self: @OnlyKeyModel, + world: dojo::world::IWorldDispatcher + ) { + dojo::world::IWorldDispatcherTrait::set_entity( + world, + Self::selector(), + dojo::model::ModelIndex::Keys(Self::keys(self)), + Self::values(self), + Self::layout() + ); + } + + fn delete_model( + self: @OnlyKeyModel, + world: dojo::world::IWorldDispatcher + ) { + dojo::world::IWorldDispatcherTrait::delete_entity( + world, + Self::selector(), + dojo::model::ModelIndex::Keys(Self::keys(self)), + Self::layout() + ); + } + + fn get_member( + world: dojo::world::IWorldDispatcher, + keys: Span, + member_id: felt252 + ) -> Span { + match dojo::utils::find_model_field_layout(Self::layout(), member_id) { + Option::Some(field_layout) => { + let entity_id = dojo::utils::entity_id_from_keys(keys); + dojo::world::IWorldDispatcherTrait::entity( + world, + Self::selector(), + dojo::model::ModelIndex::MemberId((entity_id, member_id)), + field_layout + ) + }, + Option::None => core::panic_with_felt252('bad member id') + } + } + + fn set_member( + self: @OnlyKeyModel, + world: dojo::world::IWorldDispatcher, + member_id: felt252, + values: Span + ) { + match dojo::utils::find_model_field_layout(Self::layout(), member_id) { + Option::Some(field_layout) => { + dojo::world::IWorldDispatcherTrait::set_entity( + world, + Self::selector(), + dojo::model::ModelIndex::MemberId((self.entity_id(), member_id)), + values, + field_layout + ) + }, + Option::None => core::panic_with_felt252('bad member id') + } + } + + #[inline(always)] + fn name() -> ByteArray { + "OnlyKeyModel" + } + + #[inline(always)] + fn namespace() -> ByteArray { + "dojo_test" + } + + #[inline(always)] + fn tag() -> ByteArray { + "dojo_test-OnlyKeyModel" + } + + #[inline(always)] + fn version() -> u8 { + 1 + } + + #[inline(always)] + fn selector() -> felt252 { + 2309092000941816896446401231215693966290521919639503466118437426986900396853 + } + + #[inline(always)] + fn instance_selector(self: @OnlyKeyModel) -> felt252 { + Self::selector() + } + + #[inline(always)] + fn name_hash() -> felt252 { + 1001826121797570811408809643478760373535949956555931325019299477987282578617 + } + + #[inline(always)] + fn namespace_hash() -> felt252 { + 1452123528942907587532668415362544424816022573043154497385993678618948064048 + } + + #[inline(always)] + fn entity_id(self: @OnlyKeyModel) -> felt252 { + core::poseidon::poseidon_hash_span(self.keys()) + } + + #[inline(always)] + fn keys(self: @OnlyKeyModel) -> Span { + let mut serialized = core::array::ArrayTrait::new(); + core::array::ArrayTrait::append(ref serialized, *self.id); + + core::array::ArrayTrait::span(@serialized) + } + + #[inline(always)] + fn values(self: @OnlyKeyModel) -> Span { + let mut serialized = core::array::ArrayTrait::new(); + + core::array::ArrayTrait::span(@serialized) + } + + #[inline(always)] + fn layout() -> dojo::model::Layout { + dojo::model::introspect::Introspect::::layout() + } + + #[inline(always)] + fn instance_layout(self: @OnlyKeyModel) -> dojo::model::Layout { + Self::layout() + } + + #[inline(always)] + fn packed_size() -> Option { + dojo::model::layout::compute_packed_size(Self::layout()) + } +} + +#[starknet::interface] +pub trait Ionly_key_model { + fn ensure_abi(self: @T, model: OnlyKeyModel); +} + +#[starknet::contract] +pub mod only_key_model { + use super::OnlyKeyModel; + use super::Ionly_key_model; + + #[abi(embed_v0)] + impl DojoModelImpl of dojo::model::IModel{ + fn name(self: @ContractState) -> ByteArray { + "OnlyKeyModel" + } + + fn namespace(self: @ContractState) -> ByteArray { + "dojo_test" + } + + fn tag(self: @ContractState) -> ByteArray { + "dojo_test-OnlyKeyModel" + } + + fn version(self: @ContractState) -> u8 { + 1 + } + + fn selector(self: @ContractState) -> felt252 { + 2309092000941816896446401231215693966290521919639503466118437426986900396853 + } + + fn name_hash(self: @ContractState) -> felt252 { + 1001826121797570811408809643478760373535949956555931325019299477987282578617 + } + + fn namespace_hash(self: @ContractState) -> felt252 { + 1452123528942907587532668415362544424816022573043154497385993678618948064048 + } + + fn unpacked_size(self: @ContractState) -> Option { + dojo::model::introspect::Introspect::::size() + } + + fn packed_size(self: @ContractState) -> Option { + dojo::model::Model::::packed_size() + } + + fn layout(self: @ContractState) -> dojo::model::Layout { + dojo::model::Model::::layout() + } + + fn schema(self: @ContractState) -> dojo::model::introspect::Ty { + dojo::model::introspect::Introspect::::ty() + } + } + + #[abi(embed_v0)] + impl only_key_modelImpl of Ionly_key_model{ + fn ensure_abi(self: @ContractState, model: OnlyKeyModel) { + } + } +#[event] +#[derive(Drop, starknet::Event)] +pub enum Event {} + + +#[phantom] +pub struct Storage { +} + +#[derive(Drop, Copy)] +pub struct StorageStorageBase { +} +impl StorageStorageImpl of starknet::storage::StorageTrait { + type BaseType = StorageStorageBase; + fn storage(self: starknet::storage::FlattenedStorage) -> StorageStorageBase { + StorageStorageBase { + } + } +} +#[derive(Drop, Copy)] +pub struct StorageStorageBaseMut { +} +impl StorageStorageMutImpl of starknet::storage::StorageTraitMut { + type BaseType = StorageStorageBaseMut; + fn storage_mut(self: starknet::storage::FlattenedStorage>) -> StorageStorageBaseMut { + StorageStorageBaseMut { + } + } +} + +pub struct ContractState { +} + +impl ContractStateDrop of Drop {} + +impl ContractStateDeref of core::ops::SnapshotDeref { + type Target = starknet::storage::FlattenedStorage; + fn snapshot_deref(self: @ContractState) -> starknet::storage::FlattenedStorage { + starknet::storage::FlattenedStorage {} + } +} +impl ContractStateDerefMut of core::ops::DerefMut { + type Target = starknet::storage::FlattenedStorage> ; + fn deref_mut(ref self: ContractState) -> starknet::storage::FlattenedStorage> { + starknet::storage::FlattenedStorage {} + } +} +pub fn unsafe_new_contract_state() -> ContractState { + ContractState { + } +} + +// TODO(Gil): This generates duplicate diagnostics because of the plugin system, squash the duplicates into one. +#[deprecated( + feature: "deprecated_legacy_map", + note: "Use `starknet::storage::Map` instead." +)] +use starknet::storage::Map as LegacyMap; + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__DojoModelImpl__name(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = DojoModelImpl::name(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__DojoModelImpl__namespace(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = DojoModelImpl::namespace(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__DojoModelImpl__tag(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = DojoModelImpl::tag(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__DojoModelImpl__version(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = DojoModelImpl::version(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__DojoModelImpl__selector(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = DojoModelImpl::selector(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__DojoModelImpl__name_hash(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = DojoModelImpl::name_hash(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__DojoModelImpl__namespace_hash(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = DojoModelImpl::namespace_hash(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__DojoModelImpl__unpacked_size(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = DojoModelImpl::unpacked_size(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::>::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__DojoModelImpl__packed_size(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = DojoModelImpl::packed_size(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::>::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__DojoModelImpl__layout(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = DojoModelImpl::layout(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__DojoModelImpl__schema(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = DojoModelImpl::schema(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__only_key_modelImpl__ensure_abi(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + let __arg_model = core::option::OptionTraitImpl::expect( + core::serde::Serde::::deserialize(ref data), + 'Failed to deserialize param #1' + ); + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + only_key_modelImpl::ensure_abi(@contract_state, __arg_model); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::array::ArrayTrait::span(@arr) +} + + +pub mod __external { + pub use super::__wrapper__DojoModelImpl__name as name; + pub use super::__wrapper__DojoModelImpl__namespace as namespace; + pub use super::__wrapper__DojoModelImpl__tag as tag; + pub use super::__wrapper__DojoModelImpl__version as version; + pub use super::__wrapper__DojoModelImpl__selector as selector; + pub use super::__wrapper__DojoModelImpl__name_hash as name_hash; + pub use super::__wrapper__DojoModelImpl__namespace_hash as namespace_hash; + pub use super::__wrapper__DojoModelImpl__unpacked_size as unpacked_size; + pub use super::__wrapper__DojoModelImpl__packed_size as packed_size; + pub use super::__wrapper__DojoModelImpl__layout as layout; + pub use super::__wrapper__DojoModelImpl__schema as schema; + pub use super::__wrapper__only_key_modelImpl__ensure_abi as ensure_abi; +} +pub mod __l1_handler { +} +pub mod __constructor { +} + impl ContractStateEventEmitter of starknet::event::EventEmitter< + ContractState, Event + > { + fn emit>( + ref self: ContractState, event: S + ) { + let event: Event = core::traits::Into::into(event); + let mut keys = Default::::default(); + let mut data = Default::::default(); + starknet::Event::append_keys_and_data(@event, ref keys, ref data); + starknet::SyscallResultTrait::unwrap_syscall( + starknet::syscalls::emit_event_syscall( + core::array::ArrayTrait::span(@keys), + core::array::ArrayTrait::span(@data), + ) + ) + } + } +impl EventDrop of core::traits::Drop::; +impl EventIsEvent of starknet::Event { + fn append_keys_and_data( + self: @Event, ref keys: Array, ref data: Array + ) { + match self { + } + } + fn deserialize( + ref keys: Span, ref data: Span, + ) -> Option { + let __selector__ = *core::array::SpanTrait::pop_front(ref keys)?; + Option::None + } +} +impl StorageStorageBaseDrop of core::traits::Drop::; +impl StorageStorageBaseCopy of core::traits::Copy::; +impl StorageStorageBaseMutDrop of core::traits::Drop::; +impl StorageStorageBaseMutCopy of core::traits::Copy::; +} + +impl U256KeyModelIntrospect<> of dojo::model::introspect::Introspect> { + #[inline(always)] + fn size() -> Option { + Option::None + } + + fn layout() -> dojo::model::Layout { + dojo::model::Layout::Struct( + array![ + + ].span() + ) + } + + #[inline(always)] + fn ty() -> dojo::model::introspect::Ty { + dojo::model::introspect::Ty::Struct( + dojo::model::introspect::Struct { + name: 'U256KeyModel', + attrs: array![].span(), + children: array![ + dojo::model::introspect::Member { + name: 'id', + attrs: array!['key'].span(), + ty: dojo::model::introspect::Introspect::::ty() + } + + ].span() + } + ) + } +} + +#[derive(Drop, Serde)] +pub struct U256KeyModelEntity { + __id: felt252, // private field + +} + +#[generate_trait] +pub impl U256KeyModelEntityStoreImpl of U256KeyModelEntityStore { + fn get(world: dojo::world::IWorldDispatcher, entity_id: felt252) -> U256KeyModelEntity { + U256KeyModelModelEntityImpl::get(world, entity_id) + } + + fn update(self: @U256KeyModelEntity, world: dojo::world::IWorldDispatcher) { + dojo::model::ModelEntity::::update_entity(self, world); + } + + fn delete(self: @U256KeyModelEntity, world: dojo::world::IWorldDispatcher) { + dojo::model::ModelEntity::::delete_entity(self, world); + } + + +} + +#[generate_trait] +pub impl U256KeyModelStoreImpl of U256KeyModelStore { + fn entity_id_from_keys(id: u256) -> felt252 { + let mut serialized = core::array::ArrayTrait::new(); + core::serde::Serde::serialize(@id, ref serialized); + + core::poseidon::poseidon_hash_span(serialized.span()) + } + + fn from_values(ref keys: Span, ref values: Span) -> U256KeyModel { + let mut serialized = core::array::ArrayTrait::new(); + serialized.append_span(keys); + serialized.append_span(values); + let mut serialized = core::array::ArrayTrait::span(@serialized); + + let entity = core::serde::Serde::::deserialize(ref serialized); + + if core::option::OptionTrait::::is_none(@entity) { + panic!( + "Model `U256KeyModel`: deserialization failed. Ensure the length of the keys tuple is matching the number of #[key] fields in the model struct." + ); + } + + core::option::OptionTrait::::unwrap(entity) + } + + fn get(world: dojo::world::IWorldDispatcher, id: u256) -> U256KeyModel { + let mut serialized = core::array::ArrayTrait::new(); + core::serde::Serde::serialize(@id, ref serialized); + + + dojo::model::Model::::get(world, serialized.span()) + } + + fn set(self: @U256KeyModel, world: dojo::world::IWorldDispatcher) { + dojo::model::Model::::set_model(self, world); + } + + fn delete(self: @U256KeyModel, world: dojo::world::IWorldDispatcher) { + dojo::model::Model::::delete_model(self, world); + } + + +} + +pub impl U256KeyModelModelEntityImpl of dojo::model::ModelEntity { + fn id(self: @U256KeyModelEntity) -> felt252 { + *self.__id + } + + fn values(self: @U256KeyModelEntity) -> Span { + let mut serialized = core::array::ArrayTrait::new(); + + core::array::ArrayTrait::span(@serialized) + } + + fn from_values(entity_id: felt252, ref values: Span) -> U256KeyModelEntity { + let mut serialized = array![entity_id]; + serialized.append_span(values); + let mut serialized = core::array::ArrayTrait::span(@serialized); + + let entity_values = core::serde::Serde::::deserialize(ref serialized); + if core::option::OptionTrait::::is_none(@entity_values) { + panic!( + "ModelEntity `U256KeyModelEntity`: deserialization failed." + ); + } + core::option::OptionTrait::::unwrap(entity_values) + } + + fn get(world: dojo::world::IWorldDispatcher, entity_id: felt252) -> U256KeyModelEntity { + let mut values = dojo::world::IWorldDispatcherTrait::entity( + world, + dojo::model::Model::::selector(), + dojo::model::ModelIndex::Id(entity_id), + dojo::model::Model::::layout() + ); + Self::from_values(entity_id, ref values) + } + + fn update_entity(self: @U256KeyModelEntity, world: dojo::world::IWorldDispatcher) { + dojo::world::IWorldDispatcherTrait::set_entity( + world, + dojo::model::Model::::selector(), + dojo::model::ModelIndex::Id(self.id()), + self.values(), + dojo::model::Model::::layout() + ); + } + + fn delete_entity(self: @U256KeyModelEntity, world: dojo::world::IWorldDispatcher) { + dojo::world::IWorldDispatcherTrait::delete_entity( + world, + dojo::model::Model::::selector(), + dojo::model::ModelIndex::Id(self.id()), + dojo::model::Model::::layout() + ); + } + + fn get_member( + world: dojo::world::IWorldDispatcher, + entity_id: felt252, + member_id: felt252, + ) -> Span { + match dojo::utils::find_model_field_layout(dojo::model::Model::::layout(), member_id) { + Option::Some(field_layout) => { + dojo::world::IWorldDispatcherTrait::entity( + world, + dojo::model::Model::::selector(), + dojo::model::ModelIndex::MemberId((entity_id, member_id)), + field_layout + ) + }, + Option::None => core::panic_with_felt252('bad member id') + } + } + + fn set_member( + self: @U256KeyModelEntity, + world: dojo::world::IWorldDispatcher, + member_id: felt252, + values: Span, + ) { + match dojo::utils::find_model_field_layout(dojo::model::Model::::layout(), member_id) { + Option::Some(field_layout) => { + dojo::world::IWorldDispatcherTrait::set_entity( + world, + dojo::model::Model::::selector(), + dojo::model::ModelIndex::MemberId((self.id(), member_id)), + values, + field_layout + ) + }, + Option::None => core::panic_with_felt252('bad member id') + } + } +} + +pub impl U256KeyModelModelImpl of dojo::model::Model { + fn get(world: dojo::world::IWorldDispatcher, keys: Span) -> U256KeyModel { + let mut values = dojo::world::IWorldDispatcherTrait::entity( + world, + Self::selector(), + dojo::model::ModelIndex::Keys(keys), + Self::layout() + ); + let mut _keys = keys; + + U256KeyModelStore::from_values(ref _keys, ref values) + } + + fn set_model( + self: @U256KeyModel, + world: dojo::world::IWorldDispatcher + ) { + dojo::world::IWorldDispatcherTrait::set_entity( + world, + Self::selector(), + dojo::model::ModelIndex::Keys(Self::keys(self)), + Self::values(self), + Self::layout() + ); + } + + fn delete_model( + self: @U256KeyModel, + world: dojo::world::IWorldDispatcher + ) { + dojo::world::IWorldDispatcherTrait::delete_entity( + world, + Self::selector(), + dojo::model::ModelIndex::Keys(Self::keys(self)), + Self::layout() + ); + } + + fn get_member( + world: dojo::world::IWorldDispatcher, + keys: Span, + member_id: felt252 + ) -> Span { + match dojo::utils::find_model_field_layout(Self::layout(), member_id) { + Option::Some(field_layout) => { + let entity_id = dojo::utils::entity_id_from_keys(keys); + dojo::world::IWorldDispatcherTrait::entity( + world, + Self::selector(), + dojo::model::ModelIndex::MemberId((entity_id, member_id)), + field_layout + ) + }, + Option::None => core::panic_with_felt252('bad member id') + } + } + + fn set_member( + self: @U256KeyModel, + world: dojo::world::IWorldDispatcher, + member_id: felt252, + values: Span + ) { + match dojo::utils::find_model_field_layout(Self::layout(), member_id) { + Option::Some(field_layout) => { + dojo::world::IWorldDispatcherTrait::set_entity( + world, + Self::selector(), + dojo::model::ModelIndex::MemberId((self.entity_id(), member_id)), + values, + field_layout + ) + }, + Option::None => core::panic_with_felt252('bad member id') + } + } + + #[inline(always)] + fn name() -> ByteArray { + "U256KeyModel" + } + + #[inline(always)] + fn namespace() -> ByteArray { + "dojo_test" + } + + #[inline(always)] + fn tag() -> ByteArray { + "dojo_test-U256KeyModel" + } + + #[inline(always)] + fn version() -> u8 { + 1 + } + + #[inline(always)] + fn selector() -> felt252 { + 2221887666320363067192826725795502610968343119143207326025439486865385474790 + } + + #[inline(always)] + fn instance_selector(self: @U256KeyModel) -> felt252 { + Self::selector() + } + + #[inline(always)] + fn name_hash() -> felt252 { + 1848733002266458148515852001373055968326209639346734967305014900020806934517 + } + + #[inline(always)] + fn namespace_hash() -> felt252 { + 1452123528942907587532668415362544424816022573043154497385993678618948064048 + } + + #[inline(always)] + fn entity_id(self: @U256KeyModel) -> felt252 { + core::poseidon::poseidon_hash_span(self.keys()) + } + + #[inline(always)] + fn keys(self: @U256KeyModel) -> Span { + let mut serialized = core::array::ArrayTrait::new(); + core::serde::Serde::serialize(self.id, ref serialized); + + core::array::ArrayTrait::span(@serialized) + } + + #[inline(always)] + fn values(self: @U256KeyModel) -> Span { + let mut serialized = core::array::ArrayTrait::new(); + + core::array::ArrayTrait::span(@serialized) + } + + #[inline(always)] + fn layout() -> dojo::model::Layout { + dojo::model::introspect::Introspect::::layout() + } + + #[inline(always)] + fn instance_layout(self: @U256KeyModel) -> dojo::model::Layout { + Self::layout() + } + + #[inline(always)] + fn packed_size() -> Option { + dojo::model::layout::compute_packed_size(Self::layout()) + } +} + +#[starknet::interface] +pub trait Iu_256_key_model { + fn ensure_abi(self: @T, model: U256KeyModel); +} + +#[starknet::contract] +pub mod u_256_key_model { + use super::U256KeyModel; + use super::Iu_256_key_model; + + #[abi(embed_v0)] + impl DojoModelImpl of dojo::model::IModel{ + fn name(self: @ContractState) -> ByteArray { + "U256KeyModel" + } + + fn namespace(self: @ContractState) -> ByteArray { + "dojo_test" + } + + fn tag(self: @ContractState) -> ByteArray { + "dojo_test-U256KeyModel" + } + + fn version(self: @ContractState) -> u8 { + 1 + } + + fn selector(self: @ContractState) -> felt252 { + 2221887666320363067192826725795502610968343119143207326025439486865385474790 + } + + fn name_hash(self: @ContractState) -> felt252 { + 1848733002266458148515852001373055968326209639346734967305014900020806934517 + } + + fn namespace_hash(self: @ContractState) -> felt252 { + 1452123528942907587532668415362544424816022573043154497385993678618948064048 + } + + fn unpacked_size(self: @ContractState) -> Option { + dojo::model::introspect::Introspect::::size() + } + + fn packed_size(self: @ContractState) -> Option { + dojo::model::Model::::packed_size() + } + + fn layout(self: @ContractState) -> dojo::model::Layout { + dojo::model::Model::::layout() + } + + fn schema(self: @ContractState) -> dojo::model::introspect::Ty { + dojo::model::introspect::Introspect::::ty() + } + } + + #[abi(embed_v0)] + impl u_256_key_modelImpl of Iu_256_key_model{ + fn ensure_abi(self: @ContractState, model: U256KeyModel) { + } + } +#[event] +#[derive(Drop, starknet::Event)] +pub enum Event {} + + +#[phantom] +pub struct Storage { +} + +#[derive(Drop, Copy)] +pub struct StorageStorageBase { +} +impl StorageStorageImpl of starknet::storage::StorageTrait { + type BaseType = StorageStorageBase; + fn storage(self: starknet::storage::FlattenedStorage) -> StorageStorageBase { + StorageStorageBase { + } + } +} +#[derive(Drop, Copy)] +pub struct StorageStorageBaseMut { +} +impl StorageStorageMutImpl of starknet::storage::StorageTraitMut { + type BaseType = StorageStorageBaseMut; + fn storage_mut(self: starknet::storage::FlattenedStorage>) -> StorageStorageBaseMut { + StorageStorageBaseMut { + } + } +} + +pub struct ContractState { +} + +impl ContractStateDrop of Drop {} + +impl ContractStateDeref of core::ops::SnapshotDeref { + type Target = starknet::storage::FlattenedStorage; + fn snapshot_deref(self: @ContractState) -> starknet::storage::FlattenedStorage { + starknet::storage::FlattenedStorage {} + } +} +impl ContractStateDerefMut of core::ops::DerefMut { + type Target = starknet::storage::FlattenedStorage> ; + fn deref_mut(ref self: ContractState) -> starknet::storage::FlattenedStorage> { + starknet::storage::FlattenedStorage {} + } +} +pub fn unsafe_new_contract_state() -> ContractState { + ContractState { + } +} + +// TODO(Gil): This generates duplicate diagnostics because of the plugin system, squash the duplicates into one. +#[deprecated( + feature: "deprecated_legacy_map", + note: "Use `starknet::storage::Map` instead." +)] +use starknet::storage::Map as LegacyMap; + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__DojoModelImpl__name(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = DojoModelImpl::name(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__DojoModelImpl__namespace(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = DojoModelImpl::namespace(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__DojoModelImpl__tag(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = DojoModelImpl::tag(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__DojoModelImpl__version(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = DojoModelImpl::version(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__DojoModelImpl__selector(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = DojoModelImpl::selector(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__DojoModelImpl__name_hash(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = DojoModelImpl::name_hash(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__DojoModelImpl__namespace_hash(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = DojoModelImpl::namespace_hash(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__DojoModelImpl__unpacked_size(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = DojoModelImpl::unpacked_size(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::>::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__DojoModelImpl__packed_size(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = DojoModelImpl::packed_size(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::>::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__DojoModelImpl__layout(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = DojoModelImpl::layout(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__DojoModelImpl__schema(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = DojoModelImpl::schema(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__u_256_key_modelImpl__ensure_abi(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + let __arg_model = core::option::OptionTraitImpl::expect( + core::serde::Serde::::deserialize(ref data), + 'Failed to deserialize param #1' + ); + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + u_256_key_modelImpl::ensure_abi(@contract_state, __arg_model); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::array::ArrayTrait::span(@arr) +} + + +pub mod __external { + pub use super::__wrapper__DojoModelImpl__name as name; + pub use super::__wrapper__DojoModelImpl__namespace as namespace; + pub use super::__wrapper__DojoModelImpl__tag as tag; + pub use super::__wrapper__DojoModelImpl__version as version; + pub use super::__wrapper__DojoModelImpl__selector as selector; + pub use super::__wrapper__DojoModelImpl__name_hash as name_hash; + pub use super::__wrapper__DojoModelImpl__namespace_hash as namespace_hash; + pub use super::__wrapper__DojoModelImpl__unpacked_size as unpacked_size; + pub use super::__wrapper__DojoModelImpl__packed_size as packed_size; + pub use super::__wrapper__DojoModelImpl__layout as layout; + pub use super::__wrapper__DojoModelImpl__schema as schema; + pub use super::__wrapper__u_256_key_modelImpl__ensure_abi as ensure_abi; +} +pub mod __l1_handler { +} +pub mod __constructor { +} + impl ContractStateEventEmitter of starknet::event::EventEmitter< + ContractState, Event + > { + fn emit>( + ref self: ContractState, event: S + ) { + let event: Event = core::traits::Into::into(event); + let mut keys = Default::::default(); + let mut data = Default::::default(); + starknet::Event::append_keys_and_data(@event, ref keys, ref data); + starknet::SyscallResultTrait::unwrap_syscall( + starknet::syscalls::emit_event_syscall( + core::array::ArrayTrait::span(@keys), + core::array::ArrayTrait::span(@data), + ) + ) + } + } +impl EventDrop of core::traits::Drop::; +impl EventIsEvent of starknet::Event { + fn append_keys_and_data( + self: @Event, ref keys: Array, ref data: Array + ) { + match self { + } + } + fn deserialize( + ref keys: Span, ref data: Span, + ) -> Option { + let __selector__ = *core::array::SpanTrait::pop_front(ref keys)?; + Option::None + } +} +impl StorageStorageBaseDrop of core::traits::Drop::; +impl StorageStorageBaseCopy of core::traits::Copy::; +impl StorageStorageBaseMutDrop of core::traits::Drop::; +impl StorageStorageBaseMutCopy of core::traits::Copy::; +} + +impl PlayerIntrospect<> of dojo::model::introspect::Introspect> { + #[inline(always)] + fn size() -> Option { + Option::Some(1) + } + + fn layout() -> dojo::model::Layout { + dojo::model::Layout::Struct( + array![ + dojo::model::FieldLayout { + selector: 1528802474226268325865027367859591458315299653151958663884057507666229546336, + layout: dojo::model::introspect::Introspect::::layout() + } + ].span() + ) + } + + #[inline(always)] + fn ty() -> dojo::model::introspect::Ty { + dojo::model::introspect::Ty::Struct( + dojo::model::introspect::Struct { + name: 'Player', + attrs: array![].span(), + children: array![ + dojo::model::introspect::Member { + name: 'game', + attrs: array!['key'].span(), + ty: dojo::model::introspect::Introspect::::ty() + }, +dojo::model::introspect::Member { + name: 'player', + attrs: array!['key'].span(), + ty: dojo::model::introspect::Introspect::::ty() + }, +dojo::model::introspect::Member { + name: 'name', + attrs: array![].span(), + ty: dojo::model::introspect::Introspect::::ty() + } + + ].span() + } + ) + } +} + +#[derive(Drop, Serde)] +pub struct PlayerEntity { + __id: felt252, // private field + pub name: felt252, + +} + +#[generate_trait] +pub impl PlayerEntityStoreImpl of PlayerEntityStore { + fn get(world: dojo::world::IWorldDispatcher, entity_id: felt252) -> PlayerEntity { + PlayerModelEntityImpl::get(world, entity_id) + } + + fn update(self: @PlayerEntity, world: dojo::world::IWorldDispatcher) { + dojo::model::ModelEntity::::update_entity(self, world); + } + + fn delete(self: @PlayerEntity, world: dojo::world::IWorldDispatcher) { + dojo::model::ModelEntity::::delete_entity(self, world); + } + + + fn get_name(world: dojo::world::IWorldDispatcher, entity_id: felt252) -> felt252 { + let mut values = dojo::model::ModelEntity::::get_member( + world, + entity_id, + 1528802474226268325865027367859591458315299653151958663884057507666229546336 + ); + let field_value = core::serde::Serde::::deserialize(ref values); + + if core::option::OptionTrait::::is_none(@field_value) { + panic!( + "Field `Player::name`: deserialization failed." + ); + } + + core::option::OptionTrait::::unwrap(field_value) + } + + fn set_name(self: @PlayerEntity, world: dojo::world::IWorldDispatcher, value: felt252) { + let mut serialized = core::array::ArrayTrait::new(); + core::serde::Serde::serialize(@value, ref serialized); + + self.set_member( + world, + 1528802474226268325865027367859591458315299653151958663884057507666229546336, + serialized.span() + ); + } + +} + +#[generate_trait] +pub impl PlayerStoreImpl of PlayerStore { + fn entity_id_from_keys(game: felt252, player: ContractAddress) -> felt252 { + let mut serialized = core::array::ArrayTrait::new(); + core::array::ArrayTrait::append(ref serialized, game); +core::serde::Serde::serialize(@player, ref serialized); + + core::poseidon::poseidon_hash_span(serialized.span()) + } + + fn from_values(ref keys: Span, ref values: Span) -> Player { + let mut serialized = core::array::ArrayTrait::new(); + serialized.append_span(keys); + serialized.append_span(values); + let mut serialized = core::array::ArrayTrait::span(@serialized); + + let entity = core::serde::Serde::::deserialize(ref serialized); + + if core::option::OptionTrait::::is_none(@entity) { + panic!( + "Model `Player`: deserialization failed. Ensure the length of the keys tuple is matching the number of #[key] fields in the model struct." + ); + } + + core::option::OptionTrait::::unwrap(entity) + } + + fn get(world: dojo::world::IWorldDispatcher, game: felt252, player: ContractAddress) -> Player { + let mut serialized = core::array::ArrayTrait::new(); + core::array::ArrayTrait::append(ref serialized, game); +core::serde::Serde::serialize(@player, ref serialized); + + + dojo::model::Model::::get(world, serialized.span()) + } + + fn set(self: @Player, world: dojo::world::IWorldDispatcher) { + dojo::model::Model::::set_model(self, world); + } + + fn delete(self: @Player, world: dojo::world::IWorldDispatcher) { + dojo::model::Model::::delete_model(self, world); + } + + + fn get_name(world: dojo::world::IWorldDispatcher, game: felt252, player: ContractAddress) -> felt252 { + let mut serialized = core::array::ArrayTrait::new(); + core::array::ArrayTrait::append(ref serialized, game); +core::serde::Serde::serialize(@player, ref serialized); + + + let mut values = dojo::model::Model::::get_member( + world, + serialized.span(), + 1528802474226268325865027367859591458315299653151958663884057507666229546336 + ); + + let field_value = core::serde::Serde::::deserialize(ref values); + + if core::option::OptionTrait::::is_none(@field_value) { + panic!( + "Field `Player::name`: deserialization failed." + ); + } + + core::option::OptionTrait::::unwrap(field_value) + } + + fn set_name(self: @Player, world: dojo::world::IWorldDispatcher, value: felt252) { + let mut serialized = core::array::ArrayTrait::new(); + core::serde::Serde::serialize(@value, ref serialized); + + self.set_member( + world, + 1528802474226268325865027367859591458315299653151958663884057507666229546336, + serialized.span() + ); + } + +} + +pub impl PlayerModelEntityImpl of dojo::model::ModelEntity { + fn id(self: @PlayerEntity) -> felt252 { + *self.__id + } + + fn values(self: @PlayerEntity) -> Span { + let mut serialized = core::array::ArrayTrait::new(); + core::array::ArrayTrait::append(ref serialized, *self.name); + + core::array::ArrayTrait::span(@serialized) + } + + fn from_values(entity_id: felt252, ref values: Span) -> PlayerEntity { + let mut serialized = array![entity_id]; + serialized.append_span(values); + let mut serialized = core::array::ArrayTrait::span(@serialized); + + let entity_values = core::serde::Serde::::deserialize(ref serialized); + if core::option::OptionTrait::::is_none(@entity_values) { + panic!( + "ModelEntity `PlayerEntity`: deserialization failed." + ); + } + core::option::OptionTrait::::unwrap(entity_values) + } + + fn get(world: dojo::world::IWorldDispatcher, entity_id: felt252) -> PlayerEntity { + let mut values = dojo::world::IWorldDispatcherTrait::entity( + world, + dojo::model::Model::::selector(), + dojo::model::ModelIndex::Id(entity_id), + dojo::model::Model::::layout() + ); + Self::from_values(entity_id, ref values) + } + + fn update_entity(self: @PlayerEntity, world: dojo::world::IWorldDispatcher) { + dojo::world::IWorldDispatcherTrait::set_entity( + world, + dojo::model::Model::::selector(), + dojo::model::ModelIndex::Id(self.id()), + self.values(), + dojo::model::Model::::layout() + ); + } + + fn delete_entity(self: @PlayerEntity, world: dojo::world::IWorldDispatcher) { + dojo::world::IWorldDispatcherTrait::delete_entity( + world, + dojo::model::Model::::selector(), + dojo::model::ModelIndex::Id(self.id()), + dojo::model::Model::::layout() + ); + } + + fn get_member( + world: dojo::world::IWorldDispatcher, + entity_id: felt252, + member_id: felt252, + ) -> Span { + match dojo::utils::find_model_field_layout(dojo::model::Model::::layout(), member_id) { + Option::Some(field_layout) => { + dojo::world::IWorldDispatcherTrait::entity( + world, + dojo::model::Model::::selector(), + dojo::model::ModelIndex::MemberId((entity_id, member_id)), + field_layout + ) + }, + Option::None => core::panic_with_felt252('bad member id') + } + } + + fn set_member( + self: @PlayerEntity, + world: dojo::world::IWorldDispatcher, + member_id: felt252, + values: Span, + ) { + match dojo::utils::find_model_field_layout(dojo::model::Model::::layout(), member_id) { + Option::Some(field_layout) => { + dojo::world::IWorldDispatcherTrait::set_entity( + world, + dojo::model::Model::::selector(), + dojo::model::ModelIndex::MemberId((self.id(), member_id)), + values, + field_layout + ) + }, + Option::None => core::panic_with_felt252('bad member id') + } + } +} + +pub impl PlayerModelImpl of dojo::model::Model { + fn get(world: dojo::world::IWorldDispatcher, keys: Span) -> Player { + let mut values = dojo::world::IWorldDispatcherTrait::entity( + world, + Self::selector(), + dojo::model::ModelIndex::Keys(keys), + Self::layout() + ); + let mut _keys = keys; + + PlayerStore::from_values(ref _keys, ref values) + } + + fn set_model( + self: @Player, + world: dojo::world::IWorldDispatcher + ) { + dojo::world::IWorldDispatcherTrait::set_entity( + world, + Self::selector(), + dojo::model::ModelIndex::Keys(Self::keys(self)), + Self::values(self), + Self::layout() + ); + } + + fn delete_model( + self: @Player, + world: dojo::world::IWorldDispatcher + ) { + dojo::world::IWorldDispatcherTrait::delete_entity( + world, + Self::selector(), + dojo::model::ModelIndex::Keys(Self::keys(self)), + Self::layout() + ); + } + + fn get_member( + world: dojo::world::IWorldDispatcher, + keys: Span, + member_id: felt252 + ) -> Span { + match dojo::utils::find_model_field_layout(Self::layout(), member_id) { + Option::Some(field_layout) => { + let entity_id = dojo::utils::entity_id_from_keys(keys); + dojo::world::IWorldDispatcherTrait::entity( + world, + Self::selector(), + dojo::model::ModelIndex::MemberId((entity_id, member_id)), + field_layout + ) + }, + Option::None => core::panic_with_felt252('bad member id') + } + } + + fn set_member( + self: @Player, + world: dojo::world::IWorldDispatcher, + member_id: felt252, + values: Span + ) { + match dojo::utils::find_model_field_layout(Self::layout(), member_id) { + Option::Some(field_layout) => { + dojo::world::IWorldDispatcherTrait::set_entity( + world, + Self::selector(), + dojo::model::ModelIndex::MemberId((self.entity_id(), member_id)), + values, + field_layout + ) + }, + Option::None => core::panic_with_felt252('bad member id') + } + } + + #[inline(always)] + fn name() -> ByteArray { + "Player" + } + + #[inline(always)] + fn namespace() -> ByteArray { + "dojo_test" + } + + #[inline(always)] + fn tag() -> ByteArray { + "dojo_test-Player" + } + + #[inline(always)] + fn version() -> u8 { + 1 + } + + #[inline(always)] + fn selector() -> felt252 { + 32472305970791489884889070587064570056671760620943135506258424375410423946 + } + + #[inline(always)] + fn instance_selector(self: @Player) -> felt252 { + Self::selector() + } + + #[inline(always)] + fn name_hash() -> felt252 { + 1073075359926275415180704315933677548333097210683379121732618306925003101845 + } + + #[inline(always)] + fn namespace_hash() -> felt252 { + 1452123528942907587532668415362544424816022573043154497385993678618948064048 + } + + #[inline(always)] + fn entity_id(self: @Player) -> felt252 { + core::poseidon::poseidon_hash_span(self.keys()) + } + + #[inline(always)] + fn keys(self: @Player) -> Span { + let mut serialized = core::array::ArrayTrait::new(); + core::array::ArrayTrait::append(ref serialized, *self.game); +core::serde::Serde::serialize(self.player, ref serialized); + + core::array::ArrayTrait::span(@serialized) + } + + #[inline(always)] + fn values(self: @Player) -> Span { + let mut serialized = core::array::ArrayTrait::new(); + core::array::ArrayTrait::append(ref serialized, *self.name); + + core::array::ArrayTrait::span(@serialized) + } + + #[inline(always)] + fn layout() -> dojo::model::Layout { + dojo::model::introspect::Introspect::::layout() + } + + #[inline(always)] + fn instance_layout(self: @Player) -> dojo::model::Layout { + Self::layout() + } + + #[inline(always)] + fn packed_size() -> Option { + dojo::model::layout::compute_packed_size(Self::layout()) + } +} + +#[starknet::interface] +pub trait Iplayer { + fn ensure_abi(self: @T, model: Player); +} + +#[starknet::contract] +pub mod player { + use super::Player; + use super::Iplayer; + + #[abi(embed_v0)] + impl DojoModelImpl of dojo::model::IModel{ + fn name(self: @ContractState) -> ByteArray { + "Player" + } + + fn namespace(self: @ContractState) -> ByteArray { + "dojo_test" + } + + fn tag(self: @ContractState) -> ByteArray { + "dojo_test-Player" + } + + fn version(self: @ContractState) -> u8 { + 1 + } + + fn selector(self: @ContractState) -> felt252 { + 32472305970791489884889070587064570056671760620943135506258424375410423946 + } + + fn name_hash(self: @ContractState) -> felt252 { + 1073075359926275415180704315933677548333097210683379121732618306925003101845 + } + + fn namespace_hash(self: @ContractState) -> felt252 { + 1452123528942907587532668415362544424816022573043154497385993678618948064048 + } + + fn unpacked_size(self: @ContractState) -> Option { + dojo::model::introspect::Introspect::::size() + } + + fn packed_size(self: @ContractState) -> Option { + dojo::model::Model::::packed_size() + } + + fn layout(self: @ContractState) -> dojo::model::Layout { + dojo::model::Model::::layout() + } + + fn schema(self: @ContractState) -> dojo::model::introspect::Ty { + dojo::model::introspect::Introspect::::ty() + } + } + + #[abi(embed_v0)] + impl playerImpl of Iplayer{ + fn ensure_abi(self: @ContractState, model: Player) { + } + } +#[event] +#[derive(Drop, starknet::Event)] +pub enum Event {} + + +#[phantom] +pub struct Storage { +} + +#[derive(Drop, Copy)] +pub struct StorageStorageBase { +} +impl StorageStorageImpl of starknet::storage::StorageTrait { + type BaseType = StorageStorageBase; + fn storage(self: starknet::storage::FlattenedStorage) -> StorageStorageBase { + StorageStorageBase { + } + } +} +#[derive(Drop, Copy)] +pub struct StorageStorageBaseMut { +} +impl StorageStorageMutImpl of starknet::storage::StorageTraitMut { + type BaseType = StorageStorageBaseMut; + fn storage_mut(self: starknet::storage::FlattenedStorage>) -> StorageStorageBaseMut { + StorageStorageBaseMut { + } + } +} + +pub struct ContractState { +} + +impl ContractStateDrop of Drop {} + +impl ContractStateDeref of core::ops::SnapshotDeref { + type Target = starknet::storage::FlattenedStorage; + fn snapshot_deref(self: @ContractState) -> starknet::storage::FlattenedStorage { + starknet::storage::FlattenedStorage {} + } +} +impl ContractStateDerefMut of core::ops::DerefMut { + type Target = starknet::storage::FlattenedStorage> ; + fn deref_mut(ref self: ContractState) -> starknet::storage::FlattenedStorage> { + starknet::storage::FlattenedStorage {} + } +} +pub fn unsafe_new_contract_state() -> ContractState { + ContractState { + } +} + +// TODO(Gil): This generates duplicate diagnostics because of the plugin system, squash the duplicates into one. +#[deprecated( + feature: "deprecated_legacy_map", + note: "Use `starknet::storage::Map` instead." +)] +use starknet::storage::Map as LegacyMap; + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__DojoModelImpl__name(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = DojoModelImpl::name(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__DojoModelImpl__namespace(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = DojoModelImpl::namespace(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__DojoModelImpl__tag(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = DojoModelImpl::tag(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__DojoModelImpl__version(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = DojoModelImpl::version(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__DojoModelImpl__selector(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = DojoModelImpl::selector(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__DojoModelImpl__name_hash(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = DojoModelImpl::name_hash(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__DojoModelImpl__namespace_hash(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = DojoModelImpl::namespace_hash(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__DojoModelImpl__unpacked_size(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = DojoModelImpl::unpacked_size(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::>::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__DojoModelImpl__packed_size(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = DojoModelImpl::packed_size(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::>::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__DojoModelImpl__layout(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = DojoModelImpl::layout(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__DojoModelImpl__schema(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = DojoModelImpl::schema(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__playerImpl__ensure_abi(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + let __arg_model = core::option::OptionTraitImpl::expect( + core::serde::Serde::::deserialize(ref data), + 'Failed to deserialize param #1' + ); + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + playerImpl::ensure_abi(@contract_state, __arg_model); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::array::ArrayTrait::span(@arr) +} + + +pub mod __external { + pub use super::__wrapper__DojoModelImpl__name as name; + pub use super::__wrapper__DojoModelImpl__namespace as namespace; + pub use super::__wrapper__DojoModelImpl__tag as tag; + pub use super::__wrapper__DojoModelImpl__version as version; + pub use super::__wrapper__DojoModelImpl__selector as selector; + pub use super::__wrapper__DojoModelImpl__name_hash as name_hash; + pub use super::__wrapper__DojoModelImpl__namespace_hash as namespace_hash; + pub use super::__wrapper__DojoModelImpl__unpacked_size as unpacked_size; + pub use super::__wrapper__DojoModelImpl__packed_size as packed_size; + pub use super::__wrapper__DojoModelImpl__layout as layout; + pub use super::__wrapper__DojoModelImpl__schema as schema; + pub use super::__wrapper__playerImpl__ensure_abi as ensure_abi; +} +pub mod __l1_handler { +} +pub mod __constructor { +} + impl ContractStateEventEmitter of starknet::event::EventEmitter< + ContractState, Event + > { + fn emit>( + ref self: ContractState, event: S + ) { + let event: Event = core::traits::Into::into(event); + let mut keys = Default::::default(); + let mut data = Default::::default(); + starknet::Event::append_keys_and_data(@event, ref keys, ref data); + starknet::SyscallResultTrait::unwrap_syscall( + starknet::syscalls::emit_event_syscall( + core::array::ArrayTrait::span(@keys), + core::array::ArrayTrait::span(@data), + ) + ) + } + } +impl EventDrop of core::traits::Drop::; +impl EventIsEvent of starknet::Event { + fn append_keys_and_data( + self: @Event, ref keys: Array, ref data: Array + ) { + match self { + } + } + fn deserialize( + ref keys: Span, ref data: Span, + ) -> Option { + let __selector__ = *core::array::SpanTrait::pop_front(ref keys)?; + Option::None + } +} +impl StorageStorageBaseDrop of core::traits::Drop::; +impl StorageStorageBaseCopy of core::traits::Copy::; +impl StorageStorageBaseMutDrop of core::traits::Drop::; +impl StorageStorageBaseMutCopy of core::traits::Copy::; +} + +impl ModelWithSimpleArrayIntrospect<> of dojo::model::introspect::Introspect> { + #[inline(always)] + fn size() -> Option { + Option::None + } + + fn layout() -> dojo::model::Layout { + dojo::model::Layout::Struct( + array![ + dojo::model::FieldLayout { + selector: 512066735765477566404754172672287371265995314501343422459174036873487219331, + layout: dojo::model::introspect::Introspect::::layout() + }, +dojo::model::FieldLayout { + selector: 1591024729085637502504777720563487898377940395575083379770417352976841400819, + layout: dojo::model::introspect::Introspect:: +>::layout() + } + ].span() + ) + } + + #[inline(always)] + fn ty() -> dojo::model::introspect::Ty { + dojo::model::introspect::Ty::Struct( + dojo::model::introspect::Struct { + name: 'ModelWithSimpleArray', + attrs: array![].span(), + children: array![ + dojo::model::introspect::Member { + name: 'player', + attrs: array!['key'].span(), + ty: dojo::model::introspect::Introspect::::ty() + }, +dojo::model::introspect::Member { + name: 'x', + attrs: array![].span(), + ty: dojo::model::introspect::Introspect::::ty() + }, +dojo::model::introspect::Member { + name: 'y', + attrs: array![].span(), + ty: dojo::model::introspect::Ty::Array( + array![ + dojo::model::introspect::Introspect::::ty() + ].span() + ) + } + + ].span() + } + ) + } +} + +#[derive(Drop, Serde)] +pub struct ModelWithSimpleArrayEntity { + __id: felt252, // private field + pub x: u16, +pub y: Array, + +} + +#[generate_trait] +pub impl ModelWithSimpleArrayEntityStoreImpl of ModelWithSimpleArrayEntityStore { + fn get(world: dojo::world::IWorldDispatcher, entity_id: felt252) -> ModelWithSimpleArrayEntity { + ModelWithSimpleArrayModelEntityImpl::get(world, entity_id) + } + + fn update(self: @ModelWithSimpleArrayEntity, world: dojo::world::IWorldDispatcher) { + dojo::model::ModelEntity::::update_entity(self, world); + } + + fn delete(self: @ModelWithSimpleArrayEntity, world: dojo::world::IWorldDispatcher) { + dojo::model::ModelEntity::::delete_entity(self, world); + } + + + fn get_x(world: dojo::world::IWorldDispatcher, entity_id: felt252) -> u16 { + let mut values = dojo::model::ModelEntity::::get_member( + world, + entity_id, + 512066735765477566404754172672287371265995314501343422459174036873487219331 + ); + let field_value = core::serde::Serde::::deserialize(ref values); + + if core::option::OptionTrait::::is_none(@field_value) { + panic!( + "Field `ModelWithSimpleArray::x`: deserialization failed." + ); + } + + core::option::OptionTrait::::unwrap(field_value) + } + + fn set_x(self: @ModelWithSimpleArrayEntity, world: dojo::world::IWorldDispatcher, value: u16) { + let mut serialized = core::array::ArrayTrait::new(); + core::serde::Serde::serialize(@value, ref serialized); + + self.set_member( + world, + 512066735765477566404754172672287371265995314501343422459174036873487219331, + serialized.span() + ); + } + + fn get_y(world: dojo::world::IWorldDispatcher, entity_id: felt252) -> Array { + let mut values = dojo::model::ModelEntity::::get_member( + world, + entity_id, + 1591024729085637502504777720563487898377940395575083379770417352976841400819 + ); + let field_value = core::serde::Serde::>::deserialize(ref values); + + if core::option::OptionTrait::>::is_none(@field_value) { + panic!( + "Field `ModelWithSimpleArray::y`: deserialization failed." + ); + } + + core::option::OptionTrait::>::unwrap(field_value) + } + + fn set_y(self: @ModelWithSimpleArrayEntity, world: dojo::world::IWorldDispatcher, value: Array) { + let mut serialized = core::array::ArrayTrait::new(); + core::serde::Serde::serialize(@value, ref serialized); + + self.set_member( + world, + 1591024729085637502504777720563487898377940395575083379770417352976841400819, + serialized.span() + ); + } + +} + +#[generate_trait] +pub impl ModelWithSimpleArrayStoreImpl of ModelWithSimpleArrayStore { + fn entity_id_from_keys(player: ContractAddress) -> felt252 { + let mut serialized = core::array::ArrayTrait::new(); + core::serde::Serde::serialize(@player, ref serialized); + + core::poseidon::poseidon_hash_span(serialized.span()) + } + + fn from_values(ref keys: Span, ref values: Span) -> ModelWithSimpleArray { + let mut serialized = core::array::ArrayTrait::new(); + serialized.append_span(keys); + serialized.append_span(values); + let mut serialized = core::array::ArrayTrait::span(@serialized); + + let entity = core::serde::Serde::::deserialize(ref serialized); + + if core::option::OptionTrait::::is_none(@entity) { + panic!( + "Model `ModelWithSimpleArray`: deserialization failed. Ensure the length of the keys tuple is matching the number of #[key] fields in the model struct." + ); + } + + core::option::OptionTrait::::unwrap(entity) + } + + fn get(world: dojo::world::IWorldDispatcher, player: ContractAddress) -> ModelWithSimpleArray { + let mut serialized = core::array::ArrayTrait::new(); + core::serde::Serde::serialize(@player, ref serialized); + + + dojo::model::Model::::get(world, serialized.span()) + } + + fn set(self: @ModelWithSimpleArray, world: dojo::world::IWorldDispatcher) { + dojo::model::Model::::set_model(self, world); + } + + fn delete(self: @ModelWithSimpleArray, world: dojo::world::IWorldDispatcher) { + dojo::model::Model::::delete_model(self, world); + } + + + fn get_x(world: dojo::world::IWorldDispatcher, player: ContractAddress) -> u16 { + let mut serialized = core::array::ArrayTrait::new(); + core::serde::Serde::serialize(@player, ref serialized); + + + let mut values = dojo::model::Model::::get_member( + world, + serialized.span(), + 512066735765477566404754172672287371265995314501343422459174036873487219331 + ); + + let field_value = core::serde::Serde::::deserialize(ref values); + + if core::option::OptionTrait::::is_none(@field_value) { + panic!( + "Field `ModelWithSimpleArray::x`: deserialization failed." + ); + } + + core::option::OptionTrait::::unwrap(field_value) + } + + fn set_x(self: @ModelWithSimpleArray, world: dojo::world::IWorldDispatcher, value: u16) { + let mut serialized = core::array::ArrayTrait::new(); + core::serde::Serde::serialize(@value, ref serialized); + + self.set_member( + world, + 512066735765477566404754172672287371265995314501343422459174036873487219331, + serialized.span() + ); + } + + fn get_y(world: dojo::world::IWorldDispatcher, player: ContractAddress) -> Array { + let mut serialized = core::array::ArrayTrait::new(); + core::serde::Serde::serialize(@player, ref serialized); + + + let mut values = dojo::model::Model::::get_member( + world, + serialized.span(), + 1591024729085637502504777720563487898377940395575083379770417352976841400819 + ); + + let field_value = core::serde::Serde::>::deserialize(ref values); + + if core::option::OptionTrait::>::is_none(@field_value) { + panic!( + "Field `ModelWithSimpleArray::y`: deserialization failed." + ); + } + + core::option::OptionTrait::>::unwrap(field_value) + } + + fn set_y(self: @ModelWithSimpleArray, world: dojo::world::IWorldDispatcher, value: Array) { + let mut serialized = core::array::ArrayTrait::new(); + core::serde::Serde::serialize(@value, ref serialized); + + self.set_member( + world, + 1591024729085637502504777720563487898377940395575083379770417352976841400819, + serialized.span() + ); + } + +} + +pub impl ModelWithSimpleArrayModelEntityImpl of dojo::model::ModelEntity { + fn id(self: @ModelWithSimpleArrayEntity) -> felt252 { + *self.__id + } + + fn values(self: @ModelWithSimpleArrayEntity) -> Span { + let mut serialized = core::array::ArrayTrait::new(); + core::serde::Serde::serialize(self.x, ref serialized); +core::serde::Serde::serialize(self.y, ref serialized); + + core::array::ArrayTrait::span(@serialized) + } + + fn from_values(entity_id: felt252, ref values: Span) -> ModelWithSimpleArrayEntity { + let mut serialized = array![entity_id]; + serialized.append_span(values); + let mut serialized = core::array::ArrayTrait::span(@serialized); + + let entity_values = core::serde::Serde::::deserialize(ref serialized); + if core::option::OptionTrait::::is_none(@entity_values) { + panic!( + "ModelEntity `ModelWithSimpleArrayEntity`: deserialization failed." + ); + } + core::option::OptionTrait::::unwrap(entity_values) + } + + fn get(world: dojo::world::IWorldDispatcher, entity_id: felt252) -> ModelWithSimpleArrayEntity { + let mut values = dojo::world::IWorldDispatcherTrait::entity( + world, + dojo::model::Model::::selector(), + dojo::model::ModelIndex::Id(entity_id), + dojo::model::Model::::layout() + ); + Self::from_values(entity_id, ref values) + } + + fn update_entity(self: @ModelWithSimpleArrayEntity, world: dojo::world::IWorldDispatcher) { + dojo::world::IWorldDispatcherTrait::set_entity( + world, + dojo::model::Model::::selector(), + dojo::model::ModelIndex::Id(self.id()), + self.values(), + dojo::model::Model::::layout() + ); + } + + fn delete_entity(self: @ModelWithSimpleArrayEntity, world: dojo::world::IWorldDispatcher) { + dojo::world::IWorldDispatcherTrait::delete_entity( + world, + dojo::model::Model::::selector(), + dojo::model::ModelIndex::Id(self.id()), + dojo::model::Model::::layout() + ); + } + + fn get_member( + world: dojo::world::IWorldDispatcher, + entity_id: felt252, + member_id: felt252, + ) -> Span { + match dojo::utils::find_model_field_layout(dojo::model::Model::::layout(), member_id) { + Option::Some(field_layout) => { + dojo::world::IWorldDispatcherTrait::entity( + world, + dojo::model::Model::::selector(), + dojo::model::ModelIndex::MemberId((entity_id, member_id)), + field_layout + ) + }, + Option::None => core::panic_with_felt252('bad member id') + } + } + + fn set_member( + self: @ModelWithSimpleArrayEntity, + world: dojo::world::IWorldDispatcher, + member_id: felt252, + values: Span, + ) { + match dojo::utils::find_model_field_layout(dojo::model::Model::::layout(), member_id) { + Option::Some(field_layout) => { + dojo::world::IWorldDispatcherTrait::set_entity( + world, + dojo::model::Model::::selector(), + dojo::model::ModelIndex::MemberId((self.id(), member_id)), + values, + field_layout + ) + }, + Option::None => core::panic_with_felt252('bad member id') + } + } +} + +pub impl ModelWithSimpleArrayModelImpl of dojo::model::Model { + fn get(world: dojo::world::IWorldDispatcher, keys: Span) -> ModelWithSimpleArray { + let mut values = dojo::world::IWorldDispatcherTrait::entity( + world, + Self::selector(), + dojo::model::ModelIndex::Keys(keys), + Self::layout() + ); + let mut _keys = keys; + + ModelWithSimpleArrayStore::from_values(ref _keys, ref values) + } + + fn set_model( + self: @ModelWithSimpleArray, + world: dojo::world::IWorldDispatcher + ) { + dojo::world::IWorldDispatcherTrait::set_entity( + world, + Self::selector(), + dojo::model::ModelIndex::Keys(Self::keys(self)), + Self::values(self), + Self::layout() + ); + } + + fn delete_model( + self: @ModelWithSimpleArray, + world: dojo::world::IWorldDispatcher + ) { + dojo::world::IWorldDispatcherTrait::delete_entity( + world, + Self::selector(), + dojo::model::ModelIndex::Keys(Self::keys(self)), + Self::layout() + ); + } + + fn get_member( + world: dojo::world::IWorldDispatcher, + keys: Span, + member_id: felt252 + ) -> Span { + match dojo::utils::find_model_field_layout(Self::layout(), member_id) { + Option::Some(field_layout) => { + let entity_id = dojo::utils::entity_id_from_keys(keys); + dojo::world::IWorldDispatcherTrait::entity( + world, + Self::selector(), + dojo::model::ModelIndex::MemberId((entity_id, member_id)), + field_layout + ) + }, + Option::None => core::panic_with_felt252('bad member id') + } + } + + fn set_member( + self: @ModelWithSimpleArray, + world: dojo::world::IWorldDispatcher, + member_id: felt252, + values: Span + ) { + match dojo::utils::find_model_field_layout(Self::layout(), member_id) { + Option::Some(field_layout) => { + dojo::world::IWorldDispatcherTrait::set_entity( + world, + Self::selector(), + dojo::model::ModelIndex::MemberId((self.entity_id(), member_id)), + values, + field_layout + ) + }, + Option::None => core::panic_with_felt252('bad member id') + } + } + + #[inline(always)] + fn name() -> ByteArray { + "ModelWithSimpleArray" + } + + #[inline(always)] + fn namespace() -> ByteArray { + "dojo_test" + } + + #[inline(always)] + fn tag() -> ByteArray { + "dojo_test-ModelWithSimpleArray" + } + + #[inline(always)] + fn version() -> u8 { + 1 + } + + #[inline(always)] + fn selector() -> felt252 { + 2155888289741706273257207428305937938996511115291276975807216945184181752777 + } + + #[inline(always)] + fn instance_selector(self: @ModelWithSimpleArray) -> felt252 { + Self::selector() + } + + #[inline(always)] + fn name_hash() -> felt252 { + 173141902001925402715103859951360389436088950156916962046507357841237663931 + } + + #[inline(always)] + fn namespace_hash() -> felt252 { + 1452123528942907587532668415362544424816022573043154497385993678618948064048 + } + + #[inline(always)] + fn entity_id(self: @ModelWithSimpleArray) -> felt252 { + core::poseidon::poseidon_hash_span(self.keys()) + } + + #[inline(always)] + fn keys(self: @ModelWithSimpleArray) -> Span { + let mut serialized = core::array::ArrayTrait::new(); + core::serde::Serde::serialize(self.player, ref serialized); + + core::array::ArrayTrait::span(@serialized) + } + + #[inline(always)] + fn values(self: @ModelWithSimpleArray) -> Span { + let mut serialized = core::array::ArrayTrait::new(); + core::serde::Serde::serialize(self.x, ref serialized); +core::serde::Serde::serialize(self.y, ref serialized); + + core::array::ArrayTrait::span(@serialized) + } + + #[inline(always)] + fn layout() -> dojo::model::Layout { + dojo::model::introspect::Introspect::::layout() + } + + #[inline(always)] + fn instance_layout(self: @ModelWithSimpleArray) -> dojo::model::Layout { + Self::layout() + } + + #[inline(always)] + fn packed_size() -> Option { + dojo::model::layout::compute_packed_size(Self::layout()) + } +} + +#[starknet::interface] +pub trait Imodel_with_simple_array { + fn ensure_abi(self: @T, model: ModelWithSimpleArray); +} + +#[starknet::contract] +pub mod model_with_simple_array { + use super::ModelWithSimpleArray; + use super::Imodel_with_simple_array; + + #[abi(embed_v0)] + impl DojoModelImpl of dojo::model::IModel{ + fn name(self: @ContractState) -> ByteArray { + "ModelWithSimpleArray" + } + + fn namespace(self: @ContractState) -> ByteArray { + "dojo_test" + } + + fn tag(self: @ContractState) -> ByteArray { + "dojo_test-ModelWithSimpleArray" + } + + fn version(self: @ContractState) -> u8 { + 1 + } + + fn selector(self: @ContractState) -> felt252 { + 2155888289741706273257207428305937938996511115291276975807216945184181752777 + } + + fn name_hash(self: @ContractState) -> felt252 { + 173141902001925402715103859951360389436088950156916962046507357841237663931 + } + + fn namespace_hash(self: @ContractState) -> felt252 { + 1452123528942907587532668415362544424816022573043154497385993678618948064048 + } + + fn unpacked_size(self: @ContractState) -> Option { + dojo::model::introspect::Introspect::::size() + } + + fn packed_size(self: @ContractState) -> Option { + dojo::model::Model::::packed_size() + } + + fn layout(self: @ContractState) -> dojo::model::Layout { + dojo::model::Model::::layout() + } + + fn schema(self: @ContractState) -> dojo::model::introspect::Ty { + dojo::model::introspect::Introspect::::ty() + } + } + + #[abi(embed_v0)] + impl model_with_simple_arrayImpl of Imodel_with_simple_array{ + fn ensure_abi(self: @ContractState, model: ModelWithSimpleArray) { + } + } +#[event] +#[derive(Drop, starknet::Event)] +pub enum Event {} + + +#[phantom] +pub struct Storage { +} + +#[derive(Drop, Copy)] +pub struct StorageStorageBase { +} +impl StorageStorageImpl of starknet::storage::StorageTrait { + type BaseType = StorageStorageBase; + fn storage(self: starknet::storage::FlattenedStorage) -> StorageStorageBase { + StorageStorageBase { + } + } +} +#[derive(Drop, Copy)] +pub struct StorageStorageBaseMut { +} +impl StorageStorageMutImpl of starknet::storage::StorageTraitMut { + type BaseType = StorageStorageBaseMut; + fn storage_mut(self: starknet::storage::FlattenedStorage>) -> StorageStorageBaseMut { + StorageStorageBaseMut { + } + } +} + +pub struct ContractState { +} + +impl ContractStateDrop of Drop {} + +impl ContractStateDeref of core::ops::SnapshotDeref { + type Target = starknet::storage::FlattenedStorage; + fn snapshot_deref(self: @ContractState) -> starknet::storage::FlattenedStorage { + starknet::storage::FlattenedStorage {} + } +} +impl ContractStateDerefMut of core::ops::DerefMut { + type Target = starknet::storage::FlattenedStorage> ; + fn deref_mut(ref self: ContractState) -> starknet::storage::FlattenedStorage> { + starknet::storage::FlattenedStorage {} + } +} +pub fn unsafe_new_contract_state() -> ContractState { + ContractState { + } +} + +// TODO(Gil): This generates duplicate diagnostics because of the plugin system, squash the duplicates into one. +#[deprecated( + feature: "deprecated_legacy_map", + note: "Use `starknet::storage::Map` instead." +)] +use starknet::storage::Map as LegacyMap; + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__DojoModelImpl__name(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = DojoModelImpl::name(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__DojoModelImpl__namespace(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = DojoModelImpl::namespace(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__DojoModelImpl__tag(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = DojoModelImpl::tag(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__DojoModelImpl__version(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = DojoModelImpl::version(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__DojoModelImpl__selector(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = DojoModelImpl::selector(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__DojoModelImpl__name_hash(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = DojoModelImpl::name_hash(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__DojoModelImpl__namespace_hash(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = DojoModelImpl::namespace_hash(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__DojoModelImpl__unpacked_size(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = DojoModelImpl::unpacked_size(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::>::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__DojoModelImpl__packed_size(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = DojoModelImpl::packed_size(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::>::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__DojoModelImpl__layout(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = DojoModelImpl::layout(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__DojoModelImpl__schema(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = DojoModelImpl::schema(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__model_with_simple_arrayImpl__ensure_abi(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + let __arg_model = core::option::OptionTraitImpl::expect( + core::serde::Serde::::deserialize(ref data), + 'Failed to deserialize param #1' + ); + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + model_with_simple_arrayImpl::ensure_abi(@contract_state, __arg_model); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::array::ArrayTrait::span(@arr) +} + + +pub mod __external { + pub use super::__wrapper__DojoModelImpl__name as name; + pub use super::__wrapper__DojoModelImpl__namespace as namespace; + pub use super::__wrapper__DojoModelImpl__tag as tag; + pub use super::__wrapper__DojoModelImpl__version as version; + pub use super::__wrapper__DojoModelImpl__selector as selector; + pub use super::__wrapper__DojoModelImpl__name_hash as name_hash; + pub use super::__wrapper__DojoModelImpl__namespace_hash as namespace_hash; + pub use super::__wrapper__DojoModelImpl__unpacked_size as unpacked_size; + pub use super::__wrapper__DojoModelImpl__packed_size as packed_size; + pub use super::__wrapper__DojoModelImpl__layout as layout; + pub use super::__wrapper__DojoModelImpl__schema as schema; + pub use super::__wrapper__model_with_simple_arrayImpl__ensure_abi as ensure_abi; +} +pub mod __l1_handler { +} +pub mod __constructor { +} + impl ContractStateEventEmitter of starknet::event::EventEmitter< + ContractState, Event + > { + fn emit>( + ref self: ContractState, event: S + ) { + let event: Event = core::traits::Into::into(event); + let mut keys = Default::::default(); + let mut data = Default::::default(); + starknet::Event::append_keys_and_data(@event, ref keys, ref data); + starknet::SyscallResultTrait::unwrap_syscall( + starknet::syscalls::emit_event_syscall( + core::array::ArrayTrait::span(@keys), + core::array::ArrayTrait::span(@data), + ) + ) + } + } +impl EventDrop of core::traits::Drop::; +impl EventIsEvent of starknet::Event { + fn append_keys_and_data( + self: @Event, ref keys: Array, ref data: Array + ) { + match self { + } + } + fn deserialize( + ref keys: Span, ref data: Span, + ) -> Option { + let __selector__ = *core::array::SpanTrait::pop_front(ref keys)?; + Option::None + } +} +impl StorageStorageBaseDrop of core::traits::Drop::; +impl StorageStorageBaseCopy of core::traits::Copy::; +impl StorageStorageBaseMutDrop of core::traits::Drop::; +impl StorageStorageBaseMutCopy of core::traits::Copy::; +} + +impl ModelWithByteArrayIntrospect<> of dojo::model::introspect::Introspect> { + #[inline(always)] + fn size() -> Option { + Option::None + } + + fn layout() -> dojo::model::Layout { + dojo::model::Layout::Struct( + array![ + dojo::model::FieldLayout { + selector: 512066735765477566404754172672287371265995314501343422459174036873487219331, + layout: dojo::model::introspect::Introspect::::layout() + }, +dojo::model::FieldLayout { + selector: 1591024729085637502504777720563487898377940395575083379770417352976841400819, + layout: dojo::model::introspect::Introspect::::layout() + } + ].span() + ) + } + + #[inline(always)] + fn ty() -> dojo::model::introspect::Ty { + dojo::model::introspect::Ty::Struct( + dojo::model::introspect::Struct { + name: 'ModelWithByteArray', + attrs: array![].span(), + children: array![ + dojo::model::introspect::Member { + name: 'player', + attrs: array!['key'].span(), + ty: dojo::model::introspect::Introspect::::ty() + }, +dojo::model::introspect::Member { + name: 'x', + attrs: array![].span(), + ty: dojo::model::introspect::Introspect::::ty() + }, +dojo::model::introspect::Member { + name: 'y', + attrs: array![].span(), + ty: dojo::model::introspect::Ty::ByteArray + } + + ].span() + } + ) + } +} + +#[derive(Drop, Serde)] +pub struct ModelWithByteArrayEntity { + __id: felt252, // private field + pub x: u16, +pub y: ByteArray, + +} + +#[generate_trait] +pub impl ModelWithByteArrayEntityStoreImpl of ModelWithByteArrayEntityStore { + fn get(world: dojo::world::IWorldDispatcher, entity_id: felt252) -> ModelWithByteArrayEntity { + ModelWithByteArrayModelEntityImpl::get(world, entity_id) + } + + fn update(self: @ModelWithByteArrayEntity, world: dojo::world::IWorldDispatcher) { + dojo::model::ModelEntity::::update_entity(self, world); + } + + fn delete(self: @ModelWithByteArrayEntity, world: dojo::world::IWorldDispatcher) { + dojo::model::ModelEntity::::delete_entity(self, world); + } + + + fn get_x(world: dojo::world::IWorldDispatcher, entity_id: felt252) -> u16 { + let mut values = dojo::model::ModelEntity::::get_member( + world, + entity_id, + 512066735765477566404754172672287371265995314501343422459174036873487219331 + ); + let field_value = core::serde::Serde::::deserialize(ref values); + + if core::option::OptionTrait::::is_none(@field_value) { + panic!( + "Field `ModelWithByteArray::x`: deserialization failed." + ); + } + + core::option::OptionTrait::::unwrap(field_value) + } + + fn set_x(self: @ModelWithByteArrayEntity, world: dojo::world::IWorldDispatcher, value: u16) { + let mut serialized = core::array::ArrayTrait::new(); + core::serde::Serde::serialize(@value, ref serialized); + + self.set_member( + world, + 512066735765477566404754172672287371265995314501343422459174036873487219331, + serialized.span() + ); + } + + fn get_y(world: dojo::world::IWorldDispatcher, entity_id: felt252) -> ByteArray { + let mut values = dojo::model::ModelEntity::::get_member( + world, + entity_id, + 1591024729085637502504777720563487898377940395575083379770417352976841400819 + ); + let field_value = core::serde::Serde::::deserialize(ref values); + + if core::option::OptionTrait::::is_none(@field_value) { + panic!( + "Field `ModelWithByteArray::y`: deserialization failed." + ); + } + + core::option::OptionTrait::::unwrap(field_value) + } + + fn set_y(self: @ModelWithByteArrayEntity, world: dojo::world::IWorldDispatcher, value: ByteArray) { + let mut serialized = core::array::ArrayTrait::new(); + core::serde::Serde::serialize(@value, ref serialized); + + self.set_member( + world, + 1591024729085637502504777720563487898377940395575083379770417352976841400819, + serialized.span() + ); + } + +} + +#[generate_trait] +pub impl ModelWithByteArrayStoreImpl of ModelWithByteArrayStore { + fn entity_id_from_keys(player: ContractAddress) -> felt252 { + let mut serialized = core::array::ArrayTrait::new(); + core::serde::Serde::serialize(@player, ref serialized); + + core::poseidon::poseidon_hash_span(serialized.span()) + } + + fn from_values(ref keys: Span, ref values: Span) -> ModelWithByteArray { + let mut serialized = core::array::ArrayTrait::new(); + serialized.append_span(keys); + serialized.append_span(values); + let mut serialized = core::array::ArrayTrait::span(@serialized); + + let entity = core::serde::Serde::::deserialize(ref serialized); + + if core::option::OptionTrait::::is_none(@entity) { + panic!( + "Model `ModelWithByteArray`: deserialization failed. Ensure the length of the keys tuple is matching the number of #[key] fields in the model struct." + ); + } + + core::option::OptionTrait::::unwrap(entity) + } + + fn get(world: dojo::world::IWorldDispatcher, player: ContractAddress) -> ModelWithByteArray { + let mut serialized = core::array::ArrayTrait::new(); + core::serde::Serde::serialize(@player, ref serialized); + + + dojo::model::Model::::get(world, serialized.span()) + } + + fn set(self: @ModelWithByteArray, world: dojo::world::IWorldDispatcher) { + dojo::model::Model::::set_model(self, world); + } + + fn delete(self: @ModelWithByteArray, world: dojo::world::IWorldDispatcher) { + dojo::model::Model::::delete_model(self, world); + } + + + fn get_x(world: dojo::world::IWorldDispatcher, player: ContractAddress) -> u16 { + let mut serialized = core::array::ArrayTrait::new(); + core::serde::Serde::serialize(@player, ref serialized); + + + let mut values = dojo::model::Model::::get_member( + world, + serialized.span(), + 512066735765477566404754172672287371265995314501343422459174036873487219331 + ); + + let field_value = core::serde::Serde::::deserialize(ref values); + + if core::option::OptionTrait::::is_none(@field_value) { + panic!( + "Field `ModelWithByteArray::x`: deserialization failed." + ); + } + + core::option::OptionTrait::::unwrap(field_value) + } + + fn set_x(self: @ModelWithByteArray, world: dojo::world::IWorldDispatcher, value: u16) { + let mut serialized = core::array::ArrayTrait::new(); + core::serde::Serde::serialize(@value, ref serialized); + + self.set_member( + world, + 512066735765477566404754172672287371265995314501343422459174036873487219331, + serialized.span() + ); + } + + fn get_y(world: dojo::world::IWorldDispatcher, player: ContractAddress) -> ByteArray { + let mut serialized = core::array::ArrayTrait::new(); + core::serde::Serde::serialize(@player, ref serialized); + + + let mut values = dojo::model::Model::::get_member( + world, + serialized.span(), + 1591024729085637502504777720563487898377940395575083379770417352976841400819 + ); + + let field_value = core::serde::Serde::::deserialize(ref values); + + if core::option::OptionTrait::::is_none(@field_value) { + panic!( + "Field `ModelWithByteArray::y`: deserialization failed." + ); + } + + core::option::OptionTrait::::unwrap(field_value) + } + + fn set_y(self: @ModelWithByteArray, world: dojo::world::IWorldDispatcher, value: ByteArray) { + let mut serialized = core::array::ArrayTrait::new(); + core::serde::Serde::serialize(@value, ref serialized); + + self.set_member( + world, + 1591024729085637502504777720563487898377940395575083379770417352976841400819, + serialized.span() + ); + } + +} + +pub impl ModelWithByteArrayModelEntityImpl of dojo::model::ModelEntity { + fn id(self: @ModelWithByteArrayEntity) -> felt252 { + *self.__id + } + + fn values(self: @ModelWithByteArrayEntity) -> Span { + let mut serialized = core::array::ArrayTrait::new(); + core::serde::Serde::serialize(self.x, ref serialized); +core::serde::Serde::serialize(self.y, ref serialized); + + core::array::ArrayTrait::span(@serialized) + } + + fn from_values(entity_id: felt252, ref values: Span) -> ModelWithByteArrayEntity { + let mut serialized = array![entity_id]; + serialized.append_span(values); + let mut serialized = core::array::ArrayTrait::span(@serialized); + + let entity_values = core::serde::Serde::::deserialize(ref serialized); + if core::option::OptionTrait::::is_none(@entity_values) { + panic!( + "ModelEntity `ModelWithByteArrayEntity`: deserialization failed." + ); + } + core::option::OptionTrait::::unwrap(entity_values) + } + + fn get(world: dojo::world::IWorldDispatcher, entity_id: felt252) -> ModelWithByteArrayEntity { + let mut values = dojo::world::IWorldDispatcherTrait::entity( + world, + dojo::model::Model::::selector(), + dojo::model::ModelIndex::Id(entity_id), + dojo::model::Model::::layout() + ); + Self::from_values(entity_id, ref values) + } + + fn update_entity(self: @ModelWithByteArrayEntity, world: dojo::world::IWorldDispatcher) { + dojo::world::IWorldDispatcherTrait::set_entity( + world, + dojo::model::Model::::selector(), + dojo::model::ModelIndex::Id(self.id()), + self.values(), + dojo::model::Model::::layout() + ); + } + + fn delete_entity(self: @ModelWithByteArrayEntity, world: dojo::world::IWorldDispatcher) { + dojo::world::IWorldDispatcherTrait::delete_entity( + world, + dojo::model::Model::::selector(), + dojo::model::ModelIndex::Id(self.id()), + dojo::model::Model::::layout() + ); + } + + fn get_member( + world: dojo::world::IWorldDispatcher, + entity_id: felt252, + member_id: felt252, + ) -> Span { + match dojo::utils::find_model_field_layout(dojo::model::Model::::layout(), member_id) { + Option::Some(field_layout) => { + dojo::world::IWorldDispatcherTrait::entity( + world, + dojo::model::Model::::selector(), + dojo::model::ModelIndex::MemberId((entity_id, member_id)), + field_layout + ) + }, + Option::None => core::panic_with_felt252('bad member id') + } + } + + fn set_member( + self: @ModelWithByteArrayEntity, + world: dojo::world::IWorldDispatcher, + member_id: felt252, + values: Span, + ) { + match dojo::utils::find_model_field_layout(dojo::model::Model::::layout(), member_id) { + Option::Some(field_layout) => { + dojo::world::IWorldDispatcherTrait::set_entity( + world, + dojo::model::Model::::selector(), + dojo::model::ModelIndex::MemberId((self.id(), member_id)), + values, + field_layout + ) + }, + Option::None => core::panic_with_felt252('bad member id') + } + } +} + +pub impl ModelWithByteArrayModelImpl of dojo::model::Model { + fn get(world: dojo::world::IWorldDispatcher, keys: Span) -> ModelWithByteArray { + let mut values = dojo::world::IWorldDispatcherTrait::entity( + world, + Self::selector(), + dojo::model::ModelIndex::Keys(keys), + Self::layout() + ); + let mut _keys = keys; + + ModelWithByteArrayStore::from_values(ref _keys, ref values) + } + + fn set_model( + self: @ModelWithByteArray, + world: dojo::world::IWorldDispatcher + ) { + dojo::world::IWorldDispatcherTrait::set_entity( + world, + Self::selector(), + dojo::model::ModelIndex::Keys(Self::keys(self)), + Self::values(self), + Self::layout() + ); + } + + fn delete_model( + self: @ModelWithByteArray, + world: dojo::world::IWorldDispatcher + ) { + dojo::world::IWorldDispatcherTrait::delete_entity( + world, + Self::selector(), + dojo::model::ModelIndex::Keys(Self::keys(self)), + Self::layout() + ); + } + + fn get_member( + world: dojo::world::IWorldDispatcher, + keys: Span, + member_id: felt252 + ) -> Span { + match dojo::utils::find_model_field_layout(Self::layout(), member_id) { + Option::Some(field_layout) => { + let entity_id = dojo::utils::entity_id_from_keys(keys); + dojo::world::IWorldDispatcherTrait::entity( + world, + Self::selector(), + dojo::model::ModelIndex::MemberId((entity_id, member_id)), + field_layout + ) + }, + Option::None => core::panic_with_felt252('bad member id') + } + } + + fn set_member( + self: @ModelWithByteArray, + world: dojo::world::IWorldDispatcher, + member_id: felt252, + values: Span + ) { + match dojo::utils::find_model_field_layout(Self::layout(), member_id) { + Option::Some(field_layout) => { + dojo::world::IWorldDispatcherTrait::set_entity( + world, + Self::selector(), + dojo::model::ModelIndex::MemberId((self.entity_id(), member_id)), + values, + field_layout + ) + }, + Option::None => core::panic_with_felt252('bad member id') + } + } + + #[inline(always)] + fn name() -> ByteArray { + "ModelWithByteArray" + } + + #[inline(always)] + fn namespace() -> ByteArray { + "dojo_test" + } + + #[inline(always)] + fn tag() -> ByteArray { + "dojo_test-ModelWithByteArray" + } + + #[inline(always)] + fn version() -> u8 { + 1 + } + + #[inline(always)] + fn selector() -> felt252 { + 2309493726682581230048608406375650493303358263694405202817326852234706548038 + } + + #[inline(always)] + fn instance_selector(self: @ModelWithByteArray) -> felt252 { + Self::selector() + } + + #[inline(always)] + fn name_hash() -> felt252 { + 2176409715042145900636260236501596599545103472111273072320531220776338338674 + } + + #[inline(always)] + fn namespace_hash() -> felt252 { + 1452123528942907587532668415362544424816022573043154497385993678618948064048 + } + + #[inline(always)] + fn entity_id(self: @ModelWithByteArray) -> felt252 { + core::poseidon::poseidon_hash_span(self.keys()) + } + + #[inline(always)] + fn keys(self: @ModelWithByteArray) -> Span { + let mut serialized = core::array::ArrayTrait::new(); + core::serde::Serde::serialize(self.player, ref serialized); + + core::array::ArrayTrait::span(@serialized) + } + + #[inline(always)] + fn values(self: @ModelWithByteArray) -> Span { + let mut serialized = core::array::ArrayTrait::new(); + core::serde::Serde::serialize(self.x, ref serialized); +core::serde::Serde::serialize(self.y, ref serialized); + + core::array::ArrayTrait::span(@serialized) + } + + #[inline(always)] + fn layout() -> dojo::model::Layout { + dojo::model::introspect::Introspect::::layout() + } + + #[inline(always)] + fn instance_layout(self: @ModelWithByteArray) -> dojo::model::Layout { + Self::layout() + } + + #[inline(always)] + fn packed_size() -> Option { + dojo::model::layout::compute_packed_size(Self::layout()) + } +} + +#[starknet::interface] +pub trait Imodel_with_byte_array { + fn ensure_abi(self: @T, model: ModelWithByteArray); +} + +#[starknet::contract] +pub mod model_with_byte_array { + use super::ModelWithByteArray; + use super::Imodel_with_byte_array; + + #[abi(embed_v0)] + impl DojoModelImpl of dojo::model::IModel{ + fn name(self: @ContractState) -> ByteArray { + "ModelWithByteArray" + } + + fn namespace(self: @ContractState) -> ByteArray { + "dojo_test" + } + + fn tag(self: @ContractState) -> ByteArray { + "dojo_test-ModelWithByteArray" + } + + fn version(self: @ContractState) -> u8 { + 1 + } + + fn selector(self: @ContractState) -> felt252 { + 2309493726682581230048608406375650493303358263694405202817326852234706548038 + } + + fn name_hash(self: @ContractState) -> felt252 { + 2176409715042145900636260236501596599545103472111273072320531220776338338674 + } + + fn namespace_hash(self: @ContractState) -> felt252 { + 1452123528942907587532668415362544424816022573043154497385993678618948064048 + } + + fn unpacked_size(self: @ContractState) -> Option { + dojo::model::introspect::Introspect::::size() + } + + fn packed_size(self: @ContractState) -> Option { + dojo::model::Model::::packed_size() + } + + fn layout(self: @ContractState) -> dojo::model::Layout { + dojo::model::Model::::layout() + } + + fn schema(self: @ContractState) -> dojo::model::introspect::Ty { + dojo::model::introspect::Introspect::::ty() + } + } + + #[abi(embed_v0)] + impl model_with_byte_arrayImpl of Imodel_with_byte_array{ + fn ensure_abi(self: @ContractState, model: ModelWithByteArray) { + } + } +#[event] +#[derive(Drop, starknet::Event)] +pub enum Event {} + + +#[phantom] +pub struct Storage { +} + +#[derive(Drop, Copy)] +pub struct StorageStorageBase { +} +impl StorageStorageImpl of starknet::storage::StorageTrait { + type BaseType = StorageStorageBase; + fn storage(self: starknet::storage::FlattenedStorage) -> StorageStorageBase { + StorageStorageBase { + } + } +} +#[derive(Drop, Copy)] +pub struct StorageStorageBaseMut { +} +impl StorageStorageMutImpl of starknet::storage::StorageTraitMut { + type BaseType = StorageStorageBaseMut; + fn storage_mut(self: starknet::storage::FlattenedStorage>) -> StorageStorageBaseMut { + StorageStorageBaseMut { + } + } +} + +pub struct ContractState { +} + +impl ContractStateDrop of Drop {} + +impl ContractStateDeref of core::ops::SnapshotDeref { + type Target = starknet::storage::FlattenedStorage; + fn snapshot_deref(self: @ContractState) -> starknet::storage::FlattenedStorage { + starknet::storage::FlattenedStorage {} + } +} +impl ContractStateDerefMut of core::ops::DerefMut { + type Target = starknet::storage::FlattenedStorage> ; + fn deref_mut(ref self: ContractState) -> starknet::storage::FlattenedStorage> { + starknet::storage::FlattenedStorage {} + } +} +pub fn unsafe_new_contract_state() -> ContractState { + ContractState { + } +} + +// TODO(Gil): This generates duplicate diagnostics because of the plugin system, squash the duplicates into one. +#[deprecated( + feature: "deprecated_legacy_map", + note: "Use `starknet::storage::Map` instead." +)] +use starknet::storage::Map as LegacyMap; + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__DojoModelImpl__name(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = DojoModelImpl::name(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__DojoModelImpl__namespace(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = DojoModelImpl::namespace(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__DojoModelImpl__tag(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = DojoModelImpl::tag(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__DojoModelImpl__version(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = DojoModelImpl::version(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__DojoModelImpl__selector(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = DojoModelImpl::selector(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__DojoModelImpl__name_hash(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = DojoModelImpl::name_hash(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__DojoModelImpl__namespace_hash(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = DojoModelImpl::namespace_hash(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__DojoModelImpl__unpacked_size(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = DojoModelImpl::unpacked_size(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::>::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__DojoModelImpl__packed_size(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = DojoModelImpl::packed_size(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::>::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__DojoModelImpl__layout(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = DojoModelImpl::layout(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__DojoModelImpl__schema(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = DojoModelImpl::schema(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__model_with_byte_arrayImpl__ensure_abi(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + let __arg_model = core::option::OptionTraitImpl::expect( + core::serde::Serde::::deserialize(ref data), + 'Failed to deserialize param #1' + ); + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + model_with_byte_arrayImpl::ensure_abi(@contract_state, __arg_model); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::array::ArrayTrait::span(@arr) +} + + +pub mod __external { + pub use super::__wrapper__DojoModelImpl__name as name; + pub use super::__wrapper__DojoModelImpl__namespace as namespace; + pub use super::__wrapper__DojoModelImpl__tag as tag; + pub use super::__wrapper__DojoModelImpl__version as version; + pub use super::__wrapper__DojoModelImpl__selector as selector; + pub use super::__wrapper__DojoModelImpl__name_hash as name_hash; + pub use super::__wrapper__DojoModelImpl__namespace_hash as namespace_hash; + pub use super::__wrapper__DojoModelImpl__unpacked_size as unpacked_size; + pub use super::__wrapper__DojoModelImpl__packed_size as packed_size; + pub use super::__wrapper__DojoModelImpl__layout as layout; + pub use super::__wrapper__DojoModelImpl__schema as schema; + pub use super::__wrapper__model_with_byte_arrayImpl__ensure_abi as ensure_abi; +} +pub mod __l1_handler { +} +pub mod __constructor { +} + impl ContractStateEventEmitter of starknet::event::EventEmitter< + ContractState, Event + > { + fn emit>( + ref self: ContractState, event: S + ) { + let event: Event = core::traits::Into::into(event); + let mut keys = Default::::default(); + let mut data = Default::::default(); + starknet::Event::append_keys_and_data(@event, ref keys, ref data); + starknet::SyscallResultTrait::unwrap_syscall( + starknet::syscalls::emit_event_syscall( + core::array::ArrayTrait::span(@keys), + core::array::ArrayTrait::span(@data), + ) + ) + } + } +impl EventDrop of core::traits::Drop::; +impl EventIsEvent of starknet::Event { + fn append_keys_and_data( + self: @Event, ref keys: Array, ref data: Array + ) { + match self { + } + } + fn deserialize( + ref keys: Span, ref data: Span, + ) -> Option { + let __selector__ = *core::array::SpanTrait::pop_front(ref keys)?; + Option::None + } +} +impl StorageStorageBaseDrop of core::traits::Drop::; +impl StorageStorageBaseCopy of core::traits::Copy::; +impl StorageStorageBaseMutDrop of core::traits::Drop::; +impl StorageStorageBaseMutCopy of core::traits::Copy::; +} + +impl ModelWithComplexArrayIntrospect<> of dojo::model::introspect::Introspect> { + #[inline(always)] + fn size() -> Option { + Option::None + } + + fn layout() -> dojo::model::Layout { + dojo::model::Layout::Struct( + array![ + dojo::model::FieldLayout { + selector: 512066735765477566404754172672287371265995314501343422459174036873487219331, + layout: dojo::model::introspect::Introspect::::layout() + }, +dojo::model::FieldLayout { + selector: 1591024729085637502504777720563487898377940395575083379770417352976841400819, + layout: dojo::model::introspect::Introspect:: +>::layout() + } + ].span() + ) + } + + #[inline(always)] + fn ty() -> dojo::model::introspect::Ty { + dojo::model::introspect::Ty::Struct( + dojo::model::introspect::Struct { + name: 'ModelWithComplexArray', + attrs: array![].span(), + children: array![ + dojo::model::introspect::Member { + name: 'player', + attrs: array!['key'].span(), + ty: dojo::model::introspect::Introspect::::ty() + }, +dojo::model::introspect::Member { + name: 'x', + attrs: array![].span(), + ty: dojo::model::introspect::Introspect::::ty() + }, +dojo::model::introspect::Member { + name: 'y', + attrs: array![].span(), + ty: dojo::model::introspect::Ty::Array( + array![ + dojo::model::introspect::Introspect::::ty() + ].span() + ) + } + + ].span() + } + ) + } +} + +#[derive(Drop, Serde)] +pub struct ModelWithComplexArrayEntity { + __id: felt252, // private field + pub x: u16, +pub y: Array, + +} + +#[generate_trait] +pub impl ModelWithComplexArrayEntityStoreImpl of ModelWithComplexArrayEntityStore { + fn get(world: dojo::world::IWorldDispatcher, entity_id: felt252) -> ModelWithComplexArrayEntity { + ModelWithComplexArrayModelEntityImpl::get(world, entity_id) + } + + fn update(self: @ModelWithComplexArrayEntity, world: dojo::world::IWorldDispatcher) { + dojo::model::ModelEntity::::update_entity(self, world); + } + + fn delete(self: @ModelWithComplexArrayEntity, world: dojo::world::IWorldDispatcher) { + dojo::model::ModelEntity::::delete_entity(self, world); + } + + + fn get_x(world: dojo::world::IWorldDispatcher, entity_id: felt252) -> u16 { + let mut values = dojo::model::ModelEntity::::get_member( + world, + entity_id, + 512066735765477566404754172672287371265995314501343422459174036873487219331 + ); + let field_value = core::serde::Serde::::deserialize(ref values); + + if core::option::OptionTrait::::is_none(@field_value) { + panic!( + "Field `ModelWithComplexArray::x`: deserialization failed." + ); + } + + core::option::OptionTrait::::unwrap(field_value) + } + + fn set_x(self: @ModelWithComplexArrayEntity, world: dojo::world::IWorldDispatcher, value: u16) { + let mut serialized = core::array::ArrayTrait::new(); + core::serde::Serde::serialize(@value, ref serialized); + + self.set_member( + world, + 512066735765477566404754172672287371265995314501343422459174036873487219331, + serialized.span() + ); + } + + fn get_y(world: dojo::world::IWorldDispatcher, entity_id: felt252) -> Array { + let mut values = dojo::model::ModelEntity::::get_member( + world, + entity_id, + 1591024729085637502504777720563487898377940395575083379770417352976841400819 + ); + let field_value = core::serde::Serde::>::deserialize(ref values); + + if core::option::OptionTrait::>::is_none(@field_value) { + panic!( + "Field `ModelWithComplexArray::y`: deserialization failed." + ); + } + + core::option::OptionTrait::>::unwrap(field_value) + } + + fn set_y(self: @ModelWithComplexArrayEntity, world: dojo::world::IWorldDispatcher, value: Array) { + let mut serialized = core::array::ArrayTrait::new(); + core::serde::Serde::serialize(@value, ref serialized); + + self.set_member( + world, + 1591024729085637502504777720563487898377940395575083379770417352976841400819, + serialized.span() + ); + } + +} + +#[generate_trait] +pub impl ModelWithComplexArrayStoreImpl of ModelWithComplexArrayStore { + fn entity_id_from_keys(player: ContractAddress) -> felt252 { + let mut serialized = core::array::ArrayTrait::new(); + core::serde::Serde::serialize(@player, ref serialized); + + core::poseidon::poseidon_hash_span(serialized.span()) + } + + fn from_values(ref keys: Span, ref values: Span) -> ModelWithComplexArray { + let mut serialized = core::array::ArrayTrait::new(); + serialized.append_span(keys); + serialized.append_span(values); + let mut serialized = core::array::ArrayTrait::span(@serialized); + + let entity = core::serde::Serde::::deserialize(ref serialized); + + if core::option::OptionTrait::::is_none(@entity) { + panic!( + "Model `ModelWithComplexArray`: deserialization failed. Ensure the length of the keys tuple is matching the number of #[key] fields in the model struct." + ); + } + + core::option::OptionTrait::::unwrap(entity) + } + + fn get(world: dojo::world::IWorldDispatcher, player: ContractAddress) -> ModelWithComplexArray { + let mut serialized = core::array::ArrayTrait::new(); + core::serde::Serde::serialize(@player, ref serialized); + + + dojo::model::Model::::get(world, serialized.span()) + } + + fn set(self: @ModelWithComplexArray, world: dojo::world::IWorldDispatcher) { + dojo::model::Model::::set_model(self, world); + } + + fn delete(self: @ModelWithComplexArray, world: dojo::world::IWorldDispatcher) { + dojo::model::Model::::delete_model(self, world); + } + + + fn get_x(world: dojo::world::IWorldDispatcher, player: ContractAddress) -> u16 { + let mut serialized = core::array::ArrayTrait::new(); + core::serde::Serde::serialize(@player, ref serialized); + + + let mut values = dojo::model::Model::::get_member( + world, + serialized.span(), + 512066735765477566404754172672287371265995314501343422459174036873487219331 + ); + + let field_value = core::serde::Serde::::deserialize(ref values); + + if core::option::OptionTrait::::is_none(@field_value) { + panic!( + "Field `ModelWithComplexArray::x`: deserialization failed." + ); + } + + core::option::OptionTrait::::unwrap(field_value) + } + + fn set_x(self: @ModelWithComplexArray, world: dojo::world::IWorldDispatcher, value: u16) { + let mut serialized = core::array::ArrayTrait::new(); + core::serde::Serde::serialize(@value, ref serialized); + + self.set_member( + world, + 512066735765477566404754172672287371265995314501343422459174036873487219331, + serialized.span() + ); + } + + fn get_y(world: dojo::world::IWorldDispatcher, player: ContractAddress) -> Array { + let mut serialized = core::array::ArrayTrait::new(); + core::serde::Serde::serialize(@player, ref serialized); + + + let mut values = dojo::model::Model::::get_member( + world, + serialized.span(), + 1591024729085637502504777720563487898377940395575083379770417352976841400819 + ); + + let field_value = core::serde::Serde::>::deserialize(ref values); + + if core::option::OptionTrait::>::is_none(@field_value) { + panic!( + "Field `ModelWithComplexArray::y`: deserialization failed." + ); + } + + core::option::OptionTrait::>::unwrap(field_value) + } + + fn set_y(self: @ModelWithComplexArray, world: dojo::world::IWorldDispatcher, value: Array) { + let mut serialized = core::array::ArrayTrait::new(); + core::serde::Serde::serialize(@value, ref serialized); + + self.set_member( + world, + 1591024729085637502504777720563487898377940395575083379770417352976841400819, + serialized.span() + ); + } + +} + +pub impl ModelWithComplexArrayModelEntityImpl of dojo::model::ModelEntity { + fn id(self: @ModelWithComplexArrayEntity) -> felt252 { + *self.__id + } + + fn values(self: @ModelWithComplexArrayEntity) -> Span { + let mut serialized = core::array::ArrayTrait::new(); + core::serde::Serde::serialize(self.x, ref serialized); +core::serde::Serde::serialize(self.y, ref serialized); + + core::array::ArrayTrait::span(@serialized) + } + + fn from_values(entity_id: felt252, ref values: Span) -> ModelWithComplexArrayEntity { + let mut serialized = array![entity_id]; + serialized.append_span(values); + let mut serialized = core::array::ArrayTrait::span(@serialized); + + let entity_values = core::serde::Serde::::deserialize(ref serialized); + if core::option::OptionTrait::::is_none(@entity_values) { + panic!( + "ModelEntity `ModelWithComplexArrayEntity`: deserialization failed." + ); + } + core::option::OptionTrait::::unwrap(entity_values) + } + + fn get(world: dojo::world::IWorldDispatcher, entity_id: felt252) -> ModelWithComplexArrayEntity { + let mut values = dojo::world::IWorldDispatcherTrait::entity( + world, + dojo::model::Model::::selector(), + dojo::model::ModelIndex::Id(entity_id), + dojo::model::Model::::layout() + ); + Self::from_values(entity_id, ref values) + } + + fn update_entity(self: @ModelWithComplexArrayEntity, world: dojo::world::IWorldDispatcher) { + dojo::world::IWorldDispatcherTrait::set_entity( + world, + dojo::model::Model::::selector(), + dojo::model::ModelIndex::Id(self.id()), + self.values(), + dojo::model::Model::::layout() + ); + } + + fn delete_entity(self: @ModelWithComplexArrayEntity, world: dojo::world::IWorldDispatcher) { + dojo::world::IWorldDispatcherTrait::delete_entity( + world, + dojo::model::Model::::selector(), + dojo::model::ModelIndex::Id(self.id()), + dojo::model::Model::::layout() + ); + } + + fn get_member( + world: dojo::world::IWorldDispatcher, + entity_id: felt252, + member_id: felt252, + ) -> Span { + match dojo::utils::find_model_field_layout(dojo::model::Model::::layout(), member_id) { + Option::Some(field_layout) => { + dojo::world::IWorldDispatcherTrait::entity( + world, + dojo::model::Model::::selector(), + dojo::model::ModelIndex::MemberId((entity_id, member_id)), + field_layout + ) + }, + Option::None => core::panic_with_felt252('bad member id') + } + } + + fn set_member( + self: @ModelWithComplexArrayEntity, + world: dojo::world::IWorldDispatcher, + member_id: felt252, + values: Span, + ) { + match dojo::utils::find_model_field_layout(dojo::model::Model::::layout(), member_id) { + Option::Some(field_layout) => { + dojo::world::IWorldDispatcherTrait::set_entity( + world, + dojo::model::Model::::selector(), + dojo::model::ModelIndex::MemberId((self.id(), member_id)), + values, + field_layout + ) + }, + Option::None => core::panic_with_felt252('bad member id') + } + } +} + +pub impl ModelWithComplexArrayModelImpl of dojo::model::Model { + fn get(world: dojo::world::IWorldDispatcher, keys: Span) -> ModelWithComplexArray { + let mut values = dojo::world::IWorldDispatcherTrait::entity( + world, + Self::selector(), + dojo::model::ModelIndex::Keys(keys), + Self::layout() + ); + let mut _keys = keys; + + ModelWithComplexArrayStore::from_values(ref _keys, ref values) + } + + fn set_model( + self: @ModelWithComplexArray, + world: dojo::world::IWorldDispatcher + ) { + dojo::world::IWorldDispatcherTrait::set_entity( + world, + Self::selector(), + dojo::model::ModelIndex::Keys(Self::keys(self)), + Self::values(self), + Self::layout() + ); + } + + fn delete_model( + self: @ModelWithComplexArray, + world: dojo::world::IWorldDispatcher + ) { + dojo::world::IWorldDispatcherTrait::delete_entity( + world, + Self::selector(), + dojo::model::ModelIndex::Keys(Self::keys(self)), + Self::layout() + ); + } + + fn get_member( + world: dojo::world::IWorldDispatcher, + keys: Span, + member_id: felt252 + ) -> Span { + match dojo::utils::find_model_field_layout(Self::layout(), member_id) { + Option::Some(field_layout) => { + let entity_id = dojo::utils::entity_id_from_keys(keys); + dojo::world::IWorldDispatcherTrait::entity( + world, + Self::selector(), + dojo::model::ModelIndex::MemberId((entity_id, member_id)), + field_layout + ) + }, + Option::None => core::panic_with_felt252('bad member id') + } + } + + fn set_member( + self: @ModelWithComplexArray, + world: dojo::world::IWorldDispatcher, + member_id: felt252, + values: Span + ) { + match dojo::utils::find_model_field_layout(Self::layout(), member_id) { + Option::Some(field_layout) => { + dojo::world::IWorldDispatcherTrait::set_entity( + world, + Self::selector(), + dojo::model::ModelIndex::MemberId((self.entity_id(), member_id)), + values, + field_layout + ) + }, + Option::None => core::panic_with_felt252('bad member id') + } + } + + #[inline(always)] + fn name() -> ByteArray { + "ModelWithComplexArray" + } + + #[inline(always)] + fn namespace() -> ByteArray { + "dojo_test" + } + + #[inline(always)] + fn tag() -> ByteArray { + "dojo_test-ModelWithComplexArray" + } + + #[inline(always)] + fn version() -> u8 { + 1 + } + + #[inline(always)] + fn selector() -> felt252 { + 1293570145807126672811046976011709110822800800255162893130594439459909679461 + } + + #[inline(always)] + fn instance_selector(self: @ModelWithComplexArray) -> felt252 { + Self::selector() + } + + #[inline(always)] + fn name_hash() -> felt252 { + 2866472224509756243720005045848892642397514372569303051745174230372637769655 + } + + #[inline(always)] + fn namespace_hash() -> felt252 { + 1452123528942907587532668415362544424816022573043154497385993678618948064048 + } + + #[inline(always)] + fn entity_id(self: @ModelWithComplexArray) -> felt252 { + core::poseidon::poseidon_hash_span(self.keys()) + } + + #[inline(always)] + fn keys(self: @ModelWithComplexArray) -> Span { + let mut serialized = core::array::ArrayTrait::new(); + core::serde::Serde::serialize(self.player, ref serialized); + + core::array::ArrayTrait::span(@serialized) + } + + #[inline(always)] + fn values(self: @ModelWithComplexArray) -> Span { + let mut serialized = core::array::ArrayTrait::new(); + core::serde::Serde::serialize(self.x, ref serialized); +core::serde::Serde::serialize(self.y, ref serialized); + + core::array::ArrayTrait::span(@serialized) + } + + #[inline(always)] + fn layout() -> dojo::model::Layout { + dojo::model::introspect::Introspect::::layout() + } + + #[inline(always)] + fn instance_layout(self: @ModelWithComplexArray) -> dojo::model::Layout { + Self::layout() + } + + #[inline(always)] + fn packed_size() -> Option { + dojo::model::layout::compute_packed_size(Self::layout()) + } +} + +#[starknet::interface] +pub trait Imodel_with_complex_array { + fn ensure_abi(self: @T, model: ModelWithComplexArray); +} + +#[starknet::contract] +pub mod model_with_complex_array { + use super::ModelWithComplexArray; + use super::Imodel_with_complex_array; + + #[abi(embed_v0)] + impl DojoModelImpl of dojo::model::IModel{ + fn name(self: @ContractState) -> ByteArray { + "ModelWithComplexArray" + } + + fn namespace(self: @ContractState) -> ByteArray { + "dojo_test" + } + + fn tag(self: @ContractState) -> ByteArray { + "dojo_test-ModelWithComplexArray" + } + + fn version(self: @ContractState) -> u8 { + 1 + } + + fn selector(self: @ContractState) -> felt252 { + 1293570145807126672811046976011709110822800800255162893130594439459909679461 + } + + fn name_hash(self: @ContractState) -> felt252 { + 2866472224509756243720005045848892642397514372569303051745174230372637769655 + } + + fn namespace_hash(self: @ContractState) -> felt252 { + 1452123528942907587532668415362544424816022573043154497385993678618948064048 + } + + fn unpacked_size(self: @ContractState) -> Option { + dojo::model::introspect::Introspect::::size() + } + + fn packed_size(self: @ContractState) -> Option { + dojo::model::Model::::packed_size() + } + + fn layout(self: @ContractState) -> dojo::model::Layout { + dojo::model::Model::::layout() + } + + fn schema(self: @ContractState) -> dojo::model::introspect::Ty { + dojo::model::introspect::Introspect::::ty() + } + } + + #[abi(embed_v0)] + impl model_with_complex_arrayImpl of Imodel_with_complex_array{ + fn ensure_abi(self: @ContractState, model: ModelWithComplexArray) { + } + } +#[event] +#[derive(Drop, starknet::Event)] +pub enum Event {} + + +#[phantom] +pub struct Storage { +} + +#[derive(Drop, Copy)] +pub struct StorageStorageBase { +} +impl StorageStorageImpl of starknet::storage::StorageTrait { + type BaseType = StorageStorageBase; + fn storage(self: starknet::storage::FlattenedStorage) -> StorageStorageBase { + StorageStorageBase { + } + } +} +#[derive(Drop, Copy)] +pub struct StorageStorageBaseMut { +} +impl StorageStorageMutImpl of starknet::storage::StorageTraitMut { + type BaseType = StorageStorageBaseMut; + fn storage_mut(self: starknet::storage::FlattenedStorage>) -> StorageStorageBaseMut { + StorageStorageBaseMut { + } + } +} + +pub struct ContractState { +} + +impl ContractStateDrop of Drop {} + +impl ContractStateDeref of core::ops::SnapshotDeref { + type Target = starknet::storage::FlattenedStorage; + fn snapshot_deref(self: @ContractState) -> starknet::storage::FlattenedStorage { + starknet::storage::FlattenedStorage {} + } +} +impl ContractStateDerefMut of core::ops::DerefMut { + type Target = starknet::storage::FlattenedStorage> ; + fn deref_mut(ref self: ContractState) -> starknet::storage::FlattenedStorage> { + starknet::storage::FlattenedStorage {} + } +} +pub fn unsafe_new_contract_state() -> ContractState { + ContractState { + } +} + +// TODO(Gil): This generates duplicate diagnostics because of the plugin system, squash the duplicates into one. +#[deprecated( + feature: "deprecated_legacy_map", + note: "Use `starknet::storage::Map` instead." +)] +use starknet::storage::Map as LegacyMap; + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__DojoModelImpl__name(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = DojoModelImpl::name(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__DojoModelImpl__namespace(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = DojoModelImpl::namespace(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__DojoModelImpl__tag(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = DojoModelImpl::tag(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__DojoModelImpl__version(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = DojoModelImpl::version(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__DojoModelImpl__selector(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = DojoModelImpl::selector(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__DojoModelImpl__name_hash(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = DojoModelImpl::name_hash(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__DojoModelImpl__namespace_hash(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = DojoModelImpl::namespace_hash(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__DojoModelImpl__unpacked_size(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = DojoModelImpl::unpacked_size(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::>::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__DojoModelImpl__packed_size(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = DojoModelImpl::packed_size(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::>::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__DojoModelImpl__layout(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = DojoModelImpl::layout(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__DojoModelImpl__schema(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = DojoModelImpl::schema(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__model_with_complex_arrayImpl__ensure_abi(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + let __arg_model = core::option::OptionTraitImpl::expect( + core::serde::Serde::::deserialize(ref data), + 'Failed to deserialize param #1' + ); + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + model_with_complex_arrayImpl::ensure_abi(@contract_state, __arg_model); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::array::ArrayTrait::span(@arr) +} + + +pub mod __external { + pub use super::__wrapper__DojoModelImpl__name as name; + pub use super::__wrapper__DojoModelImpl__namespace as namespace; + pub use super::__wrapper__DojoModelImpl__tag as tag; + pub use super::__wrapper__DojoModelImpl__version as version; + pub use super::__wrapper__DojoModelImpl__selector as selector; + pub use super::__wrapper__DojoModelImpl__name_hash as name_hash; + pub use super::__wrapper__DojoModelImpl__namespace_hash as namespace_hash; + pub use super::__wrapper__DojoModelImpl__unpacked_size as unpacked_size; + pub use super::__wrapper__DojoModelImpl__packed_size as packed_size; + pub use super::__wrapper__DojoModelImpl__layout as layout; + pub use super::__wrapper__DojoModelImpl__schema as schema; + pub use super::__wrapper__model_with_complex_arrayImpl__ensure_abi as ensure_abi; +} +pub mod __l1_handler { +} +pub mod __constructor { +} + impl ContractStateEventEmitter of starknet::event::EventEmitter< + ContractState, Event + > { + fn emit>( + ref self: ContractState, event: S + ) { + let event: Event = core::traits::Into::into(event); + let mut keys = Default::::default(); + let mut data = Default::::default(); + starknet::Event::append_keys_and_data(@event, ref keys, ref data); + starknet::SyscallResultTrait::unwrap_syscall( + starknet::syscalls::emit_event_syscall( + core::array::ArrayTrait::span(@keys), + core::array::ArrayTrait::span(@data), + ) + ) + } + } +impl EventDrop of core::traits::Drop::; +impl EventIsEvent of starknet::Event { + fn append_keys_and_data( + self: @Event, ref keys: Array, ref data: Array + ) { + match self { + } + } + fn deserialize( + ref keys: Span, ref data: Span, + ) -> Option { + let __selector__ = *core::array::SpanTrait::pop_front(ref keys)?; + Option::None + } +} +impl StorageStorageBaseDrop of core::traits::Drop::; +impl StorageStorageBaseCopy of core::traits::Copy::; +impl StorageStorageBaseMutDrop of core::traits::Drop::; +impl StorageStorageBaseMutCopy of core::traits::Copy::; +} + +impl ModelWithTupleIntrospect<> of dojo::model::introspect::Introspect> { + #[inline(always)] + fn size() -> Option { + Option::Some(4) + } + + fn layout() -> dojo::model::Layout { + dojo::model::Layout::Struct( + array![ + dojo::model::FieldLayout { + selector: 512066735765477566404754172672287371265995314501343422459174036873487219331, + layout: dojo::model::introspect::Introspect::::layout() + }, +dojo::model::FieldLayout { + selector: 1591024729085637502504777720563487898377940395575083379770417352976841400819, + layout: dojo::model::Layout::Tuple( + array![ + dojo::model::introspect::Introspect::::layout(), +dojo::model::introspect::Introspect::::layout(), +dojo::model::introspect::Introspect::::layout() + ].span() + ) + } + ].span() + ) + } + + #[inline(always)] + fn ty() -> dojo::model::introspect::Ty { + dojo::model::introspect::Ty::Struct( + dojo::model::introspect::Struct { + name: 'ModelWithTuple', + attrs: array![].span(), + children: array![ + dojo::model::introspect::Member { + name: 'player', + attrs: array!['key'].span(), + ty: dojo::model::introspect::Introspect::::ty() + }, +dojo::model::introspect::Member { + name: 'x', + attrs: array![].span(), + ty: dojo::model::introspect::Introspect::::ty() + }, +dojo::model::introspect::Member { + name: 'y', + attrs: array![].span(), + ty: dojo::model::introspect::Ty::Tuple( + array![ + dojo::model::introspect::Introspect::::ty(), +dojo::model::introspect::Introspect::::ty(), +dojo::model::introspect::Introspect::::ty() + ].span() + ) + } + + ].span() + } + ) + } +} + +#[derive(Drop, Serde)] +pub struct ModelWithTupleEntity { + __id: felt252, // private field + pub x: u16, +pub y: (u8, u16, u32), + +} + +#[generate_trait] +pub impl ModelWithTupleEntityStoreImpl of ModelWithTupleEntityStore { + fn get(world: dojo::world::IWorldDispatcher, entity_id: felt252) -> ModelWithTupleEntity { + ModelWithTupleModelEntityImpl::get(world, entity_id) + } + + fn update(self: @ModelWithTupleEntity, world: dojo::world::IWorldDispatcher) { + dojo::model::ModelEntity::::update_entity(self, world); + } + + fn delete(self: @ModelWithTupleEntity, world: dojo::world::IWorldDispatcher) { + dojo::model::ModelEntity::::delete_entity(self, world); + } + + + fn get_x(world: dojo::world::IWorldDispatcher, entity_id: felt252) -> u16 { + let mut values = dojo::model::ModelEntity::::get_member( + world, + entity_id, + 512066735765477566404754172672287371265995314501343422459174036873487219331 + ); + let field_value = core::serde::Serde::::deserialize(ref values); + + if core::option::OptionTrait::::is_none(@field_value) { + panic!( + "Field `ModelWithTuple::x`: deserialization failed." + ); + } + + core::option::OptionTrait::::unwrap(field_value) + } + + fn set_x(self: @ModelWithTupleEntity, world: dojo::world::IWorldDispatcher, value: u16) { + let mut serialized = core::array::ArrayTrait::new(); + core::serde::Serde::serialize(@value, ref serialized); + + self.set_member( + world, + 512066735765477566404754172672287371265995314501343422459174036873487219331, + serialized.span() + ); + } + + fn get_y(world: dojo::world::IWorldDispatcher, entity_id: felt252) -> (u8, u16, u32) { + let mut values = dojo::model::ModelEntity::::get_member( + world, + entity_id, + 1591024729085637502504777720563487898377940395575083379770417352976841400819 + ); + let field_value = core::serde::Serde::<(u8, u16, u32)>::deserialize(ref values); + + if core::option::OptionTrait::<(u8, u16, u32)>::is_none(@field_value) { + panic!( + "Field `ModelWithTuple::y`: deserialization failed." + ); + } + + core::option::OptionTrait::<(u8, u16, u32)>::unwrap(field_value) + } + + fn set_y(self: @ModelWithTupleEntity, world: dojo::world::IWorldDispatcher, value: (u8, u16, u32)) { + let mut serialized = core::array::ArrayTrait::new(); + core::serde::Serde::serialize(@value, ref serialized); + + self.set_member( + world, + 1591024729085637502504777720563487898377940395575083379770417352976841400819, + serialized.span() + ); + } + +} + +#[generate_trait] +pub impl ModelWithTupleStoreImpl of ModelWithTupleStore { + fn entity_id_from_keys(player: ContractAddress) -> felt252 { + let mut serialized = core::array::ArrayTrait::new(); + core::serde::Serde::serialize(@player, ref serialized); + + core::poseidon::poseidon_hash_span(serialized.span()) + } + + fn from_values(ref keys: Span, ref values: Span) -> ModelWithTuple { + let mut serialized = core::array::ArrayTrait::new(); + serialized.append_span(keys); + serialized.append_span(values); + let mut serialized = core::array::ArrayTrait::span(@serialized); + + let entity = core::serde::Serde::::deserialize(ref serialized); + + if core::option::OptionTrait::::is_none(@entity) { + panic!( + "Model `ModelWithTuple`: deserialization failed. Ensure the length of the keys tuple is matching the number of #[key] fields in the model struct." + ); + } + + core::option::OptionTrait::::unwrap(entity) + } + + fn get(world: dojo::world::IWorldDispatcher, player: ContractAddress) -> ModelWithTuple { + let mut serialized = core::array::ArrayTrait::new(); + core::serde::Serde::serialize(@player, ref serialized); + + + dojo::model::Model::::get(world, serialized.span()) + } + + fn set(self: @ModelWithTuple, world: dojo::world::IWorldDispatcher) { + dojo::model::Model::::set_model(self, world); + } + + fn delete(self: @ModelWithTuple, world: dojo::world::IWorldDispatcher) { + dojo::model::Model::::delete_model(self, world); + } + + + fn get_x(world: dojo::world::IWorldDispatcher, player: ContractAddress) -> u16 { + let mut serialized = core::array::ArrayTrait::new(); + core::serde::Serde::serialize(@player, ref serialized); + + + let mut values = dojo::model::Model::::get_member( + world, + serialized.span(), + 512066735765477566404754172672287371265995314501343422459174036873487219331 + ); + + let field_value = core::serde::Serde::::deserialize(ref values); + + if core::option::OptionTrait::::is_none(@field_value) { + panic!( + "Field `ModelWithTuple::x`: deserialization failed." + ); + } + + core::option::OptionTrait::::unwrap(field_value) + } + + fn set_x(self: @ModelWithTuple, world: dojo::world::IWorldDispatcher, value: u16) { + let mut serialized = core::array::ArrayTrait::new(); + core::serde::Serde::serialize(@value, ref serialized); + + self.set_member( + world, + 512066735765477566404754172672287371265995314501343422459174036873487219331, + serialized.span() + ); + } + + fn get_y(world: dojo::world::IWorldDispatcher, player: ContractAddress) -> (u8, u16, u32) { + let mut serialized = core::array::ArrayTrait::new(); + core::serde::Serde::serialize(@player, ref serialized); + + + let mut values = dojo::model::Model::::get_member( + world, + serialized.span(), + 1591024729085637502504777720563487898377940395575083379770417352976841400819 + ); + + let field_value = core::serde::Serde::<(u8, u16, u32)>::deserialize(ref values); + + if core::option::OptionTrait::<(u8, u16, u32)>::is_none(@field_value) { + panic!( + "Field `ModelWithTuple::y`: deserialization failed." + ); + } + + core::option::OptionTrait::<(u8, u16, u32)>::unwrap(field_value) + } + + fn set_y(self: @ModelWithTuple, world: dojo::world::IWorldDispatcher, value: (u8, u16, u32)) { + let mut serialized = core::array::ArrayTrait::new(); + core::serde::Serde::serialize(@value, ref serialized); + + self.set_member( + world, + 1591024729085637502504777720563487898377940395575083379770417352976841400819, + serialized.span() + ); + } + +} + +pub impl ModelWithTupleModelEntityImpl of dojo::model::ModelEntity { + fn id(self: @ModelWithTupleEntity) -> felt252 { + *self.__id + } + + fn values(self: @ModelWithTupleEntity) -> Span { + let mut serialized = core::array::ArrayTrait::new(); + core::serde::Serde::serialize(self.x, ref serialized); +core::serde::Serde::serialize(self.y, ref serialized); + + core::array::ArrayTrait::span(@serialized) + } + + fn from_values(entity_id: felt252, ref values: Span) -> ModelWithTupleEntity { + let mut serialized = array![entity_id]; + serialized.append_span(values); + let mut serialized = core::array::ArrayTrait::span(@serialized); + + let entity_values = core::serde::Serde::::deserialize(ref serialized); + if core::option::OptionTrait::::is_none(@entity_values) { + panic!( + "ModelEntity `ModelWithTupleEntity`: deserialization failed." + ); + } + core::option::OptionTrait::::unwrap(entity_values) + } + + fn get(world: dojo::world::IWorldDispatcher, entity_id: felt252) -> ModelWithTupleEntity { + let mut values = dojo::world::IWorldDispatcherTrait::entity( + world, + dojo::model::Model::::selector(), + dojo::model::ModelIndex::Id(entity_id), + dojo::model::Model::::layout() + ); + Self::from_values(entity_id, ref values) + } + + fn update_entity(self: @ModelWithTupleEntity, world: dojo::world::IWorldDispatcher) { + dojo::world::IWorldDispatcherTrait::set_entity( + world, + dojo::model::Model::::selector(), + dojo::model::ModelIndex::Id(self.id()), + self.values(), + dojo::model::Model::::layout() + ); + } + + fn delete_entity(self: @ModelWithTupleEntity, world: dojo::world::IWorldDispatcher) { + dojo::world::IWorldDispatcherTrait::delete_entity( + world, + dojo::model::Model::::selector(), + dojo::model::ModelIndex::Id(self.id()), + dojo::model::Model::::layout() + ); + } + + fn get_member( + world: dojo::world::IWorldDispatcher, + entity_id: felt252, + member_id: felt252, + ) -> Span { + match dojo::utils::find_model_field_layout(dojo::model::Model::::layout(), member_id) { + Option::Some(field_layout) => { + dojo::world::IWorldDispatcherTrait::entity( + world, + dojo::model::Model::::selector(), + dojo::model::ModelIndex::MemberId((entity_id, member_id)), + field_layout + ) + }, + Option::None => core::panic_with_felt252('bad member id') + } + } + + fn set_member( + self: @ModelWithTupleEntity, + world: dojo::world::IWorldDispatcher, + member_id: felt252, + values: Span, + ) { + match dojo::utils::find_model_field_layout(dojo::model::Model::::layout(), member_id) { + Option::Some(field_layout) => { + dojo::world::IWorldDispatcherTrait::set_entity( + world, + dojo::model::Model::::selector(), + dojo::model::ModelIndex::MemberId((self.id(), member_id)), + values, + field_layout + ) + }, + Option::None => core::panic_with_felt252('bad member id') + } + } +} + +pub impl ModelWithTupleModelImpl of dojo::model::Model { + fn get(world: dojo::world::IWorldDispatcher, keys: Span) -> ModelWithTuple { + let mut values = dojo::world::IWorldDispatcherTrait::entity( + world, + Self::selector(), + dojo::model::ModelIndex::Keys(keys), + Self::layout() + ); + let mut _keys = keys; + + ModelWithTupleStore::from_values(ref _keys, ref values) + } + + fn set_model( + self: @ModelWithTuple, + world: dojo::world::IWorldDispatcher + ) { + dojo::world::IWorldDispatcherTrait::set_entity( + world, + Self::selector(), + dojo::model::ModelIndex::Keys(Self::keys(self)), + Self::values(self), + Self::layout() + ); + } + + fn delete_model( + self: @ModelWithTuple, + world: dojo::world::IWorldDispatcher + ) { + dojo::world::IWorldDispatcherTrait::delete_entity( + world, + Self::selector(), + dojo::model::ModelIndex::Keys(Self::keys(self)), + Self::layout() + ); + } + + fn get_member( + world: dojo::world::IWorldDispatcher, + keys: Span, + member_id: felt252 + ) -> Span { + match dojo::utils::find_model_field_layout(Self::layout(), member_id) { + Option::Some(field_layout) => { + let entity_id = dojo::utils::entity_id_from_keys(keys); + dojo::world::IWorldDispatcherTrait::entity( + world, + Self::selector(), + dojo::model::ModelIndex::MemberId((entity_id, member_id)), + field_layout + ) + }, + Option::None => core::panic_with_felt252('bad member id') + } + } + + fn set_member( + self: @ModelWithTuple, + world: dojo::world::IWorldDispatcher, + member_id: felt252, + values: Span + ) { + match dojo::utils::find_model_field_layout(Self::layout(), member_id) { + Option::Some(field_layout) => { + dojo::world::IWorldDispatcherTrait::set_entity( + world, + Self::selector(), + dojo::model::ModelIndex::MemberId((self.entity_id(), member_id)), + values, + field_layout + ) + }, + Option::None => core::panic_with_felt252('bad member id') + } + } + + #[inline(always)] + fn name() -> ByteArray { + "ModelWithTuple" + } + + #[inline(always)] + fn namespace() -> ByteArray { + "dojo_test" + } + + #[inline(always)] + fn tag() -> ByteArray { + "dojo_test-ModelWithTuple" + } + + #[inline(always)] + fn version() -> u8 { + 1 + } + + #[inline(always)] + fn selector() -> felt252 { + 2556860780543194947392385177981405629628409496147617432088261544126553394590 + } + + #[inline(always)] + fn instance_selector(self: @ModelWithTuple) -> felt252 { + Self::selector() + } + + #[inline(always)] + fn name_hash() -> felt252 { + 3222351670132870101782632958288197874250493316621507272653773018669253981260 + } + + #[inline(always)] + fn namespace_hash() -> felt252 { + 1452123528942907587532668415362544424816022573043154497385993678618948064048 + } + + #[inline(always)] + fn entity_id(self: @ModelWithTuple) -> felt252 { + core::poseidon::poseidon_hash_span(self.keys()) + } + + #[inline(always)] + fn keys(self: @ModelWithTuple) -> Span { + let mut serialized = core::array::ArrayTrait::new(); + core::serde::Serde::serialize(self.player, ref serialized); + + core::array::ArrayTrait::span(@serialized) + } + + #[inline(always)] + fn values(self: @ModelWithTuple) -> Span { + let mut serialized = core::array::ArrayTrait::new(); + core::serde::Serde::serialize(self.x, ref serialized); +core::serde::Serde::serialize(self.y, ref serialized); + + core::array::ArrayTrait::span(@serialized) + } + + #[inline(always)] + fn layout() -> dojo::model::Layout { + dojo::model::introspect::Introspect::::layout() + } + + #[inline(always)] + fn instance_layout(self: @ModelWithTuple) -> dojo::model::Layout { + Self::layout() + } + + #[inline(always)] + fn packed_size() -> Option { + dojo::model::layout::compute_packed_size(Self::layout()) + } +} + +#[starknet::interface] +pub trait Imodel_with_tuple { + fn ensure_abi(self: @T, model: ModelWithTuple); +} + +#[starknet::contract] +pub mod model_with_tuple { + use super::ModelWithTuple; + use super::Imodel_with_tuple; + + #[abi(embed_v0)] + impl DojoModelImpl of dojo::model::IModel{ + fn name(self: @ContractState) -> ByteArray { + "ModelWithTuple" + } + + fn namespace(self: @ContractState) -> ByteArray { + "dojo_test" + } + + fn tag(self: @ContractState) -> ByteArray { + "dojo_test-ModelWithTuple" + } + + fn version(self: @ContractState) -> u8 { + 1 + } + + fn selector(self: @ContractState) -> felt252 { + 2556860780543194947392385177981405629628409496147617432088261544126553394590 + } + + fn name_hash(self: @ContractState) -> felt252 { + 3222351670132870101782632958288197874250493316621507272653773018669253981260 + } + + fn namespace_hash(self: @ContractState) -> felt252 { + 1452123528942907587532668415362544424816022573043154497385993678618948064048 + } + + fn unpacked_size(self: @ContractState) -> Option { + dojo::model::introspect::Introspect::::size() + } + + fn packed_size(self: @ContractState) -> Option { + dojo::model::Model::::packed_size() + } + + fn layout(self: @ContractState) -> dojo::model::Layout { + dojo::model::Model::::layout() + } + + fn schema(self: @ContractState) -> dojo::model::introspect::Ty { + dojo::model::introspect::Introspect::::ty() + } + } + + #[abi(embed_v0)] + impl model_with_tupleImpl of Imodel_with_tuple{ + fn ensure_abi(self: @ContractState, model: ModelWithTuple) { + } + } +#[event] +#[derive(Drop, starknet::Event)] +pub enum Event {} + + +#[phantom] +pub struct Storage { +} + +#[derive(Drop, Copy)] +pub struct StorageStorageBase { +} +impl StorageStorageImpl of starknet::storage::StorageTrait { + type BaseType = StorageStorageBase; + fn storage(self: starknet::storage::FlattenedStorage) -> StorageStorageBase { + StorageStorageBase { + } + } +} +#[derive(Drop, Copy)] +pub struct StorageStorageBaseMut { +} +impl StorageStorageMutImpl of starknet::storage::StorageTraitMut { + type BaseType = StorageStorageBaseMut; + fn storage_mut(self: starknet::storage::FlattenedStorage>) -> StorageStorageBaseMut { + StorageStorageBaseMut { + } + } +} + +pub struct ContractState { +} + +impl ContractStateDrop of Drop {} + +impl ContractStateDeref of core::ops::SnapshotDeref { + type Target = starknet::storage::FlattenedStorage; + fn snapshot_deref(self: @ContractState) -> starknet::storage::FlattenedStorage { + starknet::storage::FlattenedStorage {} + } +} +impl ContractStateDerefMut of core::ops::DerefMut { + type Target = starknet::storage::FlattenedStorage> ; + fn deref_mut(ref self: ContractState) -> starknet::storage::FlattenedStorage> { + starknet::storage::FlattenedStorage {} + } +} +pub fn unsafe_new_contract_state() -> ContractState { + ContractState { + } +} + +// TODO(Gil): This generates duplicate diagnostics because of the plugin system, squash the duplicates into one. +#[deprecated( + feature: "deprecated_legacy_map", + note: "Use `starknet::storage::Map` instead." +)] +use starknet::storage::Map as LegacyMap; + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__DojoModelImpl__name(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = DojoModelImpl::name(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__DojoModelImpl__namespace(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = DojoModelImpl::namespace(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__DojoModelImpl__tag(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = DojoModelImpl::tag(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__DojoModelImpl__version(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = DojoModelImpl::version(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__DojoModelImpl__selector(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = DojoModelImpl::selector(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__DojoModelImpl__name_hash(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = DojoModelImpl::name_hash(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__DojoModelImpl__namespace_hash(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = DojoModelImpl::namespace_hash(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__DojoModelImpl__unpacked_size(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = DojoModelImpl::unpacked_size(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::>::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__DojoModelImpl__packed_size(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = DojoModelImpl::packed_size(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::>::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__DojoModelImpl__layout(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = DojoModelImpl::layout(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__DojoModelImpl__schema(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = DojoModelImpl::schema(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__model_with_tupleImpl__ensure_abi(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + let __arg_model = core::option::OptionTraitImpl::expect( + core::serde::Serde::::deserialize(ref data), + 'Failed to deserialize param #1' + ); + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + model_with_tupleImpl::ensure_abi(@contract_state, __arg_model); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::array::ArrayTrait::span(@arr) +} + + +pub mod __external { + pub use super::__wrapper__DojoModelImpl__name as name; + pub use super::__wrapper__DojoModelImpl__namespace as namespace; + pub use super::__wrapper__DojoModelImpl__tag as tag; + pub use super::__wrapper__DojoModelImpl__version as version; + pub use super::__wrapper__DojoModelImpl__selector as selector; + pub use super::__wrapper__DojoModelImpl__name_hash as name_hash; + pub use super::__wrapper__DojoModelImpl__namespace_hash as namespace_hash; + pub use super::__wrapper__DojoModelImpl__unpacked_size as unpacked_size; + pub use super::__wrapper__DojoModelImpl__packed_size as packed_size; + pub use super::__wrapper__DojoModelImpl__layout as layout; + pub use super::__wrapper__DojoModelImpl__schema as schema; + pub use super::__wrapper__model_with_tupleImpl__ensure_abi as ensure_abi; +} +pub mod __l1_handler { +} +pub mod __constructor { +} + impl ContractStateEventEmitter of starknet::event::EventEmitter< + ContractState, Event + > { + fn emit>( + ref self: ContractState, event: S + ) { + let event: Event = core::traits::Into::into(event); + let mut keys = Default::::default(); + let mut data = Default::::default(); + starknet::Event::append_keys_and_data(@event, ref keys, ref data); + starknet::SyscallResultTrait::unwrap_syscall( + starknet::syscalls::emit_event_syscall( + core::array::ArrayTrait::span(@keys), + core::array::ArrayTrait::span(@data), + ) + ) + } + } +impl EventDrop of core::traits::Drop::; +impl EventIsEvent of starknet::Event { + fn append_keys_and_data( + self: @Event, ref keys: Array, ref data: Array + ) { + match self { + } + } + fn deserialize( + ref keys: Span, ref data: Span, + ) -> Option { + let __selector__ = *core::array::SpanTrait::pop_front(ref keys)?; + Option::None + } +} +impl StorageStorageBaseDrop of core::traits::Drop::; +impl StorageStorageBaseCopy of core::traits::Copy::; +impl StorageStorageBaseMutDrop of core::traits::Drop::; +impl StorageStorageBaseMutCopy of core::traits::Copy::; +} + +impl ModelWithTupleNoPrimitivesIntrospect<> of dojo::model::introspect::Introspect> { + #[inline(always)] + fn size() -> Option { + let sizes : Array> = array![ + dojo::model::introspect::Introspect::::size(), +Option::Some(3) + ]; + + if dojo::utils::any_none(@sizes) { + return Option::None; + } + Option::Some(dojo::utils::sum(sizes)) + + } + + fn layout() -> dojo::model::Layout { + dojo::model::Layout::Struct( + array![ + dojo::model::FieldLayout { + selector: 512066735765477566404754172672287371265995314501343422459174036873487219331, + layout: dojo::model::introspect::Introspect::::layout() + }, +dojo::model::FieldLayout { + selector: 1591024729085637502504777720563487898377940395575083379770417352976841400819, + layout: dojo::model::Layout::Tuple( + array![ + dojo::model::introspect::Introspect::::layout(), +dojo::model::introspect::Introspect::::layout(), +dojo::model::introspect::Introspect::::layout() + ].span() + ) + } + ].span() + ) + } + + #[inline(always)] + fn ty() -> dojo::model::introspect::Ty { + dojo::model::introspect::Ty::Struct( + dojo::model::introspect::Struct { + name: 'ModelWithTupleNoPrimitives', + attrs: array![].span(), + children: array![ + dojo::model::introspect::Member { + name: 'player', + attrs: array!['key'].span(), + ty: dojo::model::introspect::Introspect::::ty() + }, +dojo::model::introspect::Member { + name: 'x', + attrs: array![].span(), + ty: dojo::model::introspect::Introspect::::ty() + }, +dojo::model::introspect::Member { + name: 'y', + attrs: array![].span(), + ty: dojo::model::introspect::Ty::Tuple( + array![ + dojo::model::introspect::Introspect::::ty(), +dojo::model::introspect::Introspect::::ty(), +dojo::model::introspect::Introspect::::ty() + ].span() + ) + } + + ].span() + } + ) + } +} + +#[derive(Drop, Serde)] +pub struct ModelWithTupleNoPrimitivesEntity { + __id: felt252, // private field + pub x: u16, +pub y: (u8, Vec3, u32), + +} + +#[generate_trait] +pub impl ModelWithTupleNoPrimitivesEntityStoreImpl of ModelWithTupleNoPrimitivesEntityStore { + fn get(world: dojo::world::IWorldDispatcher, entity_id: felt252) -> ModelWithTupleNoPrimitivesEntity { + ModelWithTupleNoPrimitivesModelEntityImpl::get(world, entity_id) + } + + fn update(self: @ModelWithTupleNoPrimitivesEntity, world: dojo::world::IWorldDispatcher) { + dojo::model::ModelEntity::::update_entity(self, world); + } + + fn delete(self: @ModelWithTupleNoPrimitivesEntity, world: dojo::world::IWorldDispatcher) { + dojo::model::ModelEntity::::delete_entity(self, world); + } + + + fn get_x(world: dojo::world::IWorldDispatcher, entity_id: felt252) -> u16 { + let mut values = dojo::model::ModelEntity::::get_member( + world, + entity_id, + 512066735765477566404754172672287371265995314501343422459174036873487219331 + ); + let field_value = core::serde::Serde::::deserialize(ref values); + + if core::option::OptionTrait::::is_none(@field_value) { + panic!( + "Field `ModelWithTupleNoPrimitives::x`: deserialization failed." + ); + } + + core::option::OptionTrait::::unwrap(field_value) + } + + fn set_x(self: @ModelWithTupleNoPrimitivesEntity, world: dojo::world::IWorldDispatcher, value: u16) { + let mut serialized = core::array::ArrayTrait::new(); + core::serde::Serde::serialize(@value, ref serialized); + + self.set_member( + world, + 512066735765477566404754172672287371265995314501343422459174036873487219331, + serialized.span() + ); + } + + fn get_y(world: dojo::world::IWorldDispatcher, entity_id: felt252) -> (u8, Vec3, u32) { + let mut values = dojo::model::ModelEntity::::get_member( + world, + entity_id, + 1591024729085637502504777720563487898377940395575083379770417352976841400819 + ); + let field_value = core::serde::Serde::<(u8, Vec3, u32)>::deserialize(ref values); + + if core::option::OptionTrait::<(u8, Vec3, u32)>::is_none(@field_value) { + panic!( + "Field `ModelWithTupleNoPrimitives::y`: deserialization failed." + ); + } + + core::option::OptionTrait::<(u8, Vec3, u32)>::unwrap(field_value) + } + + fn set_y(self: @ModelWithTupleNoPrimitivesEntity, world: dojo::world::IWorldDispatcher, value: (u8, Vec3, u32)) { + let mut serialized = core::array::ArrayTrait::new(); + core::serde::Serde::serialize(@value, ref serialized); + + self.set_member( + world, + 1591024729085637502504777720563487898377940395575083379770417352976841400819, + serialized.span() + ); + } + +} + +#[generate_trait] +pub impl ModelWithTupleNoPrimitivesStoreImpl of ModelWithTupleNoPrimitivesStore { + fn entity_id_from_keys(player: ContractAddress) -> felt252 { + let mut serialized = core::array::ArrayTrait::new(); + core::serde::Serde::serialize(@player, ref serialized); + + core::poseidon::poseidon_hash_span(serialized.span()) + } + + fn from_values(ref keys: Span, ref values: Span) -> ModelWithTupleNoPrimitives { + let mut serialized = core::array::ArrayTrait::new(); + serialized.append_span(keys); + serialized.append_span(values); + let mut serialized = core::array::ArrayTrait::span(@serialized); + + let entity = core::serde::Serde::::deserialize(ref serialized); + + if core::option::OptionTrait::::is_none(@entity) { + panic!( + "Model `ModelWithTupleNoPrimitives`: deserialization failed. Ensure the length of the keys tuple is matching the number of #[key] fields in the model struct." + ); + } + + core::option::OptionTrait::::unwrap(entity) + } + + fn get(world: dojo::world::IWorldDispatcher, player: ContractAddress) -> ModelWithTupleNoPrimitives { + let mut serialized = core::array::ArrayTrait::new(); + core::serde::Serde::serialize(@player, ref serialized); + + + dojo::model::Model::::get(world, serialized.span()) + } + + fn set(self: @ModelWithTupleNoPrimitives, world: dojo::world::IWorldDispatcher) { + dojo::model::Model::::set_model(self, world); + } + + fn delete(self: @ModelWithTupleNoPrimitives, world: dojo::world::IWorldDispatcher) { + dojo::model::Model::::delete_model(self, world); + } + + + fn get_x(world: dojo::world::IWorldDispatcher, player: ContractAddress) -> u16 { + let mut serialized = core::array::ArrayTrait::new(); + core::serde::Serde::serialize(@player, ref serialized); + + + let mut values = dojo::model::Model::::get_member( + world, + serialized.span(), + 512066735765477566404754172672287371265995314501343422459174036873487219331 + ); + + let field_value = core::serde::Serde::::deserialize(ref values); + + if core::option::OptionTrait::::is_none(@field_value) { + panic!( + "Field `ModelWithTupleNoPrimitives::x`: deserialization failed." + ); + } + + core::option::OptionTrait::::unwrap(field_value) + } + + fn set_x(self: @ModelWithTupleNoPrimitives, world: dojo::world::IWorldDispatcher, value: u16) { + let mut serialized = core::array::ArrayTrait::new(); + core::serde::Serde::serialize(@value, ref serialized); + + self.set_member( + world, + 512066735765477566404754172672287371265995314501343422459174036873487219331, + serialized.span() + ); + } + + fn get_y(world: dojo::world::IWorldDispatcher, player: ContractAddress) -> (u8, Vec3, u32) { + let mut serialized = core::array::ArrayTrait::new(); + core::serde::Serde::serialize(@player, ref serialized); + + + let mut values = dojo::model::Model::::get_member( + world, + serialized.span(), + 1591024729085637502504777720563487898377940395575083379770417352976841400819 + ); + + let field_value = core::serde::Serde::<(u8, Vec3, u32)>::deserialize(ref values); + + if core::option::OptionTrait::<(u8, Vec3, u32)>::is_none(@field_value) { + panic!( + "Field `ModelWithTupleNoPrimitives::y`: deserialization failed." + ); + } + + core::option::OptionTrait::<(u8, Vec3, u32)>::unwrap(field_value) + } + + fn set_y(self: @ModelWithTupleNoPrimitives, world: dojo::world::IWorldDispatcher, value: (u8, Vec3, u32)) { + let mut serialized = core::array::ArrayTrait::new(); + core::serde::Serde::serialize(@value, ref serialized); + + self.set_member( + world, + 1591024729085637502504777720563487898377940395575083379770417352976841400819, + serialized.span() + ); + } + +} + +pub impl ModelWithTupleNoPrimitivesModelEntityImpl of dojo::model::ModelEntity { + fn id(self: @ModelWithTupleNoPrimitivesEntity) -> felt252 { + *self.__id + } + + fn values(self: @ModelWithTupleNoPrimitivesEntity) -> Span { + let mut serialized = core::array::ArrayTrait::new(); + core::serde::Serde::serialize(self.x, ref serialized); +core::serde::Serde::serialize(self.y, ref serialized); + + core::array::ArrayTrait::span(@serialized) + } + + fn from_values(entity_id: felt252, ref values: Span) -> ModelWithTupleNoPrimitivesEntity { + let mut serialized = array![entity_id]; + serialized.append_span(values); + let mut serialized = core::array::ArrayTrait::span(@serialized); + + let entity_values = core::serde::Serde::::deserialize(ref serialized); + if core::option::OptionTrait::::is_none(@entity_values) { + panic!( + "ModelEntity `ModelWithTupleNoPrimitivesEntity`: deserialization failed." + ); + } + core::option::OptionTrait::::unwrap(entity_values) + } + + fn get(world: dojo::world::IWorldDispatcher, entity_id: felt252) -> ModelWithTupleNoPrimitivesEntity { + let mut values = dojo::world::IWorldDispatcherTrait::entity( + world, + dojo::model::Model::::selector(), + dojo::model::ModelIndex::Id(entity_id), + dojo::model::Model::::layout() + ); + Self::from_values(entity_id, ref values) + } + + fn update_entity(self: @ModelWithTupleNoPrimitivesEntity, world: dojo::world::IWorldDispatcher) { + dojo::world::IWorldDispatcherTrait::set_entity( + world, + dojo::model::Model::::selector(), + dojo::model::ModelIndex::Id(self.id()), + self.values(), + dojo::model::Model::::layout() + ); + } + + fn delete_entity(self: @ModelWithTupleNoPrimitivesEntity, world: dojo::world::IWorldDispatcher) { + dojo::world::IWorldDispatcherTrait::delete_entity( + world, + dojo::model::Model::::selector(), + dojo::model::ModelIndex::Id(self.id()), + dojo::model::Model::::layout() + ); + } + + fn get_member( + world: dojo::world::IWorldDispatcher, + entity_id: felt252, + member_id: felt252, + ) -> Span { + match dojo::utils::find_model_field_layout(dojo::model::Model::::layout(), member_id) { + Option::Some(field_layout) => { + dojo::world::IWorldDispatcherTrait::entity( + world, + dojo::model::Model::::selector(), + dojo::model::ModelIndex::MemberId((entity_id, member_id)), + field_layout + ) + }, + Option::None => core::panic_with_felt252('bad member id') + } + } + + fn set_member( + self: @ModelWithTupleNoPrimitivesEntity, + world: dojo::world::IWorldDispatcher, + member_id: felt252, + values: Span, + ) { + match dojo::utils::find_model_field_layout(dojo::model::Model::::layout(), member_id) { + Option::Some(field_layout) => { + dojo::world::IWorldDispatcherTrait::set_entity( + world, + dojo::model::Model::::selector(), + dojo::model::ModelIndex::MemberId((self.id(), member_id)), + values, + field_layout + ) + }, + Option::None => core::panic_with_felt252('bad member id') + } + } +} + +pub impl ModelWithTupleNoPrimitivesModelImpl of dojo::model::Model { + fn get(world: dojo::world::IWorldDispatcher, keys: Span) -> ModelWithTupleNoPrimitives { + let mut values = dojo::world::IWorldDispatcherTrait::entity( + world, + Self::selector(), + dojo::model::ModelIndex::Keys(keys), + Self::layout() + ); + let mut _keys = keys; + + ModelWithTupleNoPrimitivesStore::from_values(ref _keys, ref values) + } + + fn set_model( + self: @ModelWithTupleNoPrimitives, + world: dojo::world::IWorldDispatcher + ) { + dojo::world::IWorldDispatcherTrait::set_entity( + world, + Self::selector(), + dojo::model::ModelIndex::Keys(Self::keys(self)), + Self::values(self), + Self::layout() + ); + } + + fn delete_model( + self: @ModelWithTupleNoPrimitives, + world: dojo::world::IWorldDispatcher + ) { + dojo::world::IWorldDispatcherTrait::delete_entity( + world, + Self::selector(), + dojo::model::ModelIndex::Keys(Self::keys(self)), + Self::layout() + ); + } + + fn get_member( + world: dojo::world::IWorldDispatcher, + keys: Span, + member_id: felt252 + ) -> Span { + match dojo::utils::find_model_field_layout(Self::layout(), member_id) { + Option::Some(field_layout) => { + let entity_id = dojo::utils::entity_id_from_keys(keys); + dojo::world::IWorldDispatcherTrait::entity( + world, + Self::selector(), + dojo::model::ModelIndex::MemberId((entity_id, member_id)), + field_layout + ) + }, + Option::None => core::panic_with_felt252('bad member id') + } + } + + fn set_member( + self: @ModelWithTupleNoPrimitives, + world: dojo::world::IWorldDispatcher, + member_id: felt252, + values: Span + ) { + match dojo::utils::find_model_field_layout(Self::layout(), member_id) { + Option::Some(field_layout) => { + dojo::world::IWorldDispatcherTrait::set_entity( + world, + Self::selector(), + dojo::model::ModelIndex::MemberId((self.entity_id(), member_id)), + values, + field_layout + ) + }, + Option::None => core::panic_with_felt252('bad member id') + } + } + + #[inline(always)] + fn name() -> ByteArray { + "ModelWithTupleNoPrimitives" + } + + #[inline(always)] + fn namespace() -> ByteArray { + "dojo_test" + } + + #[inline(always)] + fn tag() -> ByteArray { + "dojo_test-ModelWithTupleNoPrimitives" + } + + #[inline(always)] + fn version() -> u8 { + 1 + } + + #[inline(always)] + fn selector() -> felt252 { + 59168777730614245274545541976317431416582911855710103554159293691166950405 + } + + #[inline(always)] + fn instance_selector(self: @ModelWithTupleNoPrimitives) -> felt252 { + Self::selector() + } + + #[inline(always)] + fn name_hash() -> felt252 { + 157059227407493660591195028728750607977045261142495925435047270200565107096 + } + + #[inline(always)] + fn namespace_hash() -> felt252 { + 1452123528942907587532668415362544424816022573043154497385993678618948064048 + } + + #[inline(always)] + fn entity_id(self: @ModelWithTupleNoPrimitives) -> felt252 { + core::poseidon::poseidon_hash_span(self.keys()) + } + + #[inline(always)] + fn keys(self: @ModelWithTupleNoPrimitives) -> Span { + let mut serialized = core::array::ArrayTrait::new(); + core::serde::Serde::serialize(self.player, ref serialized); + + core::array::ArrayTrait::span(@serialized) + } + + #[inline(always)] + fn values(self: @ModelWithTupleNoPrimitives) -> Span { + let mut serialized = core::array::ArrayTrait::new(); + core::serde::Serde::serialize(self.x, ref serialized); +core::serde::Serde::serialize(self.y, ref serialized); + + core::array::ArrayTrait::span(@serialized) + } + + #[inline(always)] + fn layout() -> dojo::model::Layout { + dojo::model::introspect::Introspect::::layout() + } + + #[inline(always)] + fn instance_layout(self: @ModelWithTupleNoPrimitives) -> dojo::model::Layout { + Self::layout() + } + + #[inline(always)] + fn packed_size() -> Option { + dojo::model::layout::compute_packed_size(Self::layout()) + } +} + +#[starknet::interface] +pub trait Imodel_with_tuple_no_primitives { + fn ensure_abi(self: @T, model: ModelWithTupleNoPrimitives); +} + +#[starknet::contract] +pub mod model_with_tuple_no_primitives { + use super::ModelWithTupleNoPrimitives; + use super::Imodel_with_tuple_no_primitives; + + #[abi(embed_v0)] + impl DojoModelImpl of dojo::model::IModel{ + fn name(self: @ContractState) -> ByteArray { + "ModelWithTupleNoPrimitives" + } + + fn namespace(self: @ContractState) -> ByteArray { + "dojo_test" + } + + fn tag(self: @ContractState) -> ByteArray { + "dojo_test-ModelWithTupleNoPrimitives" + } + + fn version(self: @ContractState) -> u8 { + 1 + } + + fn selector(self: @ContractState) -> felt252 { + 59168777730614245274545541976317431416582911855710103554159293691166950405 + } + + fn name_hash(self: @ContractState) -> felt252 { + 157059227407493660591195028728750607977045261142495925435047270200565107096 + } + + fn namespace_hash(self: @ContractState) -> felt252 { + 1452123528942907587532668415362544424816022573043154497385993678618948064048 + } + + fn unpacked_size(self: @ContractState) -> Option { + dojo::model::introspect::Introspect::::size() + } + + fn packed_size(self: @ContractState) -> Option { + dojo::model::Model::::packed_size() + } + + fn layout(self: @ContractState) -> dojo::model::Layout { + dojo::model::Model::::layout() + } + + fn schema(self: @ContractState) -> dojo::model::introspect::Ty { + dojo::model::introspect::Introspect::::ty() + } + } + + #[abi(embed_v0)] + impl model_with_tuple_no_primitivesImpl of Imodel_with_tuple_no_primitives{ + fn ensure_abi(self: @ContractState, model: ModelWithTupleNoPrimitives) { + } + } +#[event] +#[derive(Drop, starknet::Event)] +pub enum Event {} + + +#[phantom] +pub struct Storage { +} + +#[derive(Drop, Copy)] +pub struct StorageStorageBase { +} +impl StorageStorageImpl of starknet::storage::StorageTrait { + type BaseType = StorageStorageBase; + fn storage(self: starknet::storage::FlattenedStorage) -> StorageStorageBase { + StorageStorageBase { + } + } +} +#[derive(Drop, Copy)] +pub struct StorageStorageBaseMut { +} +impl StorageStorageMutImpl of starknet::storage::StorageTraitMut { + type BaseType = StorageStorageBaseMut; + fn storage_mut(self: starknet::storage::FlattenedStorage>) -> StorageStorageBaseMut { + StorageStorageBaseMut { + } + } +} + +pub struct ContractState { +} + +impl ContractStateDrop of Drop {} + +impl ContractStateDeref of core::ops::SnapshotDeref { + type Target = starknet::storage::FlattenedStorage; + fn snapshot_deref(self: @ContractState) -> starknet::storage::FlattenedStorage { + starknet::storage::FlattenedStorage {} + } +} +impl ContractStateDerefMut of core::ops::DerefMut { + type Target = starknet::storage::FlattenedStorage> ; + fn deref_mut(ref self: ContractState) -> starknet::storage::FlattenedStorage> { + starknet::storage::FlattenedStorage {} + } +} +pub fn unsafe_new_contract_state() -> ContractState { + ContractState { + } +} + +// TODO(Gil): This generates duplicate diagnostics because of the plugin system, squash the duplicates into one. +#[deprecated( + feature: "deprecated_legacy_map", + note: "Use `starknet::storage::Map` instead." +)] +use starknet::storage::Map as LegacyMap; + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__DojoModelImpl__name(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = DojoModelImpl::name(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__DojoModelImpl__namespace(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = DojoModelImpl::namespace(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__DojoModelImpl__tag(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = DojoModelImpl::tag(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__DojoModelImpl__version(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = DojoModelImpl::version(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__DojoModelImpl__selector(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = DojoModelImpl::selector(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__DojoModelImpl__name_hash(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = DojoModelImpl::name_hash(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__DojoModelImpl__namespace_hash(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = DojoModelImpl::namespace_hash(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__DojoModelImpl__unpacked_size(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = DojoModelImpl::unpacked_size(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::>::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__DojoModelImpl__packed_size(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = DojoModelImpl::packed_size(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::>::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__DojoModelImpl__layout(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = DojoModelImpl::layout(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__DojoModelImpl__schema(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = DojoModelImpl::schema(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__model_with_tuple_no_primitivesImpl__ensure_abi(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + let __arg_model = core::option::OptionTraitImpl::expect( + core::serde::Serde::::deserialize(ref data), + 'Failed to deserialize param #1' + ); + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + model_with_tuple_no_primitivesImpl::ensure_abi(@contract_state, __arg_model); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::array::ArrayTrait::span(@arr) +} + + +pub mod __external { + pub use super::__wrapper__DojoModelImpl__name as name; + pub use super::__wrapper__DojoModelImpl__namespace as namespace; + pub use super::__wrapper__DojoModelImpl__tag as tag; + pub use super::__wrapper__DojoModelImpl__version as version; + pub use super::__wrapper__DojoModelImpl__selector as selector; + pub use super::__wrapper__DojoModelImpl__name_hash as name_hash; + pub use super::__wrapper__DojoModelImpl__namespace_hash as namespace_hash; + pub use super::__wrapper__DojoModelImpl__unpacked_size as unpacked_size; + pub use super::__wrapper__DojoModelImpl__packed_size as packed_size; + pub use super::__wrapper__DojoModelImpl__layout as layout; + pub use super::__wrapper__DojoModelImpl__schema as schema; + pub use super::__wrapper__model_with_tuple_no_primitivesImpl__ensure_abi as ensure_abi; +} +pub mod __l1_handler { +} +pub mod __constructor { +} + impl ContractStateEventEmitter of starknet::event::EventEmitter< + ContractState, Event + > { + fn emit>( + ref self: ContractState, event: S + ) { + let event: Event = core::traits::Into::into(event); + let mut keys = Default::::default(); + let mut data = Default::::default(); + starknet::Event::append_keys_and_data(@event, ref keys, ref data); + starknet::SyscallResultTrait::unwrap_syscall( + starknet::syscalls::emit_event_syscall( + core::array::ArrayTrait::span(@keys), + core::array::ArrayTrait::span(@data), + ) + ) + } + } +impl EventDrop of core::traits::Drop::; +impl EventIsEvent of starknet::Event { + fn append_keys_and_data( + self: @Event, ref keys: Array, ref data: Array + ) { + match self { + } + } + fn deserialize( + ref keys: Span, ref data: Span, + ) -> Option { + let __selector__ = *core::array::SpanTrait::pop_front(ref keys)?; + Option::None + } +} +impl StorageStorageBaseDrop of core::traits::Drop::; +impl StorageStorageBaseCopy of core::traits::Copy::; +impl StorageStorageBaseMutDrop of core::traits::Drop::; +impl StorageStorageBaseMutCopy of core::traits::Copy::; +} +impl BadModelMultipleVersionsEntityDrop of core::traits::Drop::; +impl BadModelMultipleVersionsEntitySerde of core::serde::Serde:: { + fn serialize(self: @BadModelMultipleVersionsEntity, ref output: core::array::Array) { + core::serde::Serde::serialize(self.__id, ref output); + core::serde::Serde::serialize(self.v, ref output) + } + fn deserialize(ref serialized: core::array::Span) -> core::option::Option { + core::option::Option::Some(BadModelMultipleVersionsEntity { + __id: core::serde::Serde::deserialize(ref serialized)?, + v: core::serde::Serde::deserialize(ref serialized)?, + }) + } +} +pub trait BadModelMultipleVersionsEntityStore { + fn get(world: dojo::world::IWorldDispatcher, entity_id: felt252) -> BadModelMultipleVersionsEntity; + + fn update(self: @BadModelMultipleVersionsEntity, world: dojo::world::IWorldDispatcher); + + fn delete(self: @BadModelMultipleVersionsEntity, world: dojo::world::IWorldDispatcher); + + + fn get_v(world: dojo::world::IWorldDispatcher, entity_id: felt252) -> Vec3; + + fn set_v(self: @BadModelMultipleVersionsEntity, world: dojo::world::IWorldDispatcher, value: Vec3); + +} +pub trait BadModelMultipleVersionsStore { + fn entity_id_from_keys(id: felt252) -> felt252; + + fn from_values(ref keys: Span, ref values: Span) -> BadModelMultipleVersions; + + fn get(world: dojo::world::IWorldDispatcher, id: felt252) -> BadModelMultipleVersions; + + fn set(self: @BadModelMultipleVersions, world: dojo::world::IWorldDispatcher); + + fn delete(self: @BadModelMultipleVersions, world: dojo::world::IWorldDispatcher); + + + fn get_v(world: dojo::world::IWorldDispatcher, id: felt252) -> Vec3; + + fn set_v(self: @BadModelMultipleVersions, world: dojo::world::IWorldDispatcher, value: Vec3); + +} +pub trait Ibad_model_multiple_versionsDispatcherTrait { + fn ensure_abi(self: T, model: BadModelMultipleVersions); +} + +#[derive(Copy, Drop, starknet::Store, Serde)] +pub struct Ibad_model_multiple_versionsDispatcher { + pub contract_address: starknet::ContractAddress, +} + +impl Ibad_model_multiple_versionsDispatcherImpl of Ibad_model_multiple_versionsDispatcherTrait { + fn ensure_abi(self: Ibad_model_multiple_versionsDispatcher, model: BadModelMultipleVersions) { + let mut __calldata__ = core::traits::Default::default(); + core::serde::Serde::::serialize(@model, ref __calldata__); + + let mut __dispatcher_return_data__ = starknet::syscalls::call_contract_syscall( + self.contract_address, + selector!("ensure_abi"), + core::array::ArrayTrait::span(@__calldata__), + ); + let mut __dispatcher_return_data__ = starknet::SyscallResultTrait::unwrap_syscall(__dispatcher_return_data__); + () + } + +} + +#[derive(Copy, Drop, starknet::Store, Serde)] +pub struct Ibad_model_multiple_versionsLibraryDispatcher { + pub class_hash: starknet::ClassHash, +} + +impl Ibad_model_multiple_versionsLibraryDispatcherImpl of Ibad_model_multiple_versionsDispatcherTrait { + fn ensure_abi(self: Ibad_model_multiple_versionsLibraryDispatcher, model: BadModelMultipleVersions) { + let mut __calldata__ = core::traits::Default::default(); + core::serde::Serde::::serialize(@model, ref __calldata__); + + let mut __dispatcher_return_data__ = starknet::syscalls::library_call_syscall( + self.class_hash, + selector!("ensure_abi"), + core::array::ArrayTrait::span(@__calldata__), + ); + let mut __dispatcher_return_data__ = starknet::SyscallResultTrait::unwrap_syscall(__dispatcher_return_data__); + () + } + +} + +pub trait Ibad_model_multiple_versionsSafeDispatcherTrait { + #[unstable(feature: "safe_dispatcher")] + fn ensure_abi(self: T, model: BadModelMultipleVersions) -> starknet::SyscallResult<()>; +} + +#[derive(Copy, Drop, starknet::Store, Serde)] +pub struct Ibad_model_multiple_versionsSafeLibraryDispatcher { + pub class_hash: starknet::ClassHash, +} + +impl Ibad_model_multiple_versionsSafeLibraryDispatcherImpl of Ibad_model_multiple_versionsSafeDispatcherTrait { + fn ensure_abi(self: Ibad_model_multiple_versionsSafeLibraryDispatcher, model: BadModelMultipleVersions) -> starknet::SyscallResult<()> { + let mut __calldata__ = core::traits::Default::default(); + core::serde::Serde::::serialize(@model, ref __calldata__); + + let mut __dispatcher_return_data__ = starknet::syscalls::library_call_syscall( + self.class_hash, + selector!("ensure_abi"), + core::array::ArrayTrait::span(@__calldata__), + ); + let mut __dispatcher_return_data__ = __dispatcher_return_data__?; + Result::Ok(()) + } + +} + + +#[derive(Copy, Drop, starknet::Store, Serde)] +pub struct Ibad_model_multiple_versionsSafeDispatcher { + pub contract_address: starknet::ContractAddress, +} + +impl Ibad_model_multiple_versionsSafeDispatcherImpl of Ibad_model_multiple_versionsSafeDispatcherTrait { + fn ensure_abi(self: Ibad_model_multiple_versionsSafeDispatcher, model: BadModelMultipleVersions) -> starknet::SyscallResult<()> { + let mut __calldata__ = core::traits::Default::default(); + core::serde::Serde::::serialize(@model, ref __calldata__); + + let mut __dispatcher_return_data__ = starknet::syscalls::call_contract_syscall( + self.contract_address, + selector!("ensure_abi"), + core::array::ArrayTrait::span(@__calldata__), + ); + let mut __dispatcher_return_data__ = __dispatcher_return_data__?; + Result::Ok(()) + } + +} +impl BadModelBadVersionTypeEntityDrop of core::traits::Drop::; +impl BadModelBadVersionTypeEntitySerde of core::serde::Serde:: { + fn serialize(self: @BadModelBadVersionTypeEntity, ref output: core::array::Array) { + core::serde::Serde::serialize(self.__id, ref output); + core::serde::Serde::serialize(self.v, ref output) + } + fn deserialize(ref serialized: core::array::Span) -> core::option::Option { + core::option::Option::Some(BadModelBadVersionTypeEntity { + __id: core::serde::Serde::deserialize(ref serialized)?, + v: core::serde::Serde::deserialize(ref serialized)?, + }) + } +} +pub trait BadModelBadVersionTypeEntityStore { + fn get(world: dojo::world::IWorldDispatcher, entity_id: felt252) -> BadModelBadVersionTypeEntity; + + fn update(self: @BadModelBadVersionTypeEntity, world: dojo::world::IWorldDispatcher); + + fn delete(self: @BadModelBadVersionTypeEntity, world: dojo::world::IWorldDispatcher); + + + fn get_v(world: dojo::world::IWorldDispatcher, entity_id: felt252) -> Vec3; + + fn set_v(self: @BadModelBadVersionTypeEntity, world: dojo::world::IWorldDispatcher, value: Vec3); + +} +pub trait BadModelBadVersionTypeStore { + fn entity_id_from_keys(id: felt252) -> felt252; + + fn from_values(ref keys: Span, ref values: Span) -> BadModelBadVersionType; + + fn get(world: dojo::world::IWorldDispatcher, id: felt252) -> BadModelBadVersionType; + + fn set(self: @BadModelBadVersionType, world: dojo::world::IWorldDispatcher); + + fn delete(self: @BadModelBadVersionType, world: dojo::world::IWorldDispatcher); + + + fn get_v(world: dojo::world::IWorldDispatcher, id: felt252) -> Vec3; + + fn set_v(self: @BadModelBadVersionType, world: dojo::world::IWorldDispatcher, value: Vec3); + +} +pub trait Ibad_model_bad_version_typeDispatcherTrait { + fn ensure_abi(self: T, model: BadModelBadVersionType); +} + +#[derive(Copy, Drop, starknet::Store, Serde)] +pub struct Ibad_model_bad_version_typeDispatcher { + pub contract_address: starknet::ContractAddress, +} + +impl Ibad_model_bad_version_typeDispatcherImpl of Ibad_model_bad_version_typeDispatcherTrait { + fn ensure_abi(self: Ibad_model_bad_version_typeDispatcher, model: BadModelBadVersionType) { + let mut __calldata__ = core::traits::Default::default(); + core::serde::Serde::::serialize(@model, ref __calldata__); + + let mut __dispatcher_return_data__ = starknet::syscalls::call_contract_syscall( + self.contract_address, + selector!("ensure_abi"), + core::array::ArrayTrait::span(@__calldata__), + ); + let mut __dispatcher_return_data__ = starknet::SyscallResultTrait::unwrap_syscall(__dispatcher_return_data__); + () + } + +} + +#[derive(Copy, Drop, starknet::Store, Serde)] +pub struct Ibad_model_bad_version_typeLibraryDispatcher { + pub class_hash: starknet::ClassHash, +} + +impl Ibad_model_bad_version_typeLibraryDispatcherImpl of Ibad_model_bad_version_typeDispatcherTrait { + fn ensure_abi(self: Ibad_model_bad_version_typeLibraryDispatcher, model: BadModelBadVersionType) { + let mut __calldata__ = core::traits::Default::default(); + core::serde::Serde::::serialize(@model, ref __calldata__); + + let mut __dispatcher_return_data__ = starknet::syscalls::library_call_syscall( + self.class_hash, + selector!("ensure_abi"), + core::array::ArrayTrait::span(@__calldata__), + ); + let mut __dispatcher_return_data__ = starknet::SyscallResultTrait::unwrap_syscall(__dispatcher_return_data__); + () + } + +} + +pub trait Ibad_model_bad_version_typeSafeDispatcherTrait { + #[unstable(feature: "safe_dispatcher")] + fn ensure_abi(self: T, model: BadModelBadVersionType) -> starknet::SyscallResult<()>; +} + +#[derive(Copy, Drop, starknet::Store, Serde)] +pub struct Ibad_model_bad_version_typeSafeLibraryDispatcher { + pub class_hash: starknet::ClassHash, +} + +impl Ibad_model_bad_version_typeSafeLibraryDispatcherImpl of Ibad_model_bad_version_typeSafeDispatcherTrait { + fn ensure_abi(self: Ibad_model_bad_version_typeSafeLibraryDispatcher, model: BadModelBadVersionType) -> starknet::SyscallResult<()> { + let mut __calldata__ = core::traits::Default::default(); + core::serde::Serde::::serialize(@model, ref __calldata__); + + let mut __dispatcher_return_data__ = starknet::syscalls::library_call_syscall( + self.class_hash, + selector!("ensure_abi"), + core::array::ArrayTrait::span(@__calldata__), + ); + let mut __dispatcher_return_data__ = __dispatcher_return_data__?; + Result::Ok(()) + } + +} + + +#[derive(Copy, Drop, starknet::Store, Serde)] +pub struct Ibad_model_bad_version_typeSafeDispatcher { + pub contract_address: starknet::ContractAddress, +} + +impl Ibad_model_bad_version_typeSafeDispatcherImpl of Ibad_model_bad_version_typeSafeDispatcherTrait { + fn ensure_abi(self: Ibad_model_bad_version_typeSafeDispatcher, model: BadModelBadVersionType) -> starknet::SyscallResult<()> { + let mut __calldata__ = core::traits::Default::default(); + core::serde::Serde::::serialize(@model, ref __calldata__); + + let mut __dispatcher_return_data__ = starknet::syscalls::call_contract_syscall( + self.contract_address, + selector!("ensure_abi"), + core::array::ArrayTrait::span(@__calldata__), + ); + let mut __dispatcher_return_data__ = __dispatcher_return_data__?; + Result::Ok(()) + } + +} +impl BadModelNoVersionValueEntityDrop of core::traits::Drop::; +impl BadModelNoVersionValueEntitySerde of core::serde::Serde:: { + fn serialize(self: @BadModelNoVersionValueEntity, ref output: core::array::Array) { + core::serde::Serde::serialize(self.__id, ref output); + core::serde::Serde::serialize(self.v, ref output) + } + fn deserialize(ref serialized: core::array::Span) -> core::option::Option { + core::option::Option::Some(BadModelNoVersionValueEntity { + __id: core::serde::Serde::deserialize(ref serialized)?, + v: core::serde::Serde::deserialize(ref serialized)?, + }) + } +} +pub trait BadModelNoVersionValueEntityStore { + fn get(world: dojo::world::IWorldDispatcher, entity_id: felt252) -> BadModelNoVersionValueEntity; + + fn update(self: @BadModelNoVersionValueEntity, world: dojo::world::IWorldDispatcher); + + fn delete(self: @BadModelNoVersionValueEntity, world: dojo::world::IWorldDispatcher); + + + fn get_v(world: dojo::world::IWorldDispatcher, entity_id: felt252) -> Vec3; + + fn set_v(self: @BadModelNoVersionValueEntity, world: dojo::world::IWorldDispatcher, value: Vec3); + +} +pub trait BadModelNoVersionValueStore { + fn entity_id_from_keys(id: felt252) -> felt252; + + fn from_values(ref keys: Span, ref values: Span) -> BadModelNoVersionValue; + + fn get(world: dojo::world::IWorldDispatcher, id: felt252) -> BadModelNoVersionValue; + + fn set(self: @BadModelNoVersionValue, world: dojo::world::IWorldDispatcher); + + fn delete(self: @BadModelNoVersionValue, world: dojo::world::IWorldDispatcher); + + + fn get_v(world: dojo::world::IWorldDispatcher, id: felt252) -> Vec3; + + fn set_v(self: @BadModelNoVersionValue, world: dojo::world::IWorldDispatcher, value: Vec3); + +} +pub trait Ibad_model_no_version_valueDispatcherTrait { + fn ensure_abi(self: T, model: BadModelNoVersionValue); +} + +#[derive(Copy, Drop, starknet::Store, Serde)] +pub struct Ibad_model_no_version_valueDispatcher { + pub contract_address: starknet::ContractAddress, +} + +impl Ibad_model_no_version_valueDispatcherImpl of Ibad_model_no_version_valueDispatcherTrait { + fn ensure_abi(self: Ibad_model_no_version_valueDispatcher, model: BadModelNoVersionValue) { + let mut __calldata__ = core::traits::Default::default(); + core::serde::Serde::::serialize(@model, ref __calldata__); + + let mut __dispatcher_return_data__ = starknet::syscalls::call_contract_syscall( + self.contract_address, + selector!("ensure_abi"), + core::array::ArrayTrait::span(@__calldata__), + ); + let mut __dispatcher_return_data__ = starknet::SyscallResultTrait::unwrap_syscall(__dispatcher_return_data__); + () + } + +} + +#[derive(Copy, Drop, starknet::Store, Serde)] +pub struct Ibad_model_no_version_valueLibraryDispatcher { + pub class_hash: starknet::ClassHash, +} + +impl Ibad_model_no_version_valueLibraryDispatcherImpl of Ibad_model_no_version_valueDispatcherTrait { + fn ensure_abi(self: Ibad_model_no_version_valueLibraryDispatcher, model: BadModelNoVersionValue) { + let mut __calldata__ = core::traits::Default::default(); + core::serde::Serde::::serialize(@model, ref __calldata__); + + let mut __dispatcher_return_data__ = starknet::syscalls::library_call_syscall( + self.class_hash, + selector!("ensure_abi"), + core::array::ArrayTrait::span(@__calldata__), + ); + let mut __dispatcher_return_data__ = starknet::SyscallResultTrait::unwrap_syscall(__dispatcher_return_data__); + () + } + +} + +pub trait Ibad_model_no_version_valueSafeDispatcherTrait { + #[unstable(feature: "safe_dispatcher")] + fn ensure_abi(self: T, model: BadModelNoVersionValue) -> starknet::SyscallResult<()>; +} + +#[derive(Copy, Drop, starknet::Store, Serde)] +pub struct Ibad_model_no_version_valueSafeLibraryDispatcher { + pub class_hash: starknet::ClassHash, +} + +impl Ibad_model_no_version_valueSafeLibraryDispatcherImpl of Ibad_model_no_version_valueSafeDispatcherTrait { + fn ensure_abi(self: Ibad_model_no_version_valueSafeLibraryDispatcher, model: BadModelNoVersionValue) -> starknet::SyscallResult<()> { + let mut __calldata__ = core::traits::Default::default(); + core::serde::Serde::::serialize(@model, ref __calldata__); + + let mut __dispatcher_return_data__ = starknet::syscalls::library_call_syscall( + self.class_hash, + selector!("ensure_abi"), + core::array::ArrayTrait::span(@__calldata__), + ); + let mut __dispatcher_return_data__ = __dispatcher_return_data__?; + Result::Ok(()) + } + +} + + +#[derive(Copy, Drop, starknet::Store, Serde)] +pub struct Ibad_model_no_version_valueSafeDispatcher { + pub contract_address: starknet::ContractAddress, +} + +impl Ibad_model_no_version_valueSafeDispatcherImpl of Ibad_model_no_version_valueSafeDispatcherTrait { + fn ensure_abi(self: Ibad_model_no_version_valueSafeDispatcher, model: BadModelNoVersionValue) -> starknet::SyscallResult<()> { + let mut __calldata__ = core::traits::Default::default(); + core::serde::Serde::::serialize(@model, ref __calldata__); + + let mut __dispatcher_return_data__ = starknet::syscalls::call_contract_syscall( + self.contract_address, + selector!("ensure_abi"), + core::array::ArrayTrait::span(@__calldata__), + ); + let mut __dispatcher_return_data__ = __dispatcher_return_data__?; + Result::Ok(()) + } + +} +impl BadModelUnexpectedArgWithValueEntityDrop of core::traits::Drop::; +impl BadModelUnexpectedArgWithValueEntitySerde of core::serde::Serde:: { + fn serialize(self: @BadModelUnexpectedArgWithValueEntity, ref output: core::array::Array) { + core::serde::Serde::serialize(self.__id, ref output); + core::serde::Serde::serialize(self.v, ref output) + } + fn deserialize(ref serialized: core::array::Span) -> core::option::Option { + core::option::Option::Some(BadModelUnexpectedArgWithValueEntity { + __id: core::serde::Serde::deserialize(ref serialized)?, + v: core::serde::Serde::deserialize(ref serialized)?, + }) + } +} +pub trait BadModelUnexpectedArgWithValueEntityStore { + fn get(world: dojo::world::IWorldDispatcher, entity_id: felt252) -> BadModelUnexpectedArgWithValueEntity; + + fn update(self: @BadModelUnexpectedArgWithValueEntity, world: dojo::world::IWorldDispatcher); + + fn delete(self: @BadModelUnexpectedArgWithValueEntity, world: dojo::world::IWorldDispatcher); + + + fn get_v(world: dojo::world::IWorldDispatcher, entity_id: felt252) -> Vec3; + + fn set_v(self: @BadModelUnexpectedArgWithValueEntity, world: dojo::world::IWorldDispatcher, value: Vec3); + +} +pub trait BadModelUnexpectedArgWithValueStore { + fn entity_id_from_keys(id: felt252) -> felt252; + + fn from_values(ref keys: Span, ref values: Span) -> BadModelUnexpectedArgWithValue; + + fn get(world: dojo::world::IWorldDispatcher, id: felt252) -> BadModelUnexpectedArgWithValue; + + fn set(self: @BadModelUnexpectedArgWithValue, world: dojo::world::IWorldDispatcher); + + fn delete(self: @BadModelUnexpectedArgWithValue, world: dojo::world::IWorldDispatcher); + + + fn get_v(world: dojo::world::IWorldDispatcher, id: felt252) -> Vec3; + + fn set_v(self: @BadModelUnexpectedArgWithValue, world: dojo::world::IWorldDispatcher, value: Vec3); + +} +pub trait Ibad_model_unexpected_arg_with_valueDispatcherTrait { + fn ensure_abi(self: T, model: BadModelUnexpectedArgWithValue); +} + +#[derive(Copy, Drop, starknet::Store, Serde)] +pub struct Ibad_model_unexpected_arg_with_valueDispatcher { + pub contract_address: starknet::ContractAddress, +} + +impl Ibad_model_unexpected_arg_with_valueDispatcherImpl of Ibad_model_unexpected_arg_with_valueDispatcherTrait { + fn ensure_abi(self: Ibad_model_unexpected_arg_with_valueDispatcher, model: BadModelUnexpectedArgWithValue) { + let mut __calldata__ = core::traits::Default::default(); + core::serde::Serde::::serialize(@model, ref __calldata__); + + let mut __dispatcher_return_data__ = starknet::syscalls::call_contract_syscall( + self.contract_address, + selector!("ensure_abi"), + core::array::ArrayTrait::span(@__calldata__), + ); + let mut __dispatcher_return_data__ = starknet::SyscallResultTrait::unwrap_syscall(__dispatcher_return_data__); + () + } + +} + +#[derive(Copy, Drop, starknet::Store, Serde)] +pub struct Ibad_model_unexpected_arg_with_valueLibraryDispatcher { + pub class_hash: starknet::ClassHash, +} + +impl Ibad_model_unexpected_arg_with_valueLibraryDispatcherImpl of Ibad_model_unexpected_arg_with_valueDispatcherTrait { + fn ensure_abi(self: Ibad_model_unexpected_arg_with_valueLibraryDispatcher, model: BadModelUnexpectedArgWithValue) { + let mut __calldata__ = core::traits::Default::default(); + core::serde::Serde::::serialize(@model, ref __calldata__); + + let mut __dispatcher_return_data__ = starknet::syscalls::library_call_syscall( + self.class_hash, + selector!("ensure_abi"), + core::array::ArrayTrait::span(@__calldata__), + ); + let mut __dispatcher_return_data__ = starknet::SyscallResultTrait::unwrap_syscall(__dispatcher_return_data__); + () + } + +} + +pub trait Ibad_model_unexpected_arg_with_valueSafeDispatcherTrait { + #[unstable(feature: "safe_dispatcher")] + fn ensure_abi(self: T, model: BadModelUnexpectedArgWithValue) -> starknet::SyscallResult<()>; +} + +#[derive(Copy, Drop, starknet::Store, Serde)] +pub struct Ibad_model_unexpected_arg_with_valueSafeLibraryDispatcher { + pub class_hash: starknet::ClassHash, +} + +impl Ibad_model_unexpected_arg_with_valueSafeLibraryDispatcherImpl of Ibad_model_unexpected_arg_with_valueSafeDispatcherTrait { + fn ensure_abi(self: Ibad_model_unexpected_arg_with_valueSafeLibraryDispatcher, model: BadModelUnexpectedArgWithValue) -> starknet::SyscallResult<()> { + let mut __calldata__ = core::traits::Default::default(); + core::serde::Serde::::serialize(@model, ref __calldata__); + + let mut __dispatcher_return_data__ = starknet::syscalls::library_call_syscall( + self.class_hash, + selector!("ensure_abi"), + core::array::ArrayTrait::span(@__calldata__), + ); + let mut __dispatcher_return_data__ = __dispatcher_return_data__?; + Result::Ok(()) + } + +} + + +#[derive(Copy, Drop, starknet::Store, Serde)] +pub struct Ibad_model_unexpected_arg_with_valueSafeDispatcher { + pub contract_address: starknet::ContractAddress, +} + +impl Ibad_model_unexpected_arg_with_valueSafeDispatcherImpl of Ibad_model_unexpected_arg_with_valueSafeDispatcherTrait { + fn ensure_abi(self: Ibad_model_unexpected_arg_with_valueSafeDispatcher, model: BadModelUnexpectedArgWithValue) -> starknet::SyscallResult<()> { + let mut __calldata__ = core::traits::Default::default(); + core::serde::Serde::::serialize(@model, ref __calldata__); + + let mut __dispatcher_return_data__ = starknet::syscalls::call_contract_syscall( + self.contract_address, + selector!("ensure_abi"), + core::array::ArrayTrait::span(@__calldata__), + ); + let mut __dispatcher_return_data__ = __dispatcher_return_data__?; + Result::Ok(()) + } + +} +impl BadModelUnexpectedArgEntityDrop of core::traits::Drop::; +impl BadModelUnexpectedArgEntitySerde of core::serde::Serde:: { + fn serialize(self: @BadModelUnexpectedArgEntity, ref output: core::array::Array) { + core::serde::Serde::serialize(self.__id, ref output); + core::serde::Serde::serialize(self.v, ref output) + } + fn deserialize(ref serialized: core::array::Span) -> core::option::Option { + core::option::Option::Some(BadModelUnexpectedArgEntity { + __id: core::serde::Serde::deserialize(ref serialized)?, + v: core::serde::Serde::deserialize(ref serialized)?, + }) + } +} +pub trait BadModelUnexpectedArgEntityStore { + fn get(world: dojo::world::IWorldDispatcher, entity_id: felt252) -> BadModelUnexpectedArgEntity; + + fn update(self: @BadModelUnexpectedArgEntity, world: dojo::world::IWorldDispatcher); + + fn delete(self: @BadModelUnexpectedArgEntity, world: dojo::world::IWorldDispatcher); + + + fn get_v(world: dojo::world::IWorldDispatcher, entity_id: felt252) -> Vec3; + + fn set_v(self: @BadModelUnexpectedArgEntity, world: dojo::world::IWorldDispatcher, value: Vec3); + +} +pub trait BadModelUnexpectedArgStore { + fn entity_id_from_keys(id: felt252) -> felt252; + + fn from_values(ref keys: Span, ref values: Span) -> BadModelUnexpectedArg; + + fn get(world: dojo::world::IWorldDispatcher, id: felt252) -> BadModelUnexpectedArg; + + fn set(self: @BadModelUnexpectedArg, world: dojo::world::IWorldDispatcher); + + fn delete(self: @BadModelUnexpectedArg, world: dojo::world::IWorldDispatcher); + + + fn get_v(world: dojo::world::IWorldDispatcher, id: felt252) -> Vec3; + + fn set_v(self: @BadModelUnexpectedArg, world: dojo::world::IWorldDispatcher, value: Vec3); + +} +pub trait Ibad_model_unexpected_argDispatcherTrait { + fn ensure_abi(self: T, model: BadModelUnexpectedArg); +} + +#[derive(Copy, Drop, starknet::Store, Serde)] +pub struct Ibad_model_unexpected_argDispatcher { + pub contract_address: starknet::ContractAddress, +} + +impl Ibad_model_unexpected_argDispatcherImpl of Ibad_model_unexpected_argDispatcherTrait { + fn ensure_abi(self: Ibad_model_unexpected_argDispatcher, model: BadModelUnexpectedArg) { + let mut __calldata__ = core::traits::Default::default(); + core::serde::Serde::::serialize(@model, ref __calldata__); + + let mut __dispatcher_return_data__ = starknet::syscalls::call_contract_syscall( + self.contract_address, + selector!("ensure_abi"), + core::array::ArrayTrait::span(@__calldata__), + ); + let mut __dispatcher_return_data__ = starknet::SyscallResultTrait::unwrap_syscall(__dispatcher_return_data__); + () + } + +} + +#[derive(Copy, Drop, starknet::Store, Serde)] +pub struct Ibad_model_unexpected_argLibraryDispatcher { + pub class_hash: starknet::ClassHash, +} + +impl Ibad_model_unexpected_argLibraryDispatcherImpl of Ibad_model_unexpected_argDispatcherTrait { + fn ensure_abi(self: Ibad_model_unexpected_argLibraryDispatcher, model: BadModelUnexpectedArg) { + let mut __calldata__ = core::traits::Default::default(); + core::serde::Serde::::serialize(@model, ref __calldata__); + + let mut __dispatcher_return_data__ = starknet::syscalls::library_call_syscall( + self.class_hash, + selector!("ensure_abi"), + core::array::ArrayTrait::span(@__calldata__), + ); + let mut __dispatcher_return_data__ = starknet::SyscallResultTrait::unwrap_syscall(__dispatcher_return_data__); + () + } + +} + +pub trait Ibad_model_unexpected_argSafeDispatcherTrait { + #[unstable(feature: "safe_dispatcher")] + fn ensure_abi(self: T, model: BadModelUnexpectedArg) -> starknet::SyscallResult<()>; +} + +#[derive(Copy, Drop, starknet::Store, Serde)] +pub struct Ibad_model_unexpected_argSafeLibraryDispatcher { + pub class_hash: starknet::ClassHash, +} + +impl Ibad_model_unexpected_argSafeLibraryDispatcherImpl of Ibad_model_unexpected_argSafeDispatcherTrait { + fn ensure_abi(self: Ibad_model_unexpected_argSafeLibraryDispatcher, model: BadModelUnexpectedArg) -> starknet::SyscallResult<()> { + let mut __calldata__ = core::traits::Default::default(); + core::serde::Serde::::serialize(@model, ref __calldata__); + + let mut __dispatcher_return_data__ = starknet::syscalls::library_call_syscall( + self.class_hash, + selector!("ensure_abi"), + core::array::ArrayTrait::span(@__calldata__), + ); + let mut __dispatcher_return_data__ = __dispatcher_return_data__?; + Result::Ok(()) + } + +} + + +#[derive(Copy, Drop, starknet::Store, Serde)] +pub struct Ibad_model_unexpected_argSafeDispatcher { + pub contract_address: starknet::ContractAddress, +} + +impl Ibad_model_unexpected_argSafeDispatcherImpl of Ibad_model_unexpected_argSafeDispatcherTrait { + fn ensure_abi(self: Ibad_model_unexpected_argSafeDispatcher, model: BadModelUnexpectedArg) -> starknet::SyscallResult<()> { + let mut __calldata__ = core::traits::Default::default(); + core::serde::Serde::::serialize(@model, ref __calldata__); + + let mut __dispatcher_return_data__ = starknet::syscalls::call_contract_syscall( + self.contract_address, + selector!("ensure_abi"), + core::array::ArrayTrait::span(@__calldata__), + ); + let mut __dispatcher_return_data__ = __dispatcher_return_data__?; + Result::Ok(()) + } + +} +impl BadModelNotSupportedVersionEntityDrop of core::traits::Drop::; +impl BadModelNotSupportedVersionEntitySerde of core::serde::Serde:: { + fn serialize(self: @BadModelNotSupportedVersionEntity, ref output: core::array::Array) { + core::serde::Serde::serialize(self.__id, ref output); + core::serde::Serde::serialize(self.v, ref output) + } + fn deserialize(ref serialized: core::array::Span) -> core::option::Option { + core::option::Option::Some(BadModelNotSupportedVersionEntity { + __id: core::serde::Serde::deserialize(ref serialized)?, + v: core::serde::Serde::deserialize(ref serialized)?, + }) + } +} +pub trait BadModelNotSupportedVersionEntityStore { + fn get(world: dojo::world::IWorldDispatcher, entity_id: felt252) -> BadModelNotSupportedVersionEntity; + + fn update(self: @BadModelNotSupportedVersionEntity, world: dojo::world::IWorldDispatcher); + + fn delete(self: @BadModelNotSupportedVersionEntity, world: dojo::world::IWorldDispatcher); + + + fn get_v(world: dojo::world::IWorldDispatcher, entity_id: felt252) -> Vec3; + + fn set_v(self: @BadModelNotSupportedVersionEntity, world: dojo::world::IWorldDispatcher, value: Vec3); + +} +pub trait BadModelNotSupportedVersionStore { + fn entity_id_from_keys(id: felt252) -> felt252; + + fn from_values(ref keys: Span, ref values: Span) -> BadModelNotSupportedVersion; + + fn get(world: dojo::world::IWorldDispatcher, id: felt252) -> BadModelNotSupportedVersion; + + fn set(self: @BadModelNotSupportedVersion, world: dojo::world::IWorldDispatcher); + + fn delete(self: @BadModelNotSupportedVersion, world: dojo::world::IWorldDispatcher); + + + fn get_v(world: dojo::world::IWorldDispatcher, id: felt252) -> Vec3; + + fn set_v(self: @BadModelNotSupportedVersion, world: dojo::world::IWorldDispatcher, value: Vec3); + +} +pub trait Ibad_model_not_supported_versionDispatcherTrait { + fn ensure_abi(self: T, model: BadModelNotSupportedVersion); +} + +#[derive(Copy, Drop, starknet::Store, Serde)] +pub struct Ibad_model_not_supported_versionDispatcher { + pub contract_address: starknet::ContractAddress, +} + +impl Ibad_model_not_supported_versionDispatcherImpl of Ibad_model_not_supported_versionDispatcherTrait { + fn ensure_abi(self: Ibad_model_not_supported_versionDispatcher, model: BadModelNotSupportedVersion) { + let mut __calldata__ = core::traits::Default::default(); + core::serde::Serde::::serialize(@model, ref __calldata__); + + let mut __dispatcher_return_data__ = starknet::syscalls::call_contract_syscall( + self.contract_address, + selector!("ensure_abi"), + core::array::ArrayTrait::span(@__calldata__), + ); + let mut __dispatcher_return_data__ = starknet::SyscallResultTrait::unwrap_syscall(__dispatcher_return_data__); + () + } + +} + +#[derive(Copy, Drop, starknet::Store, Serde)] +pub struct Ibad_model_not_supported_versionLibraryDispatcher { + pub class_hash: starknet::ClassHash, +} + +impl Ibad_model_not_supported_versionLibraryDispatcherImpl of Ibad_model_not_supported_versionDispatcherTrait { + fn ensure_abi(self: Ibad_model_not_supported_versionLibraryDispatcher, model: BadModelNotSupportedVersion) { + let mut __calldata__ = core::traits::Default::default(); + core::serde::Serde::::serialize(@model, ref __calldata__); + + let mut __dispatcher_return_data__ = starknet::syscalls::library_call_syscall( + self.class_hash, + selector!("ensure_abi"), + core::array::ArrayTrait::span(@__calldata__), + ); + let mut __dispatcher_return_data__ = starknet::SyscallResultTrait::unwrap_syscall(__dispatcher_return_data__); + () + } + +} + +pub trait Ibad_model_not_supported_versionSafeDispatcherTrait { + #[unstable(feature: "safe_dispatcher")] + fn ensure_abi(self: T, model: BadModelNotSupportedVersion) -> starknet::SyscallResult<()>; +} + +#[derive(Copy, Drop, starknet::Store, Serde)] +pub struct Ibad_model_not_supported_versionSafeLibraryDispatcher { + pub class_hash: starknet::ClassHash, +} + +impl Ibad_model_not_supported_versionSafeLibraryDispatcherImpl of Ibad_model_not_supported_versionSafeDispatcherTrait { + fn ensure_abi(self: Ibad_model_not_supported_versionSafeLibraryDispatcher, model: BadModelNotSupportedVersion) -> starknet::SyscallResult<()> { + let mut __calldata__ = core::traits::Default::default(); + core::serde::Serde::::serialize(@model, ref __calldata__); + + let mut __dispatcher_return_data__ = starknet::syscalls::library_call_syscall( + self.class_hash, + selector!("ensure_abi"), + core::array::ArrayTrait::span(@__calldata__), + ); + let mut __dispatcher_return_data__ = __dispatcher_return_data__?; + Result::Ok(()) + } + +} + + +#[derive(Copy, Drop, starknet::Store, Serde)] +pub struct Ibad_model_not_supported_versionSafeDispatcher { + pub contract_address: starknet::ContractAddress, +} + +impl Ibad_model_not_supported_versionSafeDispatcherImpl of Ibad_model_not_supported_versionSafeDispatcherTrait { + fn ensure_abi(self: Ibad_model_not_supported_versionSafeDispatcher, model: BadModelNotSupportedVersion) -> starknet::SyscallResult<()> { + let mut __calldata__ = core::traits::Default::default(); + core::serde::Serde::::serialize(@model, ref __calldata__); + + let mut __dispatcher_return_data__ = starknet::syscalls::call_contract_syscall( + self.contract_address, + selector!("ensure_abi"), + core::array::ArrayTrait::span(@__calldata__), + ); + let mut __dispatcher_return_data__ = __dispatcher_return_data__?; + Result::Ok(()) + } + +} +impl Modelv0EntityDrop of core::traits::Drop::; +impl Modelv0EntitySerde of core::serde::Serde:: { + fn serialize(self: @Modelv0Entity, ref output: core::array::Array) { + core::serde::Serde::serialize(self.__id, ref output); + core::serde::Serde::serialize(self.v, ref output) + } + fn deserialize(ref serialized: core::array::Span) -> core::option::Option { + core::option::Option::Some(Modelv0Entity { + __id: core::serde::Serde::deserialize(ref serialized)?, + v: core::serde::Serde::deserialize(ref serialized)?, + }) + } +} +pub trait Modelv0EntityStore { + fn get(world: dojo::world::IWorldDispatcher, entity_id: felt252) -> Modelv0Entity; + + fn update(self: @Modelv0Entity, world: dojo::world::IWorldDispatcher); + + fn delete(self: @Modelv0Entity, world: dojo::world::IWorldDispatcher); + + + fn get_v(world: dojo::world::IWorldDispatcher, entity_id: felt252) -> Vec3; + + fn set_v(self: @Modelv0Entity, world: dojo::world::IWorldDispatcher, value: Vec3); + +} +pub trait Modelv0Store { + fn entity_id_from_keys(id: felt252) -> felt252; + + fn from_values(ref keys: Span, ref values: Span) -> Modelv0; + + fn get(world: dojo::world::IWorldDispatcher, id: felt252) -> Modelv0; + + fn set(self: @Modelv0, world: dojo::world::IWorldDispatcher); + + fn delete(self: @Modelv0, world: dojo::world::IWorldDispatcher); + + + fn get_v(world: dojo::world::IWorldDispatcher, id: felt252) -> Vec3; + + fn set_v(self: @Modelv0, world: dojo::world::IWorldDispatcher, value: Vec3); + +} +pub trait Imodelv_0DispatcherTrait { + fn ensure_abi(self: T, model: Modelv0); +} + +#[derive(Copy, Drop, starknet::Store, Serde)] +pub struct Imodelv_0Dispatcher { + pub contract_address: starknet::ContractAddress, +} + +impl Imodelv_0DispatcherImpl of Imodelv_0DispatcherTrait { + fn ensure_abi(self: Imodelv_0Dispatcher, model: Modelv0) { + let mut __calldata__ = core::traits::Default::default(); + core::serde::Serde::::serialize(@model, ref __calldata__); + + let mut __dispatcher_return_data__ = starknet::syscalls::call_contract_syscall( + self.contract_address, + selector!("ensure_abi"), + core::array::ArrayTrait::span(@__calldata__), + ); + let mut __dispatcher_return_data__ = starknet::SyscallResultTrait::unwrap_syscall(__dispatcher_return_data__); + () + } + +} + +#[derive(Copy, Drop, starknet::Store, Serde)] +pub struct Imodelv_0LibraryDispatcher { + pub class_hash: starknet::ClassHash, +} + +impl Imodelv_0LibraryDispatcherImpl of Imodelv_0DispatcherTrait { + fn ensure_abi(self: Imodelv_0LibraryDispatcher, model: Modelv0) { + let mut __calldata__ = core::traits::Default::default(); + core::serde::Serde::::serialize(@model, ref __calldata__); + + let mut __dispatcher_return_data__ = starknet::syscalls::library_call_syscall( + self.class_hash, + selector!("ensure_abi"), + core::array::ArrayTrait::span(@__calldata__), + ); + let mut __dispatcher_return_data__ = starknet::SyscallResultTrait::unwrap_syscall(__dispatcher_return_data__); + () + } + +} + +pub trait Imodelv_0SafeDispatcherTrait { + #[unstable(feature: "safe_dispatcher")] + fn ensure_abi(self: T, model: Modelv0) -> starknet::SyscallResult<()>; +} + +#[derive(Copy, Drop, starknet::Store, Serde)] +pub struct Imodelv_0SafeLibraryDispatcher { + pub class_hash: starknet::ClassHash, +} + +impl Imodelv_0SafeLibraryDispatcherImpl of Imodelv_0SafeDispatcherTrait { + fn ensure_abi(self: Imodelv_0SafeLibraryDispatcher, model: Modelv0) -> starknet::SyscallResult<()> { + let mut __calldata__ = core::traits::Default::default(); + core::serde::Serde::::serialize(@model, ref __calldata__); + + let mut __dispatcher_return_data__ = starknet::syscalls::library_call_syscall( + self.class_hash, + selector!("ensure_abi"), + core::array::ArrayTrait::span(@__calldata__), + ); + let mut __dispatcher_return_data__ = __dispatcher_return_data__?; + Result::Ok(()) + } + +} + + +#[derive(Copy, Drop, starknet::Store, Serde)] +pub struct Imodelv_0SafeDispatcher { + pub contract_address: starknet::ContractAddress, +} + +impl Imodelv_0SafeDispatcherImpl of Imodelv_0SafeDispatcherTrait { + fn ensure_abi(self: Imodelv_0SafeDispatcher, model: Modelv0) -> starknet::SyscallResult<()> { + let mut __calldata__ = core::traits::Default::default(); + core::serde::Serde::::serialize(@model, ref __calldata__); + + let mut __dispatcher_return_data__ = starknet::syscalls::call_contract_syscall( + self.contract_address, + selector!("ensure_abi"), + core::array::ArrayTrait::span(@__calldata__), + ); + let mut __dispatcher_return_data__ = __dispatcher_return_data__?; + Result::Ok(()) + } + +} +impl ModelWithBadNamespaceFormatEntityDrop of core::traits::Drop::; +impl ModelWithBadNamespaceFormatEntitySerde of core::serde::Serde:: { + fn serialize(self: @ModelWithBadNamespaceFormatEntity, ref output: core::array::Array) { + core::serde::Serde::serialize(self.__id, ref output); + core::serde::Serde::serialize(self.v, ref output) + } + fn deserialize(ref serialized: core::array::Span) -> core::option::Option { + core::option::Option::Some(ModelWithBadNamespaceFormatEntity { + __id: core::serde::Serde::deserialize(ref serialized)?, + v: core::serde::Serde::deserialize(ref serialized)?, + }) + } +} +pub trait ModelWithBadNamespaceFormatEntityStore { + fn get(world: dojo::world::IWorldDispatcher, entity_id: felt252) -> ModelWithBadNamespaceFormatEntity; + + fn update(self: @ModelWithBadNamespaceFormatEntity, world: dojo::world::IWorldDispatcher); + + fn delete(self: @ModelWithBadNamespaceFormatEntity, world: dojo::world::IWorldDispatcher); + + + fn get_v(world: dojo::world::IWorldDispatcher, entity_id: felt252) -> Vec3; + + fn set_v(self: @ModelWithBadNamespaceFormatEntity, world: dojo::world::IWorldDispatcher, value: Vec3); + +} +pub trait ModelWithBadNamespaceFormatStore { + fn entity_id_from_keys(id: felt252) -> felt252; + + fn from_values(ref keys: Span, ref values: Span) -> ModelWithBadNamespaceFormat; + + fn get(world: dojo::world::IWorldDispatcher, id: felt252) -> ModelWithBadNamespaceFormat; + + fn set(self: @ModelWithBadNamespaceFormat, world: dojo::world::IWorldDispatcher); + + fn delete(self: @ModelWithBadNamespaceFormat, world: dojo::world::IWorldDispatcher); + + + fn get_v(world: dojo::world::IWorldDispatcher, id: felt252) -> Vec3; + + fn set_v(self: @ModelWithBadNamespaceFormat, world: dojo::world::IWorldDispatcher, value: Vec3); + +} +pub trait Imodel_with_bad_namespace_formatDispatcherTrait { + fn ensure_abi(self: T, model: ModelWithBadNamespaceFormat); +} + +#[derive(Copy, Drop, starknet::Store, Serde)] +pub struct Imodel_with_bad_namespace_formatDispatcher { + pub contract_address: starknet::ContractAddress, +} + +impl Imodel_with_bad_namespace_formatDispatcherImpl of Imodel_with_bad_namespace_formatDispatcherTrait { + fn ensure_abi(self: Imodel_with_bad_namespace_formatDispatcher, model: ModelWithBadNamespaceFormat) { + let mut __calldata__ = core::traits::Default::default(); + core::serde::Serde::::serialize(@model, ref __calldata__); + + let mut __dispatcher_return_data__ = starknet::syscalls::call_contract_syscall( + self.contract_address, + selector!("ensure_abi"), + core::array::ArrayTrait::span(@__calldata__), + ); + let mut __dispatcher_return_data__ = starknet::SyscallResultTrait::unwrap_syscall(__dispatcher_return_data__); + () + } + +} + +#[derive(Copy, Drop, starknet::Store, Serde)] +pub struct Imodel_with_bad_namespace_formatLibraryDispatcher { + pub class_hash: starknet::ClassHash, +} + +impl Imodel_with_bad_namespace_formatLibraryDispatcherImpl of Imodel_with_bad_namespace_formatDispatcherTrait { + fn ensure_abi(self: Imodel_with_bad_namespace_formatLibraryDispatcher, model: ModelWithBadNamespaceFormat) { + let mut __calldata__ = core::traits::Default::default(); + core::serde::Serde::::serialize(@model, ref __calldata__); + + let mut __dispatcher_return_data__ = starknet::syscalls::library_call_syscall( + self.class_hash, + selector!("ensure_abi"), + core::array::ArrayTrait::span(@__calldata__), + ); + let mut __dispatcher_return_data__ = starknet::SyscallResultTrait::unwrap_syscall(__dispatcher_return_data__); + () + } + +} + +pub trait Imodel_with_bad_namespace_formatSafeDispatcherTrait { + #[unstable(feature: "safe_dispatcher")] + fn ensure_abi(self: T, model: ModelWithBadNamespaceFormat) -> starknet::SyscallResult<()>; +} + +#[derive(Copy, Drop, starknet::Store, Serde)] +pub struct Imodel_with_bad_namespace_formatSafeLibraryDispatcher { + pub class_hash: starknet::ClassHash, +} + +impl Imodel_with_bad_namespace_formatSafeLibraryDispatcherImpl of Imodel_with_bad_namespace_formatSafeDispatcherTrait { + fn ensure_abi(self: Imodel_with_bad_namespace_formatSafeLibraryDispatcher, model: ModelWithBadNamespaceFormat) -> starknet::SyscallResult<()> { + let mut __calldata__ = core::traits::Default::default(); + core::serde::Serde::::serialize(@model, ref __calldata__); + + let mut __dispatcher_return_data__ = starknet::syscalls::library_call_syscall( + self.class_hash, + selector!("ensure_abi"), + core::array::ArrayTrait::span(@__calldata__), + ); + let mut __dispatcher_return_data__ = __dispatcher_return_data__?; + Result::Ok(()) + } + +} + + +#[derive(Copy, Drop, starknet::Store, Serde)] +pub struct Imodel_with_bad_namespace_formatSafeDispatcher { + pub contract_address: starknet::ContractAddress, +} + +impl Imodel_with_bad_namespace_formatSafeDispatcherImpl of Imodel_with_bad_namespace_formatSafeDispatcherTrait { + fn ensure_abi(self: Imodel_with_bad_namespace_formatSafeDispatcher, model: ModelWithBadNamespaceFormat) -> starknet::SyscallResult<()> { + let mut __calldata__ = core::traits::Default::default(); + core::serde::Serde::::serialize(@model, ref __calldata__); + + let mut __dispatcher_return_data__ = starknet::syscalls::call_contract_syscall( + self.contract_address, + selector!("ensure_abi"), + core::array::ArrayTrait::span(@__calldata__), + ); + let mut __dispatcher_return_data__ = __dispatcher_return_data__?; + Result::Ok(()) + } + +} +impl ModelWithShortStringNamespaceEntityDrop of core::traits::Drop::; +impl ModelWithShortStringNamespaceEntitySerde of core::serde::Serde:: { + fn serialize(self: @ModelWithShortStringNamespaceEntity, ref output: core::array::Array) { + core::serde::Serde::serialize(self.__id, ref output); + core::serde::Serde::serialize(self.v, ref output) + } + fn deserialize(ref serialized: core::array::Span) -> core::option::Option { + core::option::Option::Some(ModelWithShortStringNamespaceEntity { + __id: core::serde::Serde::deserialize(ref serialized)?, + v: core::serde::Serde::deserialize(ref serialized)?, + }) + } +} +pub trait ModelWithShortStringNamespaceEntityStore { + fn get(world: dojo::world::IWorldDispatcher, entity_id: felt252) -> ModelWithShortStringNamespaceEntity; + + fn update(self: @ModelWithShortStringNamespaceEntity, world: dojo::world::IWorldDispatcher); + + fn delete(self: @ModelWithShortStringNamespaceEntity, world: dojo::world::IWorldDispatcher); + + + fn get_v(world: dojo::world::IWorldDispatcher, entity_id: felt252) -> Vec3; + + fn set_v(self: @ModelWithShortStringNamespaceEntity, world: dojo::world::IWorldDispatcher, value: Vec3); + +} +pub trait ModelWithShortStringNamespaceStore { + fn entity_id_from_keys(id: felt252) -> felt252; + + fn from_values(ref keys: Span, ref values: Span) -> ModelWithShortStringNamespace; + + fn get(world: dojo::world::IWorldDispatcher, id: felt252) -> ModelWithShortStringNamespace; + + fn set(self: @ModelWithShortStringNamespace, world: dojo::world::IWorldDispatcher); + + fn delete(self: @ModelWithShortStringNamespace, world: dojo::world::IWorldDispatcher); + + + fn get_v(world: dojo::world::IWorldDispatcher, id: felt252) -> Vec3; + + fn set_v(self: @ModelWithShortStringNamespace, world: dojo::world::IWorldDispatcher, value: Vec3); + +} +pub trait Imodel_with_short_string_namespaceDispatcherTrait { + fn ensure_abi(self: T, model: ModelWithShortStringNamespace); +} + +#[derive(Copy, Drop, starknet::Store, Serde)] +pub struct Imodel_with_short_string_namespaceDispatcher { + pub contract_address: starknet::ContractAddress, +} + +impl Imodel_with_short_string_namespaceDispatcherImpl of Imodel_with_short_string_namespaceDispatcherTrait { + fn ensure_abi(self: Imodel_with_short_string_namespaceDispatcher, model: ModelWithShortStringNamespace) { + let mut __calldata__ = core::traits::Default::default(); + core::serde::Serde::::serialize(@model, ref __calldata__); + + let mut __dispatcher_return_data__ = starknet::syscalls::call_contract_syscall( + self.contract_address, + selector!("ensure_abi"), + core::array::ArrayTrait::span(@__calldata__), + ); + let mut __dispatcher_return_data__ = starknet::SyscallResultTrait::unwrap_syscall(__dispatcher_return_data__); + () + } + +} + +#[derive(Copy, Drop, starknet::Store, Serde)] +pub struct Imodel_with_short_string_namespaceLibraryDispatcher { + pub class_hash: starknet::ClassHash, +} + +impl Imodel_with_short_string_namespaceLibraryDispatcherImpl of Imodel_with_short_string_namespaceDispatcherTrait { + fn ensure_abi(self: Imodel_with_short_string_namespaceLibraryDispatcher, model: ModelWithShortStringNamespace) { + let mut __calldata__ = core::traits::Default::default(); + core::serde::Serde::::serialize(@model, ref __calldata__); + + let mut __dispatcher_return_data__ = starknet::syscalls::library_call_syscall( + self.class_hash, + selector!("ensure_abi"), + core::array::ArrayTrait::span(@__calldata__), + ); + let mut __dispatcher_return_data__ = starknet::SyscallResultTrait::unwrap_syscall(__dispatcher_return_data__); + () + } + +} + +pub trait Imodel_with_short_string_namespaceSafeDispatcherTrait { + #[unstable(feature: "safe_dispatcher")] + fn ensure_abi(self: T, model: ModelWithShortStringNamespace) -> starknet::SyscallResult<()>; +} + +#[derive(Copy, Drop, starknet::Store, Serde)] +pub struct Imodel_with_short_string_namespaceSafeLibraryDispatcher { + pub class_hash: starknet::ClassHash, +} + +impl Imodel_with_short_string_namespaceSafeLibraryDispatcherImpl of Imodel_with_short_string_namespaceSafeDispatcherTrait { + fn ensure_abi(self: Imodel_with_short_string_namespaceSafeLibraryDispatcher, model: ModelWithShortStringNamespace) -> starknet::SyscallResult<()> { + let mut __calldata__ = core::traits::Default::default(); + core::serde::Serde::::serialize(@model, ref __calldata__); + + let mut __dispatcher_return_data__ = starknet::syscalls::library_call_syscall( + self.class_hash, + selector!("ensure_abi"), + core::array::ArrayTrait::span(@__calldata__), + ); + let mut __dispatcher_return_data__ = __dispatcher_return_data__?; + Result::Ok(()) + } + +} + + +#[derive(Copy, Drop, starknet::Store, Serde)] +pub struct Imodel_with_short_string_namespaceSafeDispatcher { + pub contract_address: starknet::ContractAddress, +} + +impl Imodel_with_short_string_namespaceSafeDispatcherImpl of Imodel_with_short_string_namespaceSafeDispatcherTrait { + fn ensure_abi(self: Imodel_with_short_string_namespaceSafeDispatcher, model: ModelWithShortStringNamespace) -> starknet::SyscallResult<()> { + let mut __calldata__ = core::traits::Default::default(); + core::serde::Serde::::serialize(@model, ref __calldata__); + + let mut __dispatcher_return_data__ = starknet::syscalls::call_contract_syscall( + self.contract_address, + selector!("ensure_abi"), + core::array::ArrayTrait::span(@__calldata__), + ); + let mut __dispatcher_return_data__ = __dispatcher_return_data__?; + Result::Ok(()) + } + +} +impl ModelWithStringNamespaceEntityDrop of core::traits::Drop::; +impl ModelWithStringNamespaceEntitySerde of core::serde::Serde:: { + fn serialize(self: @ModelWithStringNamespaceEntity, ref output: core::array::Array) { + core::serde::Serde::serialize(self.__id, ref output); + core::serde::Serde::serialize(self.v, ref output) + } + fn deserialize(ref serialized: core::array::Span) -> core::option::Option { + core::option::Option::Some(ModelWithStringNamespaceEntity { + __id: core::serde::Serde::deserialize(ref serialized)?, + v: core::serde::Serde::deserialize(ref serialized)?, + }) + } +} +pub trait ModelWithStringNamespaceEntityStore { + fn get(world: dojo::world::IWorldDispatcher, entity_id: felt252) -> ModelWithStringNamespaceEntity; + + fn update(self: @ModelWithStringNamespaceEntity, world: dojo::world::IWorldDispatcher); + + fn delete(self: @ModelWithStringNamespaceEntity, world: dojo::world::IWorldDispatcher); + + + fn get_v(world: dojo::world::IWorldDispatcher, entity_id: felt252) -> Vec3; + + fn set_v(self: @ModelWithStringNamespaceEntity, world: dojo::world::IWorldDispatcher, value: Vec3); + +} +pub trait ModelWithStringNamespaceStore { + fn entity_id_from_keys(id: felt252) -> felt252; + + fn from_values(ref keys: Span, ref values: Span) -> ModelWithStringNamespace; + + fn get(world: dojo::world::IWorldDispatcher, id: felt252) -> ModelWithStringNamespace; + + fn set(self: @ModelWithStringNamespace, world: dojo::world::IWorldDispatcher); + + fn delete(self: @ModelWithStringNamespace, world: dojo::world::IWorldDispatcher); + + + fn get_v(world: dojo::world::IWorldDispatcher, id: felt252) -> Vec3; + + fn set_v(self: @ModelWithStringNamespace, world: dojo::world::IWorldDispatcher, value: Vec3); + +} +pub trait Imodel_with_string_namespaceDispatcherTrait { + fn ensure_abi(self: T, model: ModelWithStringNamespace); +} + +#[derive(Copy, Drop, starknet::Store, Serde)] +pub struct Imodel_with_string_namespaceDispatcher { + pub contract_address: starknet::ContractAddress, +} + +impl Imodel_with_string_namespaceDispatcherImpl of Imodel_with_string_namespaceDispatcherTrait { + fn ensure_abi(self: Imodel_with_string_namespaceDispatcher, model: ModelWithStringNamespace) { + let mut __calldata__ = core::traits::Default::default(); + core::serde::Serde::::serialize(@model, ref __calldata__); + + let mut __dispatcher_return_data__ = starknet::syscalls::call_contract_syscall( + self.contract_address, + selector!("ensure_abi"), + core::array::ArrayTrait::span(@__calldata__), + ); + let mut __dispatcher_return_data__ = starknet::SyscallResultTrait::unwrap_syscall(__dispatcher_return_data__); + () + } + +} + +#[derive(Copy, Drop, starknet::Store, Serde)] +pub struct Imodel_with_string_namespaceLibraryDispatcher { + pub class_hash: starknet::ClassHash, +} + +impl Imodel_with_string_namespaceLibraryDispatcherImpl of Imodel_with_string_namespaceDispatcherTrait { + fn ensure_abi(self: Imodel_with_string_namespaceLibraryDispatcher, model: ModelWithStringNamespace) { + let mut __calldata__ = core::traits::Default::default(); + core::serde::Serde::::serialize(@model, ref __calldata__); + + let mut __dispatcher_return_data__ = starknet::syscalls::library_call_syscall( + self.class_hash, + selector!("ensure_abi"), + core::array::ArrayTrait::span(@__calldata__), + ); + let mut __dispatcher_return_data__ = starknet::SyscallResultTrait::unwrap_syscall(__dispatcher_return_data__); + () + } + +} + +pub trait Imodel_with_string_namespaceSafeDispatcherTrait { + #[unstable(feature: "safe_dispatcher")] + fn ensure_abi(self: T, model: ModelWithStringNamespace) -> starknet::SyscallResult<()>; +} + +#[derive(Copy, Drop, starknet::Store, Serde)] +pub struct Imodel_with_string_namespaceSafeLibraryDispatcher { + pub class_hash: starknet::ClassHash, +} + +impl Imodel_with_string_namespaceSafeLibraryDispatcherImpl of Imodel_with_string_namespaceSafeDispatcherTrait { + fn ensure_abi(self: Imodel_with_string_namespaceSafeLibraryDispatcher, model: ModelWithStringNamespace) -> starknet::SyscallResult<()> { + let mut __calldata__ = core::traits::Default::default(); + core::serde::Serde::::serialize(@model, ref __calldata__); + + let mut __dispatcher_return_data__ = starknet::syscalls::library_call_syscall( + self.class_hash, + selector!("ensure_abi"), + core::array::ArrayTrait::span(@__calldata__), + ); + let mut __dispatcher_return_data__ = __dispatcher_return_data__?; + Result::Ok(()) + } + +} + + +#[derive(Copy, Drop, starknet::Store, Serde)] +pub struct Imodel_with_string_namespaceSafeDispatcher { + pub contract_address: starknet::ContractAddress, +} + +impl Imodel_with_string_namespaceSafeDispatcherImpl of Imodel_with_string_namespaceSafeDispatcherTrait { + fn ensure_abi(self: Imodel_with_string_namespaceSafeDispatcher, model: ModelWithStringNamespace) -> starknet::SyscallResult<()> { + let mut __calldata__ = core::traits::Default::default(); + core::serde::Serde::::serialize(@model, ref __calldata__); + + let mut __dispatcher_return_data__ = starknet::syscalls::call_contract_syscall( + self.contract_address, + selector!("ensure_abi"), + core::array::ArrayTrait::span(@__calldata__), + ); + let mut __dispatcher_return_data__ = __dispatcher_return_data__?; + Result::Ok(()) + } + +} +impl PositionEntityDrop of core::traits::Drop::; +impl PositionEntitySerde of core::serde::Serde:: { + fn serialize(self: @PositionEntity, ref output: core::array::Array) { + core::serde::Serde::serialize(self.__id, ref output); + core::serde::Serde::serialize(self.v, ref output) + } + fn deserialize(ref serialized: core::array::Span) -> core::option::Option { + core::option::Option::Some(PositionEntity { + __id: core::serde::Serde::deserialize(ref serialized)?, + v: core::serde::Serde::deserialize(ref serialized)?, + }) + } +} +pub trait PositionEntityStore { + fn get(world: dojo::world::IWorldDispatcher, entity_id: felt252) -> PositionEntity; + + fn update(self: @PositionEntity, world: dojo::world::IWorldDispatcher); + + fn delete(self: @PositionEntity, world: dojo::world::IWorldDispatcher); + + + fn get_v(world: dojo::world::IWorldDispatcher, entity_id: felt252) -> Vec3; + + fn set_v(self: @PositionEntity, world: dojo::world::IWorldDispatcher, value: Vec3); + +} +pub trait PositionStore { + fn entity_id_from_keys(id: felt252) -> felt252; + + fn from_values(ref keys: Span, ref values: Span) -> Position; + + fn get(world: dojo::world::IWorldDispatcher, id: felt252) -> Position; + + fn set(self: @Position, world: dojo::world::IWorldDispatcher); + + fn delete(self: @Position, world: dojo::world::IWorldDispatcher); + + + fn get_v(world: dojo::world::IWorldDispatcher, id: felt252) -> Vec3; + + fn set_v(self: @Position, world: dojo::world::IWorldDispatcher, value: Vec3); + +} +pub trait IpositionDispatcherTrait { + fn ensure_abi(self: T, model: Position); +} + +#[derive(Copy, Drop, starknet::Store, Serde)] +pub struct IpositionDispatcher { + pub contract_address: starknet::ContractAddress, +} + +impl IpositionDispatcherImpl of IpositionDispatcherTrait { + fn ensure_abi(self: IpositionDispatcher, model: Position) { + let mut __calldata__ = core::traits::Default::default(); + core::serde::Serde::::serialize(@model, ref __calldata__); + + let mut __dispatcher_return_data__ = starknet::syscalls::call_contract_syscall( + self.contract_address, + selector!("ensure_abi"), + core::array::ArrayTrait::span(@__calldata__), + ); + let mut __dispatcher_return_data__ = starknet::SyscallResultTrait::unwrap_syscall(__dispatcher_return_data__); + () + } + +} + +#[derive(Copy, Drop, starknet::Store, Serde)] +pub struct IpositionLibraryDispatcher { + pub class_hash: starknet::ClassHash, +} + +impl IpositionLibraryDispatcherImpl of IpositionDispatcherTrait { + fn ensure_abi(self: IpositionLibraryDispatcher, model: Position) { + let mut __calldata__ = core::traits::Default::default(); + core::serde::Serde::::serialize(@model, ref __calldata__); + + let mut __dispatcher_return_data__ = starknet::syscalls::library_call_syscall( + self.class_hash, + selector!("ensure_abi"), + core::array::ArrayTrait::span(@__calldata__), + ); + let mut __dispatcher_return_data__ = starknet::SyscallResultTrait::unwrap_syscall(__dispatcher_return_data__); + () + } + +} + +pub trait IpositionSafeDispatcherTrait { + #[unstable(feature: "safe_dispatcher")] + fn ensure_abi(self: T, model: Position) -> starknet::SyscallResult<()>; +} + +#[derive(Copy, Drop, starknet::Store, Serde)] +pub struct IpositionSafeLibraryDispatcher { + pub class_hash: starknet::ClassHash, +} + +impl IpositionSafeLibraryDispatcherImpl of IpositionSafeDispatcherTrait { + fn ensure_abi(self: IpositionSafeLibraryDispatcher, model: Position) -> starknet::SyscallResult<()> { + let mut __calldata__ = core::traits::Default::default(); + core::serde::Serde::::serialize(@model, ref __calldata__); + + let mut __dispatcher_return_data__ = starknet::syscalls::library_call_syscall( + self.class_hash, + selector!("ensure_abi"), + core::array::ArrayTrait::span(@__calldata__), + ); + let mut __dispatcher_return_data__ = __dispatcher_return_data__?; + Result::Ok(()) + } + +} + + +#[derive(Copy, Drop, starknet::Store, Serde)] +pub struct IpositionSafeDispatcher { + pub contract_address: starknet::ContractAddress, +} + +impl IpositionSafeDispatcherImpl of IpositionSafeDispatcherTrait { + fn ensure_abi(self: IpositionSafeDispatcher, model: Position) -> starknet::SyscallResult<()> { + let mut __calldata__ = core::traits::Default::default(); + core::serde::Serde::::serialize(@model, ref __calldata__); + + let mut __dispatcher_return_data__ = starknet::syscalls::call_contract_syscall( + self.contract_address, + selector!("ensure_abi"), + core::array::ArrayTrait::span(@__calldata__), + ); + let mut __dispatcher_return_data__ = __dispatcher_return_data__?; + Result::Ok(()) + } + +} +impl RolesEntityDrop of core::traits::Drop::; +impl RolesEntitySerde of core::serde::Serde:: { + fn serialize(self: @RolesEntity, ref output: core::array::Array) { + core::serde::Serde::serialize(self.__id, ref output); + core::serde::Serde::serialize(self.role_ids, ref output) + } + fn deserialize(ref serialized: core::array::Span) -> core::option::Option { + core::option::Option::Some(RolesEntity { + __id: core::serde::Serde::deserialize(ref serialized)?, + role_ids: core::serde::Serde::deserialize(ref serialized)?, + }) + } +} +pub trait RolesEntityStore { + fn get(world: dojo::world::IWorldDispatcher, entity_id: felt252) -> RolesEntity; + + fn update(self: @RolesEntity, world: dojo::world::IWorldDispatcher); + + fn delete(self: @RolesEntity, world: dojo::world::IWorldDispatcher); + + + fn get_role_ids(world: dojo::world::IWorldDispatcher, entity_id: felt252) -> Array; + + fn set_role_ids(self: @RolesEntity, world: dojo::world::IWorldDispatcher, value: Array); + +} +pub trait RolesStore { + fn entity_id_from_keys() -> felt252; + + fn from_values(ref keys: Span, ref values: Span) -> Roles; + + fn get(world: dojo::world::IWorldDispatcher, ) -> Roles; + + fn set(self: @Roles, world: dojo::world::IWorldDispatcher); + + fn delete(self: @Roles, world: dojo::world::IWorldDispatcher); + + + fn get_role_ids(world: dojo::world::IWorldDispatcher, ) -> Array; + + fn set_role_ids(self: @Roles, world: dojo::world::IWorldDispatcher, value: Array); + +} +pub trait IrolesDispatcherTrait { + fn ensure_abi(self: T, model: Roles); +} + +#[derive(Copy, Drop, starknet::Store, Serde)] +pub struct IrolesDispatcher { + pub contract_address: starknet::ContractAddress, +} + +impl IrolesDispatcherImpl of IrolesDispatcherTrait { + fn ensure_abi(self: IrolesDispatcher, model: Roles) { + let mut __calldata__ = core::traits::Default::default(); + core::serde::Serde::::serialize(@model, ref __calldata__); + + let mut __dispatcher_return_data__ = starknet::syscalls::call_contract_syscall( + self.contract_address, + selector!("ensure_abi"), + core::array::ArrayTrait::span(@__calldata__), + ); + let mut __dispatcher_return_data__ = starknet::SyscallResultTrait::unwrap_syscall(__dispatcher_return_data__); + () + } + +} + +#[derive(Copy, Drop, starknet::Store, Serde)] +pub struct IrolesLibraryDispatcher { + pub class_hash: starknet::ClassHash, +} + +impl IrolesLibraryDispatcherImpl of IrolesDispatcherTrait { + fn ensure_abi(self: IrolesLibraryDispatcher, model: Roles) { + let mut __calldata__ = core::traits::Default::default(); + core::serde::Serde::::serialize(@model, ref __calldata__); + + let mut __dispatcher_return_data__ = starknet::syscalls::library_call_syscall( + self.class_hash, + selector!("ensure_abi"), + core::array::ArrayTrait::span(@__calldata__), + ); + let mut __dispatcher_return_data__ = starknet::SyscallResultTrait::unwrap_syscall(__dispatcher_return_data__); + () + } + +} + +pub trait IrolesSafeDispatcherTrait { + #[unstable(feature: "safe_dispatcher")] + fn ensure_abi(self: T, model: Roles) -> starknet::SyscallResult<()>; +} + +#[derive(Copy, Drop, starknet::Store, Serde)] +pub struct IrolesSafeLibraryDispatcher { + pub class_hash: starknet::ClassHash, +} + +impl IrolesSafeLibraryDispatcherImpl of IrolesSafeDispatcherTrait { + fn ensure_abi(self: IrolesSafeLibraryDispatcher, model: Roles) -> starknet::SyscallResult<()> { + let mut __calldata__ = core::traits::Default::default(); + core::serde::Serde::::serialize(@model, ref __calldata__); + + let mut __dispatcher_return_data__ = starknet::syscalls::library_call_syscall( + self.class_hash, + selector!("ensure_abi"), + core::array::ArrayTrait::span(@__calldata__), + ); + let mut __dispatcher_return_data__ = __dispatcher_return_data__?; + Result::Ok(()) + } + +} + + +#[derive(Copy, Drop, starknet::Store, Serde)] +pub struct IrolesSafeDispatcher { + pub contract_address: starknet::ContractAddress, +} + +impl IrolesSafeDispatcherImpl of IrolesSafeDispatcherTrait { + fn ensure_abi(self: IrolesSafeDispatcher, model: Roles) -> starknet::SyscallResult<()> { + let mut __calldata__ = core::traits::Default::default(); + core::serde::Serde::::serialize(@model, ref __calldata__); + + let mut __dispatcher_return_data__ = starknet::syscalls::call_contract_syscall( + self.contract_address, + selector!("ensure_abi"), + core::array::ArrayTrait::span(@__calldata__), + ); + let mut __dispatcher_return_data__ = __dispatcher_return_data__?; + Result::Ok(()) + } + +} +impl OnlyKeyModelEntityDrop of core::traits::Drop::; +impl OnlyKeyModelEntitySerde of core::serde::Serde:: { + fn serialize(self: @OnlyKeyModelEntity, ref output: core::array::Array) { + core::serde::Serde::serialize(self.__id, ref output) + } + fn deserialize(ref serialized: core::array::Span) -> core::option::Option { + core::option::Option::Some(OnlyKeyModelEntity { + __id: core::serde::Serde::deserialize(ref serialized)?, + }) + } +} +pub trait OnlyKeyModelEntityStore { + fn get(world: dojo::world::IWorldDispatcher, entity_id: felt252) -> OnlyKeyModelEntity; + + fn update(self: @OnlyKeyModelEntity, world: dojo::world::IWorldDispatcher); + + fn delete(self: @OnlyKeyModelEntity, world: dojo::world::IWorldDispatcher); + + +} +pub trait OnlyKeyModelStore { + fn entity_id_from_keys(id: felt252) -> felt252; + + fn from_values(ref keys: Span, ref values: Span) -> OnlyKeyModel; + + fn get(world: dojo::world::IWorldDispatcher, id: felt252) -> OnlyKeyModel; + + fn set(self: @OnlyKeyModel, world: dojo::world::IWorldDispatcher); + + fn delete(self: @OnlyKeyModel, world: dojo::world::IWorldDispatcher); + + +} +pub trait Ionly_key_modelDispatcherTrait { + fn ensure_abi(self: T, model: OnlyKeyModel); +} + +#[derive(Copy, Drop, starknet::Store, Serde)] +pub struct Ionly_key_modelDispatcher { + pub contract_address: starknet::ContractAddress, +} + +impl Ionly_key_modelDispatcherImpl of Ionly_key_modelDispatcherTrait { + fn ensure_abi(self: Ionly_key_modelDispatcher, model: OnlyKeyModel) { + let mut __calldata__ = core::traits::Default::default(); + core::serde::Serde::::serialize(@model, ref __calldata__); + + let mut __dispatcher_return_data__ = starknet::syscalls::call_contract_syscall( + self.contract_address, + selector!("ensure_abi"), + core::array::ArrayTrait::span(@__calldata__), + ); + let mut __dispatcher_return_data__ = starknet::SyscallResultTrait::unwrap_syscall(__dispatcher_return_data__); + () + } + +} + +#[derive(Copy, Drop, starknet::Store, Serde)] +pub struct Ionly_key_modelLibraryDispatcher { + pub class_hash: starknet::ClassHash, +} + +impl Ionly_key_modelLibraryDispatcherImpl of Ionly_key_modelDispatcherTrait { + fn ensure_abi(self: Ionly_key_modelLibraryDispatcher, model: OnlyKeyModel) { + let mut __calldata__ = core::traits::Default::default(); + core::serde::Serde::::serialize(@model, ref __calldata__); + + let mut __dispatcher_return_data__ = starknet::syscalls::library_call_syscall( + self.class_hash, + selector!("ensure_abi"), + core::array::ArrayTrait::span(@__calldata__), + ); + let mut __dispatcher_return_data__ = starknet::SyscallResultTrait::unwrap_syscall(__dispatcher_return_data__); + () + } + +} + +pub trait Ionly_key_modelSafeDispatcherTrait { + #[unstable(feature: "safe_dispatcher")] + fn ensure_abi(self: T, model: OnlyKeyModel) -> starknet::SyscallResult<()>; +} + +#[derive(Copy, Drop, starknet::Store, Serde)] +pub struct Ionly_key_modelSafeLibraryDispatcher { + pub class_hash: starknet::ClassHash, +} + +impl Ionly_key_modelSafeLibraryDispatcherImpl of Ionly_key_modelSafeDispatcherTrait { + fn ensure_abi(self: Ionly_key_modelSafeLibraryDispatcher, model: OnlyKeyModel) -> starknet::SyscallResult<()> { + let mut __calldata__ = core::traits::Default::default(); + core::serde::Serde::::serialize(@model, ref __calldata__); + + let mut __dispatcher_return_data__ = starknet::syscalls::library_call_syscall( + self.class_hash, + selector!("ensure_abi"), + core::array::ArrayTrait::span(@__calldata__), + ); + let mut __dispatcher_return_data__ = __dispatcher_return_data__?; + Result::Ok(()) + } + +} + + +#[derive(Copy, Drop, starknet::Store, Serde)] +pub struct Ionly_key_modelSafeDispatcher { + pub contract_address: starknet::ContractAddress, +} + +impl Ionly_key_modelSafeDispatcherImpl of Ionly_key_modelSafeDispatcherTrait { + fn ensure_abi(self: Ionly_key_modelSafeDispatcher, model: OnlyKeyModel) -> starknet::SyscallResult<()> { + let mut __calldata__ = core::traits::Default::default(); + core::serde::Serde::::serialize(@model, ref __calldata__); + + let mut __dispatcher_return_data__ = starknet::syscalls::call_contract_syscall( + self.contract_address, + selector!("ensure_abi"), + core::array::ArrayTrait::span(@__calldata__), + ); + let mut __dispatcher_return_data__ = __dispatcher_return_data__?; + Result::Ok(()) + } + +} +impl U256KeyModelEntityDrop of core::traits::Drop::; +impl U256KeyModelEntitySerde of core::serde::Serde:: { + fn serialize(self: @U256KeyModelEntity, ref output: core::array::Array) { + core::serde::Serde::serialize(self.__id, ref output) + } + fn deserialize(ref serialized: core::array::Span) -> core::option::Option { + core::option::Option::Some(U256KeyModelEntity { + __id: core::serde::Serde::deserialize(ref serialized)?, + }) + } +} +pub trait U256KeyModelEntityStore { + fn get(world: dojo::world::IWorldDispatcher, entity_id: felt252) -> U256KeyModelEntity; + + fn update(self: @U256KeyModelEntity, world: dojo::world::IWorldDispatcher); + + fn delete(self: @U256KeyModelEntity, world: dojo::world::IWorldDispatcher); + + +} +pub trait U256KeyModelStore { + fn entity_id_from_keys(id: u256) -> felt252; + + fn from_values(ref keys: Span, ref values: Span) -> U256KeyModel; + + fn get(world: dojo::world::IWorldDispatcher, id: u256) -> U256KeyModel; + + fn set(self: @U256KeyModel, world: dojo::world::IWorldDispatcher); + + fn delete(self: @U256KeyModel, world: dojo::world::IWorldDispatcher); + + +} +pub trait Iu_256_key_modelDispatcherTrait { + fn ensure_abi(self: T, model: U256KeyModel); +} + +#[derive(Copy, Drop, starknet::Store, Serde)] +pub struct Iu_256_key_modelDispatcher { + pub contract_address: starknet::ContractAddress, +} + +impl Iu_256_key_modelDispatcherImpl of Iu_256_key_modelDispatcherTrait { + fn ensure_abi(self: Iu_256_key_modelDispatcher, model: U256KeyModel) { + let mut __calldata__ = core::traits::Default::default(); + core::serde::Serde::::serialize(@model, ref __calldata__); + + let mut __dispatcher_return_data__ = starknet::syscalls::call_contract_syscall( + self.contract_address, + selector!("ensure_abi"), + core::array::ArrayTrait::span(@__calldata__), + ); + let mut __dispatcher_return_data__ = starknet::SyscallResultTrait::unwrap_syscall(__dispatcher_return_data__); + () + } + +} + +#[derive(Copy, Drop, starknet::Store, Serde)] +pub struct Iu_256_key_modelLibraryDispatcher { + pub class_hash: starknet::ClassHash, +} + +impl Iu_256_key_modelLibraryDispatcherImpl of Iu_256_key_modelDispatcherTrait { + fn ensure_abi(self: Iu_256_key_modelLibraryDispatcher, model: U256KeyModel) { + let mut __calldata__ = core::traits::Default::default(); + core::serde::Serde::::serialize(@model, ref __calldata__); + + let mut __dispatcher_return_data__ = starknet::syscalls::library_call_syscall( + self.class_hash, + selector!("ensure_abi"), + core::array::ArrayTrait::span(@__calldata__), + ); + let mut __dispatcher_return_data__ = starknet::SyscallResultTrait::unwrap_syscall(__dispatcher_return_data__); + () + } + +} + +pub trait Iu_256_key_modelSafeDispatcherTrait { + #[unstable(feature: "safe_dispatcher")] + fn ensure_abi(self: T, model: U256KeyModel) -> starknet::SyscallResult<()>; +} + +#[derive(Copy, Drop, starknet::Store, Serde)] +pub struct Iu_256_key_modelSafeLibraryDispatcher { + pub class_hash: starknet::ClassHash, +} + +impl Iu_256_key_modelSafeLibraryDispatcherImpl of Iu_256_key_modelSafeDispatcherTrait { + fn ensure_abi(self: Iu_256_key_modelSafeLibraryDispatcher, model: U256KeyModel) -> starknet::SyscallResult<()> { + let mut __calldata__ = core::traits::Default::default(); + core::serde::Serde::::serialize(@model, ref __calldata__); + + let mut __dispatcher_return_data__ = starknet::syscalls::library_call_syscall( + self.class_hash, + selector!("ensure_abi"), + core::array::ArrayTrait::span(@__calldata__), + ); + let mut __dispatcher_return_data__ = __dispatcher_return_data__?; + Result::Ok(()) + } + +} + + +#[derive(Copy, Drop, starknet::Store, Serde)] +pub struct Iu_256_key_modelSafeDispatcher { + pub contract_address: starknet::ContractAddress, +} + +impl Iu_256_key_modelSafeDispatcherImpl of Iu_256_key_modelSafeDispatcherTrait { + fn ensure_abi(self: Iu_256_key_modelSafeDispatcher, model: U256KeyModel) -> starknet::SyscallResult<()> { + let mut __calldata__ = core::traits::Default::default(); + core::serde::Serde::::serialize(@model, ref __calldata__); + + let mut __dispatcher_return_data__ = starknet::syscalls::call_contract_syscall( + self.contract_address, + selector!("ensure_abi"), + core::array::ArrayTrait::span(@__calldata__), + ); + let mut __dispatcher_return_data__ = __dispatcher_return_data__?; + Result::Ok(()) + } + +} +impl PlayerEntityDrop of core::traits::Drop::; +impl PlayerEntitySerde of core::serde::Serde:: { + fn serialize(self: @PlayerEntity, ref output: core::array::Array) { + core::serde::Serde::serialize(self.__id, ref output); + core::serde::Serde::serialize(self.name, ref output) + } + fn deserialize(ref serialized: core::array::Span) -> core::option::Option { + core::option::Option::Some(PlayerEntity { + __id: core::serde::Serde::deserialize(ref serialized)?, + name: core::serde::Serde::deserialize(ref serialized)?, + }) + } +} +pub trait PlayerEntityStore { + fn get(world: dojo::world::IWorldDispatcher, entity_id: felt252) -> PlayerEntity; + + fn update(self: @PlayerEntity, world: dojo::world::IWorldDispatcher); + + fn delete(self: @PlayerEntity, world: dojo::world::IWorldDispatcher); + + + fn get_name(world: dojo::world::IWorldDispatcher, entity_id: felt252) -> felt252; + + fn set_name(self: @PlayerEntity, world: dojo::world::IWorldDispatcher, value: felt252); + +} +pub trait PlayerStore { + fn entity_id_from_keys(game: felt252, player: ContractAddress) -> felt252; + + fn from_values(ref keys: Span, ref values: Span) -> Player; + + fn get(world: dojo::world::IWorldDispatcher, game: felt252, player: ContractAddress) -> Player; + + fn set(self: @Player, world: dojo::world::IWorldDispatcher); + + fn delete(self: @Player, world: dojo::world::IWorldDispatcher); + + + fn get_name(world: dojo::world::IWorldDispatcher, game: felt252, player: ContractAddress) -> felt252; + + fn set_name(self: @Player, world: dojo::world::IWorldDispatcher, value: felt252); + +} +pub trait IplayerDispatcherTrait { + fn ensure_abi(self: T, model: Player); +} + +#[derive(Copy, Drop, starknet::Store, Serde)] +pub struct IplayerDispatcher { + pub contract_address: starknet::ContractAddress, +} + +impl IplayerDispatcherImpl of IplayerDispatcherTrait { + fn ensure_abi(self: IplayerDispatcher, model: Player) { + let mut __calldata__ = core::traits::Default::default(); + core::serde::Serde::::serialize(@model, ref __calldata__); + + let mut __dispatcher_return_data__ = starknet::syscalls::call_contract_syscall( + self.contract_address, + selector!("ensure_abi"), + core::array::ArrayTrait::span(@__calldata__), + ); + let mut __dispatcher_return_data__ = starknet::SyscallResultTrait::unwrap_syscall(__dispatcher_return_data__); + () + } + +} + +#[derive(Copy, Drop, starknet::Store, Serde)] +pub struct IplayerLibraryDispatcher { + pub class_hash: starknet::ClassHash, +} + +impl IplayerLibraryDispatcherImpl of IplayerDispatcherTrait { + fn ensure_abi(self: IplayerLibraryDispatcher, model: Player) { + let mut __calldata__ = core::traits::Default::default(); + core::serde::Serde::::serialize(@model, ref __calldata__); + + let mut __dispatcher_return_data__ = starknet::syscalls::library_call_syscall( + self.class_hash, + selector!("ensure_abi"), + core::array::ArrayTrait::span(@__calldata__), + ); + let mut __dispatcher_return_data__ = starknet::SyscallResultTrait::unwrap_syscall(__dispatcher_return_data__); + () + } + +} + +pub trait IplayerSafeDispatcherTrait { + #[unstable(feature: "safe_dispatcher")] + fn ensure_abi(self: T, model: Player) -> starknet::SyscallResult<()>; +} + +#[derive(Copy, Drop, starknet::Store, Serde)] +pub struct IplayerSafeLibraryDispatcher { + pub class_hash: starknet::ClassHash, +} + +impl IplayerSafeLibraryDispatcherImpl of IplayerSafeDispatcherTrait { + fn ensure_abi(self: IplayerSafeLibraryDispatcher, model: Player) -> starknet::SyscallResult<()> { + let mut __calldata__ = core::traits::Default::default(); + core::serde::Serde::::serialize(@model, ref __calldata__); + + let mut __dispatcher_return_data__ = starknet::syscalls::library_call_syscall( + self.class_hash, + selector!("ensure_abi"), + core::array::ArrayTrait::span(@__calldata__), + ); + let mut __dispatcher_return_data__ = __dispatcher_return_data__?; + Result::Ok(()) + } + +} + + +#[derive(Copy, Drop, starknet::Store, Serde)] +pub struct IplayerSafeDispatcher { + pub contract_address: starknet::ContractAddress, +} + +impl IplayerSafeDispatcherImpl of IplayerSafeDispatcherTrait { + fn ensure_abi(self: IplayerSafeDispatcher, model: Player) -> starknet::SyscallResult<()> { + let mut __calldata__ = core::traits::Default::default(); + core::serde::Serde::::serialize(@model, ref __calldata__); + + let mut __dispatcher_return_data__ = starknet::syscalls::call_contract_syscall( + self.contract_address, + selector!("ensure_abi"), + core::array::ArrayTrait::span(@__calldata__), + ); + let mut __dispatcher_return_data__ = __dispatcher_return_data__?; + Result::Ok(()) + } + +} +impl ModelWithSimpleArrayEntityDrop of core::traits::Drop::; +impl ModelWithSimpleArrayEntitySerde of core::serde::Serde:: { + fn serialize(self: @ModelWithSimpleArrayEntity, ref output: core::array::Array) { + core::serde::Serde::serialize(self.__id, ref output); + core::serde::Serde::serialize(self.x, ref output); + core::serde::Serde::serialize(self.y, ref output) + } + fn deserialize(ref serialized: core::array::Span) -> core::option::Option { + core::option::Option::Some(ModelWithSimpleArrayEntity { + __id: core::serde::Serde::deserialize(ref serialized)?, + x: core::serde::Serde::deserialize(ref serialized)?, + y: core::serde::Serde::deserialize(ref serialized)?, + }) + } +} +pub trait ModelWithSimpleArrayEntityStore { + fn get(world: dojo::world::IWorldDispatcher, entity_id: felt252) -> ModelWithSimpleArrayEntity; + + fn update(self: @ModelWithSimpleArrayEntity, world: dojo::world::IWorldDispatcher); + + fn delete(self: @ModelWithSimpleArrayEntity, world: dojo::world::IWorldDispatcher); + + + fn get_x(world: dojo::world::IWorldDispatcher, entity_id: felt252) -> u16; + + fn set_x(self: @ModelWithSimpleArrayEntity, world: dojo::world::IWorldDispatcher, value: u16); + + fn get_y(world: dojo::world::IWorldDispatcher, entity_id: felt252) -> Array; + + fn set_y(self: @ModelWithSimpleArrayEntity, world: dojo::world::IWorldDispatcher, value: Array); + +} +pub trait ModelWithSimpleArrayStore { + fn entity_id_from_keys(player: ContractAddress) -> felt252; + + fn from_values(ref keys: Span, ref values: Span) -> ModelWithSimpleArray; + + fn get(world: dojo::world::IWorldDispatcher, player: ContractAddress) -> ModelWithSimpleArray; + + fn set(self: @ModelWithSimpleArray, world: dojo::world::IWorldDispatcher); + + fn delete(self: @ModelWithSimpleArray, world: dojo::world::IWorldDispatcher); + + + fn get_x(world: dojo::world::IWorldDispatcher, player: ContractAddress) -> u16; + + fn set_x(self: @ModelWithSimpleArray, world: dojo::world::IWorldDispatcher, value: u16); + + fn get_y(world: dojo::world::IWorldDispatcher, player: ContractAddress) -> Array; + + fn set_y(self: @ModelWithSimpleArray, world: dojo::world::IWorldDispatcher, value: Array); + +} +pub trait Imodel_with_simple_arrayDispatcherTrait { + fn ensure_abi(self: T, model: ModelWithSimpleArray); +} + +#[derive(Copy, Drop, starknet::Store, Serde)] +pub struct Imodel_with_simple_arrayDispatcher { + pub contract_address: starknet::ContractAddress, +} + +impl Imodel_with_simple_arrayDispatcherImpl of Imodel_with_simple_arrayDispatcherTrait { + fn ensure_abi(self: Imodel_with_simple_arrayDispatcher, model: ModelWithSimpleArray) { + let mut __calldata__ = core::traits::Default::default(); + core::serde::Serde::::serialize(@model, ref __calldata__); + + let mut __dispatcher_return_data__ = starknet::syscalls::call_contract_syscall( + self.contract_address, + selector!("ensure_abi"), + core::array::ArrayTrait::span(@__calldata__), + ); + let mut __dispatcher_return_data__ = starknet::SyscallResultTrait::unwrap_syscall(__dispatcher_return_data__); + () + } + +} + +#[derive(Copy, Drop, starknet::Store, Serde)] +pub struct Imodel_with_simple_arrayLibraryDispatcher { + pub class_hash: starknet::ClassHash, +} + +impl Imodel_with_simple_arrayLibraryDispatcherImpl of Imodel_with_simple_arrayDispatcherTrait { + fn ensure_abi(self: Imodel_with_simple_arrayLibraryDispatcher, model: ModelWithSimpleArray) { + let mut __calldata__ = core::traits::Default::default(); + core::serde::Serde::::serialize(@model, ref __calldata__); + + let mut __dispatcher_return_data__ = starknet::syscalls::library_call_syscall( + self.class_hash, + selector!("ensure_abi"), + core::array::ArrayTrait::span(@__calldata__), + ); + let mut __dispatcher_return_data__ = starknet::SyscallResultTrait::unwrap_syscall(__dispatcher_return_data__); + () + } + +} + +pub trait Imodel_with_simple_arraySafeDispatcherTrait { + #[unstable(feature: "safe_dispatcher")] + fn ensure_abi(self: T, model: ModelWithSimpleArray) -> starknet::SyscallResult<()>; +} + +#[derive(Copy, Drop, starknet::Store, Serde)] +pub struct Imodel_with_simple_arraySafeLibraryDispatcher { + pub class_hash: starknet::ClassHash, +} + +impl Imodel_with_simple_arraySafeLibraryDispatcherImpl of Imodel_with_simple_arraySafeDispatcherTrait { + fn ensure_abi(self: Imodel_with_simple_arraySafeLibraryDispatcher, model: ModelWithSimpleArray) -> starknet::SyscallResult<()> { + let mut __calldata__ = core::traits::Default::default(); + core::serde::Serde::::serialize(@model, ref __calldata__); + + let mut __dispatcher_return_data__ = starknet::syscalls::library_call_syscall( + self.class_hash, + selector!("ensure_abi"), + core::array::ArrayTrait::span(@__calldata__), + ); + let mut __dispatcher_return_data__ = __dispatcher_return_data__?; + Result::Ok(()) + } + +} + + +#[derive(Copy, Drop, starknet::Store, Serde)] +pub struct Imodel_with_simple_arraySafeDispatcher { + pub contract_address: starknet::ContractAddress, +} + +impl Imodel_with_simple_arraySafeDispatcherImpl of Imodel_with_simple_arraySafeDispatcherTrait { + fn ensure_abi(self: Imodel_with_simple_arraySafeDispatcher, model: ModelWithSimpleArray) -> starknet::SyscallResult<()> { + let mut __calldata__ = core::traits::Default::default(); + core::serde::Serde::::serialize(@model, ref __calldata__); + + let mut __dispatcher_return_data__ = starknet::syscalls::call_contract_syscall( + self.contract_address, + selector!("ensure_abi"), + core::array::ArrayTrait::span(@__calldata__), + ); + let mut __dispatcher_return_data__ = __dispatcher_return_data__?; + Result::Ok(()) + } + +} +impl ModelWithByteArrayEntityDrop of core::traits::Drop::; +impl ModelWithByteArrayEntitySerde of core::serde::Serde:: { + fn serialize(self: @ModelWithByteArrayEntity, ref output: core::array::Array) { + core::serde::Serde::serialize(self.__id, ref output); + core::serde::Serde::serialize(self.x, ref output); + core::serde::Serde::serialize(self.y, ref output) + } + fn deserialize(ref serialized: core::array::Span) -> core::option::Option { + core::option::Option::Some(ModelWithByteArrayEntity { + __id: core::serde::Serde::deserialize(ref serialized)?, + x: core::serde::Serde::deserialize(ref serialized)?, + y: core::serde::Serde::deserialize(ref serialized)?, + }) + } +} +pub trait ModelWithByteArrayEntityStore { + fn get(world: dojo::world::IWorldDispatcher, entity_id: felt252) -> ModelWithByteArrayEntity; + + fn update(self: @ModelWithByteArrayEntity, world: dojo::world::IWorldDispatcher); + + fn delete(self: @ModelWithByteArrayEntity, world: dojo::world::IWorldDispatcher); + + + fn get_x(world: dojo::world::IWorldDispatcher, entity_id: felt252) -> u16; + + fn set_x(self: @ModelWithByteArrayEntity, world: dojo::world::IWorldDispatcher, value: u16); + + fn get_y(world: dojo::world::IWorldDispatcher, entity_id: felt252) -> ByteArray; + + fn set_y(self: @ModelWithByteArrayEntity, world: dojo::world::IWorldDispatcher, value: ByteArray); + +} +pub trait ModelWithByteArrayStore { + fn entity_id_from_keys(player: ContractAddress) -> felt252; + + fn from_values(ref keys: Span, ref values: Span) -> ModelWithByteArray; + + fn get(world: dojo::world::IWorldDispatcher, player: ContractAddress) -> ModelWithByteArray; + + fn set(self: @ModelWithByteArray, world: dojo::world::IWorldDispatcher); + + fn delete(self: @ModelWithByteArray, world: dojo::world::IWorldDispatcher); + + + fn get_x(world: dojo::world::IWorldDispatcher, player: ContractAddress) -> u16; + + fn set_x(self: @ModelWithByteArray, world: dojo::world::IWorldDispatcher, value: u16); + + fn get_y(world: dojo::world::IWorldDispatcher, player: ContractAddress) -> ByteArray; + + fn set_y(self: @ModelWithByteArray, world: dojo::world::IWorldDispatcher, value: ByteArray); + +} +pub trait Imodel_with_byte_arrayDispatcherTrait { + fn ensure_abi(self: T, model: ModelWithByteArray); +} + +#[derive(Copy, Drop, starknet::Store, Serde)] +pub struct Imodel_with_byte_arrayDispatcher { + pub contract_address: starknet::ContractAddress, +} + +impl Imodel_with_byte_arrayDispatcherImpl of Imodel_with_byte_arrayDispatcherTrait { + fn ensure_abi(self: Imodel_with_byte_arrayDispatcher, model: ModelWithByteArray) { + let mut __calldata__ = core::traits::Default::default(); + core::serde::Serde::::serialize(@model, ref __calldata__); + + let mut __dispatcher_return_data__ = starknet::syscalls::call_contract_syscall( + self.contract_address, + selector!("ensure_abi"), + core::array::ArrayTrait::span(@__calldata__), + ); + let mut __dispatcher_return_data__ = starknet::SyscallResultTrait::unwrap_syscall(__dispatcher_return_data__); + () + } + +} + +#[derive(Copy, Drop, starknet::Store, Serde)] +pub struct Imodel_with_byte_arrayLibraryDispatcher { + pub class_hash: starknet::ClassHash, +} + +impl Imodel_with_byte_arrayLibraryDispatcherImpl of Imodel_with_byte_arrayDispatcherTrait { + fn ensure_abi(self: Imodel_with_byte_arrayLibraryDispatcher, model: ModelWithByteArray) { + let mut __calldata__ = core::traits::Default::default(); + core::serde::Serde::::serialize(@model, ref __calldata__); + + let mut __dispatcher_return_data__ = starknet::syscalls::library_call_syscall( + self.class_hash, + selector!("ensure_abi"), + core::array::ArrayTrait::span(@__calldata__), + ); + let mut __dispatcher_return_data__ = starknet::SyscallResultTrait::unwrap_syscall(__dispatcher_return_data__); + () + } + +} + +pub trait Imodel_with_byte_arraySafeDispatcherTrait { + #[unstable(feature: "safe_dispatcher")] + fn ensure_abi(self: T, model: ModelWithByteArray) -> starknet::SyscallResult<()>; +} + +#[derive(Copy, Drop, starknet::Store, Serde)] +pub struct Imodel_with_byte_arraySafeLibraryDispatcher { + pub class_hash: starknet::ClassHash, +} + +impl Imodel_with_byte_arraySafeLibraryDispatcherImpl of Imodel_with_byte_arraySafeDispatcherTrait { + fn ensure_abi(self: Imodel_with_byte_arraySafeLibraryDispatcher, model: ModelWithByteArray) -> starknet::SyscallResult<()> { + let mut __calldata__ = core::traits::Default::default(); + core::serde::Serde::::serialize(@model, ref __calldata__); + + let mut __dispatcher_return_data__ = starknet::syscalls::library_call_syscall( + self.class_hash, + selector!("ensure_abi"), + core::array::ArrayTrait::span(@__calldata__), + ); + let mut __dispatcher_return_data__ = __dispatcher_return_data__?; + Result::Ok(()) + } + +} + + +#[derive(Copy, Drop, starknet::Store, Serde)] +pub struct Imodel_with_byte_arraySafeDispatcher { + pub contract_address: starknet::ContractAddress, +} + +impl Imodel_with_byte_arraySafeDispatcherImpl of Imodel_with_byte_arraySafeDispatcherTrait { + fn ensure_abi(self: Imodel_with_byte_arraySafeDispatcher, model: ModelWithByteArray) -> starknet::SyscallResult<()> { + let mut __calldata__ = core::traits::Default::default(); + core::serde::Serde::::serialize(@model, ref __calldata__); + + let mut __dispatcher_return_data__ = starknet::syscalls::call_contract_syscall( + self.contract_address, + selector!("ensure_abi"), + core::array::ArrayTrait::span(@__calldata__), + ); + let mut __dispatcher_return_data__ = __dispatcher_return_data__?; + Result::Ok(()) + } + +} +impl ModelWithComplexArrayEntityDrop of core::traits::Drop::; +impl ModelWithComplexArrayEntitySerde of core::serde::Serde:: { + fn serialize(self: @ModelWithComplexArrayEntity, ref output: core::array::Array) { + core::serde::Serde::serialize(self.__id, ref output); + core::serde::Serde::serialize(self.x, ref output); + core::serde::Serde::serialize(self.y, ref output) + } + fn deserialize(ref serialized: core::array::Span) -> core::option::Option { + core::option::Option::Some(ModelWithComplexArrayEntity { + __id: core::serde::Serde::deserialize(ref serialized)?, + x: core::serde::Serde::deserialize(ref serialized)?, + y: core::serde::Serde::deserialize(ref serialized)?, + }) + } +} +pub trait ModelWithComplexArrayEntityStore { + fn get(world: dojo::world::IWorldDispatcher, entity_id: felt252) -> ModelWithComplexArrayEntity; + + fn update(self: @ModelWithComplexArrayEntity, world: dojo::world::IWorldDispatcher); + + fn delete(self: @ModelWithComplexArrayEntity, world: dojo::world::IWorldDispatcher); + + + fn get_x(world: dojo::world::IWorldDispatcher, entity_id: felt252) -> u16; + + fn set_x(self: @ModelWithComplexArrayEntity, world: dojo::world::IWorldDispatcher, value: u16); + + fn get_y(world: dojo::world::IWorldDispatcher, entity_id: felt252) -> Array; + + fn set_y(self: @ModelWithComplexArrayEntity, world: dojo::world::IWorldDispatcher, value: Array); + +} +pub trait ModelWithComplexArrayStore { + fn entity_id_from_keys(player: ContractAddress) -> felt252; + + fn from_values(ref keys: Span, ref values: Span) -> ModelWithComplexArray; + + fn get(world: dojo::world::IWorldDispatcher, player: ContractAddress) -> ModelWithComplexArray; + + fn set(self: @ModelWithComplexArray, world: dojo::world::IWorldDispatcher); + + fn delete(self: @ModelWithComplexArray, world: dojo::world::IWorldDispatcher); + + + fn get_x(world: dojo::world::IWorldDispatcher, player: ContractAddress) -> u16; + + fn set_x(self: @ModelWithComplexArray, world: dojo::world::IWorldDispatcher, value: u16); + + fn get_y(world: dojo::world::IWorldDispatcher, player: ContractAddress) -> Array; + + fn set_y(self: @ModelWithComplexArray, world: dojo::world::IWorldDispatcher, value: Array); + +} +pub trait Imodel_with_complex_arrayDispatcherTrait { + fn ensure_abi(self: T, model: ModelWithComplexArray); +} + +#[derive(Copy, Drop, starknet::Store, Serde)] +pub struct Imodel_with_complex_arrayDispatcher { + pub contract_address: starknet::ContractAddress, +} + +impl Imodel_with_complex_arrayDispatcherImpl of Imodel_with_complex_arrayDispatcherTrait { + fn ensure_abi(self: Imodel_with_complex_arrayDispatcher, model: ModelWithComplexArray) { + let mut __calldata__ = core::traits::Default::default(); + core::serde::Serde::::serialize(@model, ref __calldata__); + + let mut __dispatcher_return_data__ = starknet::syscalls::call_contract_syscall( + self.contract_address, + selector!("ensure_abi"), + core::array::ArrayTrait::span(@__calldata__), + ); + let mut __dispatcher_return_data__ = starknet::SyscallResultTrait::unwrap_syscall(__dispatcher_return_data__); + () + } + +} + +#[derive(Copy, Drop, starknet::Store, Serde)] +pub struct Imodel_with_complex_arrayLibraryDispatcher { + pub class_hash: starknet::ClassHash, +} + +impl Imodel_with_complex_arrayLibraryDispatcherImpl of Imodel_with_complex_arrayDispatcherTrait { + fn ensure_abi(self: Imodel_with_complex_arrayLibraryDispatcher, model: ModelWithComplexArray) { + let mut __calldata__ = core::traits::Default::default(); + core::serde::Serde::::serialize(@model, ref __calldata__); + + let mut __dispatcher_return_data__ = starknet::syscalls::library_call_syscall( + self.class_hash, + selector!("ensure_abi"), + core::array::ArrayTrait::span(@__calldata__), + ); + let mut __dispatcher_return_data__ = starknet::SyscallResultTrait::unwrap_syscall(__dispatcher_return_data__); + () + } + +} + +pub trait Imodel_with_complex_arraySafeDispatcherTrait { + #[unstable(feature: "safe_dispatcher")] + fn ensure_abi(self: T, model: ModelWithComplexArray) -> starknet::SyscallResult<()>; +} + +#[derive(Copy, Drop, starknet::Store, Serde)] +pub struct Imodel_with_complex_arraySafeLibraryDispatcher { + pub class_hash: starknet::ClassHash, +} + +impl Imodel_with_complex_arraySafeLibraryDispatcherImpl of Imodel_with_complex_arraySafeDispatcherTrait { + fn ensure_abi(self: Imodel_with_complex_arraySafeLibraryDispatcher, model: ModelWithComplexArray) -> starknet::SyscallResult<()> { + let mut __calldata__ = core::traits::Default::default(); + core::serde::Serde::::serialize(@model, ref __calldata__); + + let mut __dispatcher_return_data__ = starknet::syscalls::library_call_syscall( + self.class_hash, + selector!("ensure_abi"), + core::array::ArrayTrait::span(@__calldata__), + ); + let mut __dispatcher_return_data__ = __dispatcher_return_data__?; + Result::Ok(()) + } + +} + + +#[derive(Copy, Drop, starknet::Store, Serde)] +pub struct Imodel_with_complex_arraySafeDispatcher { + pub contract_address: starknet::ContractAddress, +} + +impl Imodel_with_complex_arraySafeDispatcherImpl of Imodel_with_complex_arraySafeDispatcherTrait { + fn ensure_abi(self: Imodel_with_complex_arraySafeDispatcher, model: ModelWithComplexArray) -> starknet::SyscallResult<()> { + let mut __calldata__ = core::traits::Default::default(); + core::serde::Serde::::serialize(@model, ref __calldata__); + + let mut __dispatcher_return_data__ = starknet::syscalls::call_contract_syscall( + self.contract_address, + selector!("ensure_abi"), + core::array::ArrayTrait::span(@__calldata__), + ); + let mut __dispatcher_return_data__ = __dispatcher_return_data__?; + Result::Ok(()) + } + +} +impl ModelWithTupleEntityDrop of core::traits::Drop::; +impl ModelWithTupleEntitySerde of core::serde::Serde:: { + fn serialize(self: @ModelWithTupleEntity, ref output: core::array::Array) { + core::serde::Serde::serialize(self.__id, ref output); + core::serde::Serde::serialize(self.x, ref output); + core::serde::Serde::serialize(self.y, ref output) + } + fn deserialize(ref serialized: core::array::Span) -> core::option::Option { + core::option::Option::Some(ModelWithTupleEntity { + __id: core::serde::Serde::deserialize(ref serialized)?, + x: core::serde::Serde::deserialize(ref serialized)?, + y: core::serde::Serde::deserialize(ref serialized)?, + }) + } +} +pub trait ModelWithTupleEntityStore { + fn get(world: dojo::world::IWorldDispatcher, entity_id: felt252) -> ModelWithTupleEntity; + + fn update(self: @ModelWithTupleEntity, world: dojo::world::IWorldDispatcher); + + fn delete(self: @ModelWithTupleEntity, world: dojo::world::IWorldDispatcher); + + + fn get_x(world: dojo::world::IWorldDispatcher, entity_id: felt252) -> u16; + + fn set_x(self: @ModelWithTupleEntity, world: dojo::world::IWorldDispatcher, value: u16); + + fn get_y(world: dojo::world::IWorldDispatcher, entity_id: felt252) -> (u8, u16, u32); + + fn set_y(self: @ModelWithTupleEntity, world: dojo::world::IWorldDispatcher, value: (u8, u16, u32)); + +} +pub trait ModelWithTupleStore { + fn entity_id_from_keys(player: ContractAddress) -> felt252; + + fn from_values(ref keys: Span, ref values: Span) -> ModelWithTuple; + + fn get(world: dojo::world::IWorldDispatcher, player: ContractAddress) -> ModelWithTuple; + + fn set(self: @ModelWithTuple, world: dojo::world::IWorldDispatcher); + + fn delete(self: @ModelWithTuple, world: dojo::world::IWorldDispatcher); + + + fn get_x(world: dojo::world::IWorldDispatcher, player: ContractAddress) -> u16; + + fn set_x(self: @ModelWithTuple, world: dojo::world::IWorldDispatcher, value: u16); + + fn get_y(world: dojo::world::IWorldDispatcher, player: ContractAddress) -> (u8, u16, u32); + + fn set_y(self: @ModelWithTuple, world: dojo::world::IWorldDispatcher, value: (u8, u16, u32)); + +} +pub trait Imodel_with_tupleDispatcherTrait { + fn ensure_abi(self: T, model: ModelWithTuple); +} + +#[derive(Copy, Drop, starknet::Store, Serde)] +pub struct Imodel_with_tupleDispatcher { + pub contract_address: starknet::ContractAddress, +} + +impl Imodel_with_tupleDispatcherImpl of Imodel_with_tupleDispatcherTrait { + fn ensure_abi(self: Imodel_with_tupleDispatcher, model: ModelWithTuple) { + let mut __calldata__ = core::traits::Default::default(); + core::serde::Serde::::serialize(@model, ref __calldata__); + + let mut __dispatcher_return_data__ = starknet::syscalls::call_contract_syscall( + self.contract_address, + selector!("ensure_abi"), + core::array::ArrayTrait::span(@__calldata__), + ); + let mut __dispatcher_return_data__ = starknet::SyscallResultTrait::unwrap_syscall(__dispatcher_return_data__); + () + } + +} + +#[derive(Copy, Drop, starknet::Store, Serde)] +pub struct Imodel_with_tupleLibraryDispatcher { + pub class_hash: starknet::ClassHash, +} + +impl Imodel_with_tupleLibraryDispatcherImpl of Imodel_with_tupleDispatcherTrait { + fn ensure_abi(self: Imodel_with_tupleLibraryDispatcher, model: ModelWithTuple) { + let mut __calldata__ = core::traits::Default::default(); + core::serde::Serde::::serialize(@model, ref __calldata__); + + let mut __dispatcher_return_data__ = starknet::syscalls::library_call_syscall( + self.class_hash, + selector!("ensure_abi"), + core::array::ArrayTrait::span(@__calldata__), + ); + let mut __dispatcher_return_data__ = starknet::SyscallResultTrait::unwrap_syscall(__dispatcher_return_data__); + () + } + +} + +pub trait Imodel_with_tupleSafeDispatcherTrait { + #[unstable(feature: "safe_dispatcher")] + fn ensure_abi(self: T, model: ModelWithTuple) -> starknet::SyscallResult<()>; +} + +#[derive(Copy, Drop, starknet::Store, Serde)] +pub struct Imodel_with_tupleSafeLibraryDispatcher { + pub class_hash: starknet::ClassHash, +} + +impl Imodel_with_tupleSafeLibraryDispatcherImpl of Imodel_with_tupleSafeDispatcherTrait { + fn ensure_abi(self: Imodel_with_tupleSafeLibraryDispatcher, model: ModelWithTuple) -> starknet::SyscallResult<()> { + let mut __calldata__ = core::traits::Default::default(); + core::serde::Serde::::serialize(@model, ref __calldata__); + + let mut __dispatcher_return_data__ = starknet::syscalls::library_call_syscall( + self.class_hash, + selector!("ensure_abi"), + core::array::ArrayTrait::span(@__calldata__), + ); + let mut __dispatcher_return_data__ = __dispatcher_return_data__?; + Result::Ok(()) + } + +} + + +#[derive(Copy, Drop, starknet::Store, Serde)] +pub struct Imodel_with_tupleSafeDispatcher { + pub contract_address: starknet::ContractAddress, +} + +impl Imodel_with_tupleSafeDispatcherImpl of Imodel_with_tupleSafeDispatcherTrait { + fn ensure_abi(self: Imodel_with_tupleSafeDispatcher, model: ModelWithTuple) -> starknet::SyscallResult<()> { + let mut __calldata__ = core::traits::Default::default(); + core::serde::Serde::::serialize(@model, ref __calldata__); + + let mut __dispatcher_return_data__ = starknet::syscalls::call_contract_syscall( + self.contract_address, + selector!("ensure_abi"), + core::array::ArrayTrait::span(@__calldata__), + ); + let mut __dispatcher_return_data__ = __dispatcher_return_data__?; + Result::Ok(()) + } + +} +impl ModelWithTupleNoPrimitivesEntityDrop of core::traits::Drop::; +impl ModelWithTupleNoPrimitivesEntitySerde of core::serde::Serde:: { + fn serialize(self: @ModelWithTupleNoPrimitivesEntity, ref output: core::array::Array) { + core::serde::Serde::serialize(self.__id, ref output); + core::serde::Serde::serialize(self.x, ref output); + core::serde::Serde::serialize(self.y, ref output) + } + fn deserialize(ref serialized: core::array::Span) -> core::option::Option { + core::option::Option::Some(ModelWithTupleNoPrimitivesEntity { + __id: core::serde::Serde::deserialize(ref serialized)?, + x: core::serde::Serde::deserialize(ref serialized)?, + y: core::serde::Serde::deserialize(ref serialized)?, + }) + } +} +pub trait ModelWithTupleNoPrimitivesEntityStore { + fn get(world: dojo::world::IWorldDispatcher, entity_id: felt252) -> ModelWithTupleNoPrimitivesEntity; + + fn update(self: @ModelWithTupleNoPrimitivesEntity, world: dojo::world::IWorldDispatcher); + + fn delete(self: @ModelWithTupleNoPrimitivesEntity, world: dojo::world::IWorldDispatcher); + + + fn get_x(world: dojo::world::IWorldDispatcher, entity_id: felt252) -> u16; + + fn set_x(self: @ModelWithTupleNoPrimitivesEntity, world: dojo::world::IWorldDispatcher, value: u16); + + fn get_y(world: dojo::world::IWorldDispatcher, entity_id: felt252) -> (u8, Vec3, u32); + + fn set_y(self: @ModelWithTupleNoPrimitivesEntity, world: dojo::world::IWorldDispatcher, value: (u8, Vec3, u32)); + +} +pub trait ModelWithTupleNoPrimitivesStore { + fn entity_id_from_keys(player: ContractAddress) -> felt252; + + fn from_values(ref keys: Span, ref values: Span) -> ModelWithTupleNoPrimitives; + + fn get(world: dojo::world::IWorldDispatcher, player: ContractAddress) -> ModelWithTupleNoPrimitives; + + fn set(self: @ModelWithTupleNoPrimitives, world: dojo::world::IWorldDispatcher); + + fn delete(self: @ModelWithTupleNoPrimitives, world: dojo::world::IWorldDispatcher); + + + fn get_x(world: dojo::world::IWorldDispatcher, player: ContractAddress) -> u16; + + fn set_x(self: @ModelWithTupleNoPrimitives, world: dojo::world::IWorldDispatcher, value: u16); + + fn get_y(world: dojo::world::IWorldDispatcher, player: ContractAddress) -> (u8, Vec3, u32); + + fn set_y(self: @ModelWithTupleNoPrimitives, world: dojo::world::IWorldDispatcher, value: (u8, Vec3, u32)); + +} +pub trait Imodel_with_tuple_no_primitivesDispatcherTrait { + fn ensure_abi(self: T, model: ModelWithTupleNoPrimitives); +} + +#[derive(Copy, Drop, starknet::Store, Serde)] +pub struct Imodel_with_tuple_no_primitivesDispatcher { + pub contract_address: starknet::ContractAddress, +} + +impl Imodel_with_tuple_no_primitivesDispatcherImpl of Imodel_with_tuple_no_primitivesDispatcherTrait { + fn ensure_abi(self: Imodel_with_tuple_no_primitivesDispatcher, model: ModelWithTupleNoPrimitives) { + let mut __calldata__ = core::traits::Default::default(); + core::serde::Serde::::serialize(@model, ref __calldata__); + + let mut __dispatcher_return_data__ = starknet::syscalls::call_contract_syscall( + self.contract_address, + selector!("ensure_abi"), + core::array::ArrayTrait::span(@__calldata__), + ); + let mut __dispatcher_return_data__ = starknet::SyscallResultTrait::unwrap_syscall(__dispatcher_return_data__); + () + } + +} + +#[derive(Copy, Drop, starknet::Store, Serde)] +pub struct Imodel_with_tuple_no_primitivesLibraryDispatcher { + pub class_hash: starknet::ClassHash, +} + +impl Imodel_with_tuple_no_primitivesLibraryDispatcherImpl of Imodel_with_tuple_no_primitivesDispatcherTrait { + fn ensure_abi(self: Imodel_with_tuple_no_primitivesLibraryDispatcher, model: ModelWithTupleNoPrimitives) { + let mut __calldata__ = core::traits::Default::default(); + core::serde::Serde::::serialize(@model, ref __calldata__); + + let mut __dispatcher_return_data__ = starknet::syscalls::library_call_syscall( + self.class_hash, + selector!("ensure_abi"), + core::array::ArrayTrait::span(@__calldata__), + ); + let mut __dispatcher_return_data__ = starknet::SyscallResultTrait::unwrap_syscall(__dispatcher_return_data__); + () + } + +} + +pub trait Imodel_with_tuple_no_primitivesSafeDispatcherTrait { + #[unstable(feature: "safe_dispatcher")] + fn ensure_abi(self: T, model: ModelWithTupleNoPrimitives) -> starknet::SyscallResult<()>; +} + +#[derive(Copy, Drop, starknet::Store, Serde)] +pub struct Imodel_with_tuple_no_primitivesSafeLibraryDispatcher { + pub class_hash: starknet::ClassHash, +} + +impl Imodel_with_tuple_no_primitivesSafeLibraryDispatcherImpl of Imodel_with_tuple_no_primitivesSafeDispatcherTrait { + fn ensure_abi(self: Imodel_with_tuple_no_primitivesSafeLibraryDispatcher, model: ModelWithTupleNoPrimitives) -> starknet::SyscallResult<()> { + let mut __calldata__ = core::traits::Default::default(); + core::serde::Serde::::serialize(@model, ref __calldata__); + + let mut __dispatcher_return_data__ = starknet::syscalls::library_call_syscall( + self.class_hash, + selector!("ensure_abi"), + core::array::ArrayTrait::span(@__calldata__), + ); + let mut __dispatcher_return_data__ = __dispatcher_return_data__?; + Result::Ok(()) + } + +} + + +#[derive(Copy, Drop, starknet::Store, Serde)] +pub struct Imodel_with_tuple_no_primitivesSafeDispatcher { + pub contract_address: starknet::ContractAddress, +} + +impl Imodel_with_tuple_no_primitivesSafeDispatcherImpl of Imodel_with_tuple_no_primitivesSafeDispatcherTrait { + fn ensure_abi(self: Imodel_with_tuple_no_primitivesSafeDispatcher, model: ModelWithTupleNoPrimitives) -> starknet::SyscallResult<()> { + let mut __calldata__ = core::traits::Default::default(); + core::serde::Serde::::serialize(@model, ref __calldata__); + + let mut __dispatcher_return_data__ = starknet::syscalls::call_contract_syscall( + self.contract_address, + selector!("ensure_abi"), + core::array::ArrayTrait::span(@__calldata__), + ); + let mut __dispatcher_return_data__ = __dispatcher_return_data__?; + Result::Ok(()) + } + +} +impl Ibad_model_multiple_versionsDispatcherCopy of core::traits::Copy::; +impl Ibad_model_multiple_versionsDispatcherDrop of core::traits::Drop::; +impl Ibad_model_multiple_versionsDispatcherSerde of core::serde::Serde:: { + fn serialize(self: @Ibad_model_multiple_versionsDispatcher, ref output: core::array::Array) { + core::serde::Serde::serialize(self.contract_address, ref output) + } + fn deserialize(ref serialized: core::array::Span) -> core::option::Option { + core::option::Option::Some(Ibad_model_multiple_versionsDispatcher { + contract_address: core::serde::Serde::deserialize(ref serialized)?, + }) + } +} +impl StoreIbad_model_multiple_versionsDispatcher of starknet::Store:: { + fn read(address_domain: u32, base: starknet::storage_access::StorageBaseAddress) -> starknet::SyscallResult { + let contract_address = starknet::Store::::read(address_domain, base)?; + starknet::SyscallResult::Ok( + Ibad_model_multiple_versionsDispatcher { + contract_address, + } + ) + } + fn write(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, value: Ibad_model_multiple_versionsDispatcher) -> starknet::SyscallResult<()> { + starknet::Store::::write(address_domain, base, value.contract_address)?; + starknet::SyscallResult::Ok(()) + } + fn read_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8) -> starknet::SyscallResult { + let contract_address = starknet::Store::::read_at_offset(address_domain, base, offset)?; + starknet::SyscallResult::Ok( + Ibad_model_multiple_versionsDispatcher { + contract_address, + } + ) + } + #[inline(always)] + fn write_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8, value: Ibad_model_multiple_versionsDispatcher) -> starknet::SyscallResult<()> { + starknet::Store::::write_at_offset(address_domain, base, offset, value.contract_address)?; + starknet::SyscallResult::Ok(()) + } + #[inline(always)] + fn size() -> u8 { + starknet::Store::::size() + } +} + +#[derive(Drop, Copy)] +pub struct Ibad_model_multiple_versionsDispatcherSubPointers { + pub contract_address: starknet::storage::StoragePointer, +} +impl Ibad_model_multiple_versionsDispatcherSubPointersImpl of starknet::storage::SubPointers { + type SubPointersType = Ibad_model_multiple_versionsDispatcherSubPointers; + fn sub_pointers(self: starknet::storage::StoragePointer) -> Ibad_model_multiple_versionsDispatcherSubPointers { + let base_address = self.__storage_pointer_address__; + let mut current_offset = self.__storage_pointer_offset__; + let contract_address_value = starknet::storage::StoragePointer { + __storage_pointer_address__: base_address, + __storage_pointer_offset__: current_offset, + }; + Ibad_model_multiple_versionsDispatcherSubPointers { + contract_address: contract_address_value, + } + } +} +#[derive(Drop, Copy)] +pub struct Ibad_model_multiple_versionsDispatcherSubPointersMut { + pub contract_address: starknet::storage::StoragePointer>, +} +impl Ibad_model_multiple_versionsDispatcherSubPointersMutImpl of starknet::storage::SubPointersMut { + type SubPointersType = Ibad_model_multiple_versionsDispatcherSubPointersMut; + fn sub_pointers_mut(self: starknet::storage::StoragePointer>) -> Ibad_model_multiple_versionsDispatcherSubPointersMut { + let base_address = self.__storage_pointer_address__; + let mut current_offset = self.__storage_pointer_offset__; + let contract_address_value = starknet::storage::StoragePointer { + __storage_pointer_address__: base_address, + __storage_pointer_offset__: current_offset, + }; + Ibad_model_multiple_versionsDispatcherSubPointersMut { + contract_address: contract_address_value, + } + } +} +impl Ibad_model_multiple_versionsLibraryDispatcherCopy of core::traits::Copy::; +impl Ibad_model_multiple_versionsLibraryDispatcherDrop of core::traits::Drop::; +impl Ibad_model_multiple_versionsLibraryDispatcherSerde of core::serde::Serde:: { + fn serialize(self: @Ibad_model_multiple_versionsLibraryDispatcher, ref output: core::array::Array) { + core::serde::Serde::serialize(self.class_hash, ref output) + } + fn deserialize(ref serialized: core::array::Span) -> core::option::Option { + core::option::Option::Some(Ibad_model_multiple_versionsLibraryDispatcher { + class_hash: core::serde::Serde::deserialize(ref serialized)?, + }) + } +} +impl StoreIbad_model_multiple_versionsLibraryDispatcher of starknet::Store:: { + fn read(address_domain: u32, base: starknet::storage_access::StorageBaseAddress) -> starknet::SyscallResult { + let class_hash = starknet::Store::::read(address_domain, base)?; + starknet::SyscallResult::Ok( + Ibad_model_multiple_versionsLibraryDispatcher { + class_hash, + } + ) + } + fn write(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, value: Ibad_model_multiple_versionsLibraryDispatcher) -> starknet::SyscallResult<()> { + starknet::Store::::write(address_domain, base, value.class_hash)?; + starknet::SyscallResult::Ok(()) + } + fn read_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8) -> starknet::SyscallResult { + let class_hash = starknet::Store::::read_at_offset(address_domain, base, offset)?; + starknet::SyscallResult::Ok( + Ibad_model_multiple_versionsLibraryDispatcher { + class_hash, + } + ) + } + #[inline(always)] + fn write_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8, value: Ibad_model_multiple_versionsLibraryDispatcher) -> starknet::SyscallResult<()> { + starknet::Store::::write_at_offset(address_domain, base, offset, value.class_hash)?; + starknet::SyscallResult::Ok(()) + } + #[inline(always)] + fn size() -> u8 { + starknet::Store::::size() + } +} + +#[derive(Drop, Copy)] +pub struct Ibad_model_multiple_versionsLibraryDispatcherSubPointers { + pub class_hash: starknet::storage::StoragePointer, +} +impl Ibad_model_multiple_versionsLibraryDispatcherSubPointersImpl of starknet::storage::SubPointers { + type SubPointersType = Ibad_model_multiple_versionsLibraryDispatcherSubPointers; + fn sub_pointers(self: starknet::storage::StoragePointer) -> Ibad_model_multiple_versionsLibraryDispatcherSubPointers { + let base_address = self.__storage_pointer_address__; + let mut current_offset = self.__storage_pointer_offset__; + let class_hash_value = starknet::storage::StoragePointer { + __storage_pointer_address__: base_address, + __storage_pointer_offset__: current_offset, + }; + Ibad_model_multiple_versionsLibraryDispatcherSubPointers { + class_hash: class_hash_value, + } + } +} +#[derive(Drop, Copy)] +pub struct Ibad_model_multiple_versionsLibraryDispatcherSubPointersMut { + pub class_hash: starknet::storage::StoragePointer>, +} +impl Ibad_model_multiple_versionsLibraryDispatcherSubPointersMutImpl of starknet::storage::SubPointersMut { + type SubPointersType = Ibad_model_multiple_versionsLibraryDispatcherSubPointersMut; + fn sub_pointers_mut(self: starknet::storage::StoragePointer>) -> Ibad_model_multiple_versionsLibraryDispatcherSubPointersMut { + let base_address = self.__storage_pointer_address__; + let mut current_offset = self.__storage_pointer_offset__; + let class_hash_value = starknet::storage::StoragePointer { + __storage_pointer_address__: base_address, + __storage_pointer_offset__: current_offset, + }; + Ibad_model_multiple_versionsLibraryDispatcherSubPointersMut { + class_hash: class_hash_value, + } + } +} +impl Ibad_model_multiple_versionsSafeLibraryDispatcherCopy of core::traits::Copy::; +impl Ibad_model_multiple_versionsSafeLibraryDispatcherDrop of core::traits::Drop::; +impl Ibad_model_multiple_versionsSafeLibraryDispatcherSerde of core::serde::Serde:: { + fn serialize(self: @Ibad_model_multiple_versionsSafeLibraryDispatcher, ref output: core::array::Array) { + core::serde::Serde::serialize(self.class_hash, ref output) + } + fn deserialize(ref serialized: core::array::Span) -> core::option::Option { + core::option::Option::Some(Ibad_model_multiple_versionsSafeLibraryDispatcher { + class_hash: core::serde::Serde::deserialize(ref serialized)?, + }) + } +} +impl StoreIbad_model_multiple_versionsSafeLibraryDispatcher of starknet::Store:: { + fn read(address_domain: u32, base: starknet::storage_access::StorageBaseAddress) -> starknet::SyscallResult { + let class_hash = starknet::Store::::read(address_domain, base)?; + starknet::SyscallResult::Ok( + Ibad_model_multiple_versionsSafeLibraryDispatcher { + class_hash, + } + ) + } + fn write(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, value: Ibad_model_multiple_versionsSafeLibraryDispatcher) -> starknet::SyscallResult<()> { + starknet::Store::::write(address_domain, base, value.class_hash)?; + starknet::SyscallResult::Ok(()) + } + fn read_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8) -> starknet::SyscallResult { + let class_hash = starknet::Store::::read_at_offset(address_domain, base, offset)?; + starknet::SyscallResult::Ok( + Ibad_model_multiple_versionsSafeLibraryDispatcher { + class_hash, + } + ) + } + #[inline(always)] + fn write_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8, value: Ibad_model_multiple_versionsSafeLibraryDispatcher) -> starknet::SyscallResult<()> { + starknet::Store::::write_at_offset(address_domain, base, offset, value.class_hash)?; + starknet::SyscallResult::Ok(()) + } + #[inline(always)] + fn size() -> u8 { + starknet::Store::::size() + } +} + +#[derive(Drop, Copy)] +pub struct Ibad_model_multiple_versionsSafeLibraryDispatcherSubPointers { + pub class_hash: starknet::storage::StoragePointer, +} +impl Ibad_model_multiple_versionsSafeLibraryDispatcherSubPointersImpl of starknet::storage::SubPointers { + type SubPointersType = Ibad_model_multiple_versionsSafeLibraryDispatcherSubPointers; + fn sub_pointers(self: starknet::storage::StoragePointer) -> Ibad_model_multiple_versionsSafeLibraryDispatcherSubPointers { + let base_address = self.__storage_pointer_address__; + let mut current_offset = self.__storage_pointer_offset__; + let class_hash_value = starknet::storage::StoragePointer { + __storage_pointer_address__: base_address, + __storage_pointer_offset__: current_offset, + }; + Ibad_model_multiple_versionsSafeLibraryDispatcherSubPointers { + class_hash: class_hash_value, + } + } +} +#[derive(Drop, Copy)] +pub struct Ibad_model_multiple_versionsSafeLibraryDispatcherSubPointersMut { + pub class_hash: starknet::storage::StoragePointer>, +} +impl Ibad_model_multiple_versionsSafeLibraryDispatcherSubPointersMutImpl of starknet::storage::SubPointersMut { + type SubPointersType = Ibad_model_multiple_versionsSafeLibraryDispatcherSubPointersMut; + fn sub_pointers_mut(self: starknet::storage::StoragePointer>) -> Ibad_model_multiple_versionsSafeLibraryDispatcherSubPointersMut { + let base_address = self.__storage_pointer_address__; + let mut current_offset = self.__storage_pointer_offset__; + let class_hash_value = starknet::storage::StoragePointer { + __storage_pointer_address__: base_address, + __storage_pointer_offset__: current_offset, + }; + Ibad_model_multiple_versionsSafeLibraryDispatcherSubPointersMut { + class_hash: class_hash_value, + } + } +} +impl Ibad_model_multiple_versionsSafeDispatcherCopy of core::traits::Copy::; +impl Ibad_model_multiple_versionsSafeDispatcherDrop of core::traits::Drop::; +impl Ibad_model_multiple_versionsSafeDispatcherSerde of core::serde::Serde:: { + fn serialize(self: @Ibad_model_multiple_versionsSafeDispatcher, ref output: core::array::Array) { + core::serde::Serde::serialize(self.contract_address, ref output) + } + fn deserialize(ref serialized: core::array::Span) -> core::option::Option { + core::option::Option::Some(Ibad_model_multiple_versionsSafeDispatcher { + contract_address: core::serde::Serde::deserialize(ref serialized)?, + }) + } +} +impl StoreIbad_model_multiple_versionsSafeDispatcher of starknet::Store:: { + fn read(address_domain: u32, base: starknet::storage_access::StorageBaseAddress) -> starknet::SyscallResult { + let contract_address = starknet::Store::::read(address_domain, base)?; + starknet::SyscallResult::Ok( + Ibad_model_multiple_versionsSafeDispatcher { + contract_address, + } + ) + } + fn write(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, value: Ibad_model_multiple_versionsSafeDispatcher) -> starknet::SyscallResult<()> { + starknet::Store::::write(address_domain, base, value.contract_address)?; + starknet::SyscallResult::Ok(()) + } + fn read_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8) -> starknet::SyscallResult { + let contract_address = starknet::Store::::read_at_offset(address_domain, base, offset)?; + starknet::SyscallResult::Ok( + Ibad_model_multiple_versionsSafeDispatcher { + contract_address, + } + ) + } + #[inline(always)] + fn write_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8, value: Ibad_model_multiple_versionsSafeDispatcher) -> starknet::SyscallResult<()> { + starknet::Store::::write_at_offset(address_domain, base, offset, value.contract_address)?; + starknet::SyscallResult::Ok(()) + } + #[inline(always)] + fn size() -> u8 { + starknet::Store::::size() + } +} + +#[derive(Drop, Copy)] +pub struct Ibad_model_multiple_versionsSafeDispatcherSubPointers { + pub contract_address: starknet::storage::StoragePointer, +} +impl Ibad_model_multiple_versionsSafeDispatcherSubPointersImpl of starknet::storage::SubPointers { + type SubPointersType = Ibad_model_multiple_versionsSafeDispatcherSubPointers; + fn sub_pointers(self: starknet::storage::StoragePointer) -> Ibad_model_multiple_versionsSafeDispatcherSubPointers { + let base_address = self.__storage_pointer_address__; + let mut current_offset = self.__storage_pointer_offset__; + let contract_address_value = starknet::storage::StoragePointer { + __storage_pointer_address__: base_address, + __storage_pointer_offset__: current_offset, + }; + Ibad_model_multiple_versionsSafeDispatcherSubPointers { + contract_address: contract_address_value, + } + } +} +#[derive(Drop, Copy)] +pub struct Ibad_model_multiple_versionsSafeDispatcherSubPointersMut { + pub contract_address: starknet::storage::StoragePointer>, +} +impl Ibad_model_multiple_versionsSafeDispatcherSubPointersMutImpl of starknet::storage::SubPointersMut { + type SubPointersType = Ibad_model_multiple_versionsSafeDispatcherSubPointersMut; + fn sub_pointers_mut(self: starknet::storage::StoragePointer>) -> Ibad_model_multiple_versionsSafeDispatcherSubPointersMut { + let base_address = self.__storage_pointer_address__; + let mut current_offset = self.__storage_pointer_offset__; + let contract_address_value = starknet::storage::StoragePointer { + __storage_pointer_address__: base_address, + __storage_pointer_offset__: current_offset, + }; + Ibad_model_multiple_versionsSafeDispatcherSubPointersMut { + contract_address: contract_address_value, + } + } +} +impl Ibad_model_bad_version_typeDispatcherCopy of core::traits::Copy::; +impl Ibad_model_bad_version_typeDispatcherDrop of core::traits::Drop::; +impl Ibad_model_bad_version_typeDispatcherSerde of core::serde::Serde:: { + fn serialize(self: @Ibad_model_bad_version_typeDispatcher, ref output: core::array::Array) { + core::serde::Serde::serialize(self.contract_address, ref output) + } + fn deserialize(ref serialized: core::array::Span) -> core::option::Option { + core::option::Option::Some(Ibad_model_bad_version_typeDispatcher { + contract_address: core::serde::Serde::deserialize(ref serialized)?, + }) + } +} +impl StoreIbad_model_bad_version_typeDispatcher of starknet::Store:: { + fn read(address_domain: u32, base: starknet::storage_access::StorageBaseAddress) -> starknet::SyscallResult { + let contract_address = starknet::Store::::read(address_domain, base)?; + starknet::SyscallResult::Ok( + Ibad_model_bad_version_typeDispatcher { + contract_address, + } + ) + } + fn write(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, value: Ibad_model_bad_version_typeDispatcher) -> starknet::SyscallResult<()> { + starknet::Store::::write(address_domain, base, value.contract_address)?; + starknet::SyscallResult::Ok(()) + } + fn read_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8) -> starknet::SyscallResult { + let contract_address = starknet::Store::::read_at_offset(address_domain, base, offset)?; + starknet::SyscallResult::Ok( + Ibad_model_bad_version_typeDispatcher { + contract_address, + } + ) + } + #[inline(always)] + fn write_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8, value: Ibad_model_bad_version_typeDispatcher) -> starknet::SyscallResult<()> { + starknet::Store::::write_at_offset(address_domain, base, offset, value.contract_address)?; + starknet::SyscallResult::Ok(()) + } + #[inline(always)] + fn size() -> u8 { + starknet::Store::::size() + } +} + +#[derive(Drop, Copy)] +pub struct Ibad_model_bad_version_typeDispatcherSubPointers { + pub contract_address: starknet::storage::StoragePointer, +} +impl Ibad_model_bad_version_typeDispatcherSubPointersImpl of starknet::storage::SubPointers { + type SubPointersType = Ibad_model_bad_version_typeDispatcherSubPointers; + fn sub_pointers(self: starknet::storage::StoragePointer) -> Ibad_model_bad_version_typeDispatcherSubPointers { + let base_address = self.__storage_pointer_address__; + let mut current_offset = self.__storage_pointer_offset__; + let contract_address_value = starknet::storage::StoragePointer { + __storage_pointer_address__: base_address, + __storage_pointer_offset__: current_offset, + }; + Ibad_model_bad_version_typeDispatcherSubPointers { + contract_address: contract_address_value, + } + } +} +#[derive(Drop, Copy)] +pub struct Ibad_model_bad_version_typeDispatcherSubPointersMut { + pub contract_address: starknet::storage::StoragePointer>, +} +impl Ibad_model_bad_version_typeDispatcherSubPointersMutImpl of starknet::storage::SubPointersMut { + type SubPointersType = Ibad_model_bad_version_typeDispatcherSubPointersMut; + fn sub_pointers_mut(self: starknet::storage::StoragePointer>) -> Ibad_model_bad_version_typeDispatcherSubPointersMut { + let base_address = self.__storage_pointer_address__; + let mut current_offset = self.__storage_pointer_offset__; + let contract_address_value = starknet::storage::StoragePointer { + __storage_pointer_address__: base_address, + __storage_pointer_offset__: current_offset, + }; + Ibad_model_bad_version_typeDispatcherSubPointersMut { + contract_address: contract_address_value, + } + } +} +impl Ibad_model_bad_version_typeLibraryDispatcherCopy of core::traits::Copy::; +impl Ibad_model_bad_version_typeLibraryDispatcherDrop of core::traits::Drop::; +impl Ibad_model_bad_version_typeLibraryDispatcherSerde of core::serde::Serde:: { + fn serialize(self: @Ibad_model_bad_version_typeLibraryDispatcher, ref output: core::array::Array) { + core::serde::Serde::serialize(self.class_hash, ref output) + } + fn deserialize(ref serialized: core::array::Span) -> core::option::Option { + core::option::Option::Some(Ibad_model_bad_version_typeLibraryDispatcher { + class_hash: core::serde::Serde::deserialize(ref serialized)?, + }) + } +} +impl StoreIbad_model_bad_version_typeLibraryDispatcher of starknet::Store:: { + fn read(address_domain: u32, base: starknet::storage_access::StorageBaseAddress) -> starknet::SyscallResult { + let class_hash = starknet::Store::::read(address_domain, base)?; + starknet::SyscallResult::Ok( + Ibad_model_bad_version_typeLibraryDispatcher { + class_hash, + } + ) + } + fn write(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, value: Ibad_model_bad_version_typeLibraryDispatcher) -> starknet::SyscallResult<()> { + starknet::Store::::write(address_domain, base, value.class_hash)?; + starknet::SyscallResult::Ok(()) + } + fn read_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8) -> starknet::SyscallResult { + let class_hash = starknet::Store::::read_at_offset(address_domain, base, offset)?; + starknet::SyscallResult::Ok( + Ibad_model_bad_version_typeLibraryDispatcher { + class_hash, + } + ) + } + #[inline(always)] + fn write_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8, value: Ibad_model_bad_version_typeLibraryDispatcher) -> starknet::SyscallResult<()> { + starknet::Store::::write_at_offset(address_domain, base, offset, value.class_hash)?; + starknet::SyscallResult::Ok(()) + } + #[inline(always)] + fn size() -> u8 { + starknet::Store::::size() + } +} + +#[derive(Drop, Copy)] +pub struct Ibad_model_bad_version_typeLibraryDispatcherSubPointers { + pub class_hash: starknet::storage::StoragePointer, +} +impl Ibad_model_bad_version_typeLibraryDispatcherSubPointersImpl of starknet::storage::SubPointers { + type SubPointersType = Ibad_model_bad_version_typeLibraryDispatcherSubPointers; + fn sub_pointers(self: starknet::storage::StoragePointer) -> Ibad_model_bad_version_typeLibraryDispatcherSubPointers { + let base_address = self.__storage_pointer_address__; + let mut current_offset = self.__storage_pointer_offset__; + let class_hash_value = starknet::storage::StoragePointer { + __storage_pointer_address__: base_address, + __storage_pointer_offset__: current_offset, + }; + Ibad_model_bad_version_typeLibraryDispatcherSubPointers { + class_hash: class_hash_value, + } + } +} +#[derive(Drop, Copy)] +pub struct Ibad_model_bad_version_typeLibraryDispatcherSubPointersMut { + pub class_hash: starknet::storage::StoragePointer>, +} +impl Ibad_model_bad_version_typeLibraryDispatcherSubPointersMutImpl of starknet::storage::SubPointersMut { + type SubPointersType = Ibad_model_bad_version_typeLibraryDispatcherSubPointersMut; + fn sub_pointers_mut(self: starknet::storage::StoragePointer>) -> Ibad_model_bad_version_typeLibraryDispatcherSubPointersMut { + let base_address = self.__storage_pointer_address__; + let mut current_offset = self.__storage_pointer_offset__; + let class_hash_value = starknet::storage::StoragePointer { + __storage_pointer_address__: base_address, + __storage_pointer_offset__: current_offset, + }; + Ibad_model_bad_version_typeLibraryDispatcherSubPointersMut { + class_hash: class_hash_value, + } + } +} +impl Ibad_model_bad_version_typeSafeLibraryDispatcherCopy of core::traits::Copy::; +impl Ibad_model_bad_version_typeSafeLibraryDispatcherDrop of core::traits::Drop::; +impl Ibad_model_bad_version_typeSafeLibraryDispatcherSerde of core::serde::Serde:: { + fn serialize(self: @Ibad_model_bad_version_typeSafeLibraryDispatcher, ref output: core::array::Array) { + core::serde::Serde::serialize(self.class_hash, ref output) + } + fn deserialize(ref serialized: core::array::Span) -> core::option::Option { + core::option::Option::Some(Ibad_model_bad_version_typeSafeLibraryDispatcher { + class_hash: core::serde::Serde::deserialize(ref serialized)?, + }) + } +} +impl StoreIbad_model_bad_version_typeSafeLibraryDispatcher of starknet::Store:: { + fn read(address_domain: u32, base: starknet::storage_access::StorageBaseAddress) -> starknet::SyscallResult { + let class_hash = starknet::Store::::read(address_domain, base)?; + starknet::SyscallResult::Ok( + Ibad_model_bad_version_typeSafeLibraryDispatcher { + class_hash, + } + ) + } + fn write(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, value: Ibad_model_bad_version_typeSafeLibraryDispatcher) -> starknet::SyscallResult<()> { + starknet::Store::::write(address_domain, base, value.class_hash)?; + starknet::SyscallResult::Ok(()) + } + fn read_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8) -> starknet::SyscallResult { + let class_hash = starknet::Store::::read_at_offset(address_domain, base, offset)?; + starknet::SyscallResult::Ok( + Ibad_model_bad_version_typeSafeLibraryDispatcher { + class_hash, + } + ) + } + #[inline(always)] + fn write_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8, value: Ibad_model_bad_version_typeSafeLibraryDispatcher) -> starknet::SyscallResult<()> { + starknet::Store::::write_at_offset(address_domain, base, offset, value.class_hash)?; + starknet::SyscallResult::Ok(()) + } + #[inline(always)] + fn size() -> u8 { + starknet::Store::::size() + } +} + +#[derive(Drop, Copy)] +pub struct Ibad_model_bad_version_typeSafeLibraryDispatcherSubPointers { + pub class_hash: starknet::storage::StoragePointer, +} +impl Ibad_model_bad_version_typeSafeLibraryDispatcherSubPointersImpl of starknet::storage::SubPointers { + type SubPointersType = Ibad_model_bad_version_typeSafeLibraryDispatcherSubPointers; + fn sub_pointers(self: starknet::storage::StoragePointer) -> Ibad_model_bad_version_typeSafeLibraryDispatcherSubPointers { + let base_address = self.__storage_pointer_address__; + let mut current_offset = self.__storage_pointer_offset__; + let class_hash_value = starknet::storage::StoragePointer { + __storage_pointer_address__: base_address, + __storage_pointer_offset__: current_offset, + }; + Ibad_model_bad_version_typeSafeLibraryDispatcherSubPointers { + class_hash: class_hash_value, + } + } +} +#[derive(Drop, Copy)] +pub struct Ibad_model_bad_version_typeSafeLibraryDispatcherSubPointersMut { + pub class_hash: starknet::storage::StoragePointer>, +} +impl Ibad_model_bad_version_typeSafeLibraryDispatcherSubPointersMutImpl of starknet::storage::SubPointersMut { + type SubPointersType = Ibad_model_bad_version_typeSafeLibraryDispatcherSubPointersMut; + fn sub_pointers_mut(self: starknet::storage::StoragePointer>) -> Ibad_model_bad_version_typeSafeLibraryDispatcherSubPointersMut { + let base_address = self.__storage_pointer_address__; + let mut current_offset = self.__storage_pointer_offset__; + let class_hash_value = starknet::storage::StoragePointer { + __storage_pointer_address__: base_address, + __storage_pointer_offset__: current_offset, + }; + Ibad_model_bad_version_typeSafeLibraryDispatcherSubPointersMut { + class_hash: class_hash_value, + } + } +} +impl Ibad_model_bad_version_typeSafeDispatcherCopy of core::traits::Copy::; +impl Ibad_model_bad_version_typeSafeDispatcherDrop of core::traits::Drop::; +impl Ibad_model_bad_version_typeSafeDispatcherSerde of core::serde::Serde:: { + fn serialize(self: @Ibad_model_bad_version_typeSafeDispatcher, ref output: core::array::Array) { + core::serde::Serde::serialize(self.contract_address, ref output) + } + fn deserialize(ref serialized: core::array::Span) -> core::option::Option { + core::option::Option::Some(Ibad_model_bad_version_typeSafeDispatcher { + contract_address: core::serde::Serde::deserialize(ref serialized)?, + }) + } +} +impl StoreIbad_model_bad_version_typeSafeDispatcher of starknet::Store:: { + fn read(address_domain: u32, base: starknet::storage_access::StorageBaseAddress) -> starknet::SyscallResult { + let contract_address = starknet::Store::::read(address_domain, base)?; + starknet::SyscallResult::Ok( + Ibad_model_bad_version_typeSafeDispatcher { + contract_address, + } + ) + } + fn write(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, value: Ibad_model_bad_version_typeSafeDispatcher) -> starknet::SyscallResult<()> { + starknet::Store::::write(address_domain, base, value.contract_address)?; + starknet::SyscallResult::Ok(()) + } + fn read_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8) -> starknet::SyscallResult { + let contract_address = starknet::Store::::read_at_offset(address_domain, base, offset)?; + starknet::SyscallResult::Ok( + Ibad_model_bad_version_typeSafeDispatcher { + contract_address, + } + ) + } + #[inline(always)] + fn write_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8, value: Ibad_model_bad_version_typeSafeDispatcher) -> starknet::SyscallResult<()> { + starknet::Store::::write_at_offset(address_domain, base, offset, value.contract_address)?; + starknet::SyscallResult::Ok(()) + } + #[inline(always)] + fn size() -> u8 { + starknet::Store::::size() + } +} + +#[derive(Drop, Copy)] +pub struct Ibad_model_bad_version_typeSafeDispatcherSubPointers { + pub contract_address: starknet::storage::StoragePointer, +} +impl Ibad_model_bad_version_typeSafeDispatcherSubPointersImpl of starknet::storage::SubPointers { + type SubPointersType = Ibad_model_bad_version_typeSafeDispatcherSubPointers; + fn sub_pointers(self: starknet::storage::StoragePointer) -> Ibad_model_bad_version_typeSafeDispatcherSubPointers { + let base_address = self.__storage_pointer_address__; + let mut current_offset = self.__storage_pointer_offset__; + let contract_address_value = starknet::storage::StoragePointer { + __storage_pointer_address__: base_address, + __storage_pointer_offset__: current_offset, + }; + Ibad_model_bad_version_typeSafeDispatcherSubPointers { + contract_address: contract_address_value, + } + } +} +#[derive(Drop, Copy)] +pub struct Ibad_model_bad_version_typeSafeDispatcherSubPointersMut { + pub contract_address: starknet::storage::StoragePointer>, +} +impl Ibad_model_bad_version_typeSafeDispatcherSubPointersMutImpl of starknet::storage::SubPointersMut { + type SubPointersType = Ibad_model_bad_version_typeSafeDispatcherSubPointersMut; + fn sub_pointers_mut(self: starknet::storage::StoragePointer>) -> Ibad_model_bad_version_typeSafeDispatcherSubPointersMut { + let base_address = self.__storage_pointer_address__; + let mut current_offset = self.__storage_pointer_offset__; + let contract_address_value = starknet::storage::StoragePointer { + __storage_pointer_address__: base_address, + __storage_pointer_offset__: current_offset, + }; + Ibad_model_bad_version_typeSafeDispatcherSubPointersMut { + contract_address: contract_address_value, + } + } +} +impl Ibad_model_no_version_valueDispatcherCopy of core::traits::Copy::; +impl Ibad_model_no_version_valueDispatcherDrop of core::traits::Drop::; +impl Ibad_model_no_version_valueDispatcherSerde of core::serde::Serde:: { + fn serialize(self: @Ibad_model_no_version_valueDispatcher, ref output: core::array::Array) { + core::serde::Serde::serialize(self.contract_address, ref output) + } + fn deserialize(ref serialized: core::array::Span) -> core::option::Option { + core::option::Option::Some(Ibad_model_no_version_valueDispatcher { + contract_address: core::serde::Serde::deserialize(ref serialized)?, + }) + } +} +impl StoreIbad_model_no_version_valueDispatcher of starknet::Store:: { + fn read(address_domain: u32, base: starknet::storage_access::StorageBaseAddress) -> starknet::SyscallResult { + let contract_address = starknet::Store::::read(address_domain, base)?; + starknet::SyscallResult::Ok( + Ibad_model_no_version_valueDispatcher { + contract_address, + } + ) + } + fn write(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, value: Ibad_model_no_version_valueDispatcher) -> starknet::SyscallResult<()> { + starknet::Store::::write(address_domain, base, value.contract_address)?; + starknet::SyscallResult::Ok(()) + } + fn read_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8) -> starknet::SyscallResult { + let contract_address = starknet::Store::::read_at_offset(address_domain, base, offset)?; + starknet::SyscallResult::Ok( + Ibad_model_no_version_valueDispatcher { + contract_address, + } + ) + } + #[inline(always)] + fn write_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8, value: Ibad_model_no_version_valueDispatcher) -> starknet::SyscallResult<()> { + starknet::Store::::write_at_offset(address_domain, base, offset, value.contract_address)?; + starknet::SyscallResult::Ok(()) + } + #[inline(always)] + fn size() -> u8 { + starknet::Store::::size() + } +} + +#[derive(Drop, Copy)] +pub struct Ibad_model_no_version_valueDispatcherSubPointers { + pub contract_address: starknet::storage::StoragePointer, +} +impl Ibad_model_no_version_valueDispatcherSubPointersImpl of starknet::storage::SubPointers { + type SubPointersType = Ibad_model_no_version_valueDispatcherSubPointers; + fn sub_pointers(self: starknet::storage::StoragePointer) -> Ibad_model_no_version_valueDispatcherSubPointers { + let base_address = self.__storage_pointer_address__; + let mut current_offset = self.__storage_pointer_offset__; + let contract_address_value = starknet::storage::StoragePointer { + __storage_pointer_address__: base_address, + __storage_pointer_offset__: current_offset, + }; + Ibad_model_no_version_valueDispatcherSubPointers { + contract_address: contract_address_value, + } + } +} +#[derive(Drop, Copy)] +pub struct Ibad_model_no_version_valueDispatcherSubPointersMut { + pub contract_address: starknet::storage::StoragePointer>, +} +impl Ibad_model_no_version_valueDispatcherSubPointersMutImpl of starknet::storage::SubPointersMut { + type SubPointersType = Ibad_model_no_version_valueDispatcherSubPointersMut; + fn sub_pointers_mut(self: starknet::storage::StoragePointer>) -> Ibad_model_no_version_valueDispatcherSubPointersMut { + let base_address = self.__storage_pointer_address__; + let mut current_offset = self.__storage_pointer_offset__; + let contract_address_value = starknet::storage::StoragePointer { + __storage_pointer_address__: base_address, + __storage_pointer_offset__: current_offset, + }; + Ibad_model_no_version_valueDispatcherSubPointersMut { + contract_address: contract_address_value, + } + } +} +impl Ibad_model_no_version_valueLibraryDispatcherCopy of core::traits::Copy::; +impl Ibad_model_no_version_valueLibraryDispatcherDrop of core::traits::Drop::; +impl Ibad_model_no_version_valueLibraryDispatcherSerde of core::serde::Serde:: { + fn serialize(self: @Ibad_model_no_version_valueLibraryDispatcher, ref output: core::array::Array) { + core::serde::Serde::serialize(self.class_hash, ref output) + } + fn deserialize(ref serialized: core::array::Span) -> core::option::Option { + core::option::Option::Some(Ibad_model_no_version_valueLibraryDispatcher { + class_hash: core::serde::Serde::deserialize(ref serialized)?, + }) + } +} +impl StoreIbad_model_no_version_valueLibraryDispatcher of starknet::Store:: { + fn read(address_domain: u32, base: starknet::storage_access::StorageBaseAddress) -> starknet::SyscallResult { + let class_hash = starknet::Store::::read(address_domain, base)?; + starknet::SyscallResult::Ok( + Ibad_model_no_version_valueLibraryDispatcher { + class_hash, + } + ) + } + fn write(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, value: Ibad_model_no_version_valueLibraryDispatcher) -> starknet::SyscallResult<()> { + starknet::Store::::write(address_domain, base, value.class_hash)?; + starknet::SyscallResult::Ok(()) + } + fn read_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8) -> starknet::SyscallResult { + let class_hash = starknet::Store::::read_at_offset(address_domain, base, offset)?; + starknet::SyscallResult::Ok( + Ibad_model_no_version_valueLibraryDispatcher { + class_hash, + } + ) + } + #[inline(always)] + fn write_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8, value: Ibad_model_no_version_valueLibraryDispatcher) -> starknet::SyscallResult<()> { + starknet::Store::::write_at_offset(address_domain, base, offset, value.class_hash)?; + starknet::SyscallResult::Ok(()) + } + #[inline(always)] + fn size() -> u8 { + starknet::Store::::size() + } +} + +#[derive(Drop, Copy)] +pub struct Ibad_model_no_version_valueLibraryDispatcherSubPointers { + pub class_hash: starknet::storage::StoragePointer, +} +impl Ibad_model_no_version_valueLibraryDispatcherSubPointersImpl of starknet::storage::SubPointers { + type SubPointersType = Ibad_model_no_version_valueLibraryDispatcherSubPointers; + fn sub_pointers(self: starknet::storage::StoragePointer) -> Ibad_model_no_version_valueLibraryDispatcherSubPointers { + let base_address = self.__storage_pointer_address__; + let mut current_offset = self.__storage_pointer_offset__; + let class_hash_value = starknet::storage::StoragePointer { + __storage_pointer_address__: base_address, + __storage_pointer_offset__: current_offset, + }; + Ibad_model_no_version_valueLibraryDispatcherSubPointers { + class_hash: class_hash_value, + } + } +} +#[derive(Drop, Copy)] +pub struct Ibad_model_no_version_valueLibraryDispatcherSubPointersMut { + pub class_hash: starknet::storage::StoragePointer>, +} +impl Ibad_model_no_version_valueLibraryDispatcherSubPointersMutImpl of starknet::storage::SubPointersMut { + type SubPointersType = Ibad_model_no_version_valueLibraryDispatcherSubPointersMut; + fn sub_pointers_mut(self: starknet::storage::StoragePointer>) -> Ibad_model_no_version_valueLibraryDispatcherSubPointersMut { + let base_address = self.__storage_pointer_address__; + let mut current_offset = self.__storage_pointer_offset__; + let class_hash_value = starknet::storage::StoragePointer { + __storage_pointer_address__: base_address, + __storage_pointer_offset__: current_offset, + }; + Ibad_model_no_version_valueLibraryDispatcherSubPointersMut { + class_hash: class_hash_value, + } + } +} +impl Ibad_model_no_version_valueSafeLibraryDispatcherCopy of core::traits::Copy::; +impl Ibad_model_no_version_valueSafeLibraryDispatcherDrop of core::traits::Drop::; +impl Ibad_model_no_version_valueSafeLibraryDispatcherSerde of core::serde::Serde:: { + fn serialize(self: @Ibad_model_no_version_valueSafeLibraryDispatcher, ref output: core::array::Array) { + core::serde::Serde::serialize(self.class_hash, ref output) + } + fn deserialize(ref serialized: core::array::Span) -> core::option::Option { + core::option::Option::Some(Ibad_model_no_version_valueSafeLibraryDispatcher { + class_hash: core::serde::Serde::deserialize(ref serialized)?, + }) + } +} +impl StoreIbad_model_no_version_valueSafeLibraryDispatcher of starknet::Store:: { + fn read(address_domain: u32, base: starknet::storage_access::StorageBaseAddress) -> starknet::SyscallResult { + let class_hash = starknet::Store::::read(address_domain, base)?; + starknet::SyscallResult::Ok( + Ibad_model_no_version_valueSafeLibraryDispatcher { + class_hash, + } + ) + } + fn write(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, value: Ibad_model_no_version_valueSafeLibraryDispatcher) -> starknet::SyscallResult<()> { + starknet::Store::::write(address_domain, base, value.class_hash)?; + starknet::SyscallResult::Ok(()) + } + fn read_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8) -> starknet::SyscallResult { + let class_hash = starknet::Store::::read_at_offset(address_domain, base, offset)?; + starknet::SyscallResult::Ok( + Ibad_model_no_version_valueSafeLibraryDispatcher { + class_hash, + } + ) + } + #[inline(always)] + fn write_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8, value: Ibad_model_no_version_valueSafeLibraryDispatcher) -> starknet::SyscallResult<()> { + starknet::Store::::write_at_offset(address_domain, base, offset, value.class_hash)?; + starknet::SyscallResult::Ok(()) + } + #[inline(always)] + fn size() -> u8 { + starknet::Store::::size() + } +} + +#[derive(Drop, Copy)] +pub struct Ibad_model_no_version_valueSafeLibraryDispatcherSubPointers { + pub class_hash: starknet::storage::StoragePointer, +} +impl Ibad_model_no_version_valueSafeLibraryDispatcherSubPointersImpl of starknet::storage::SubPointers { + type SubPointersType = Ibad_model_no_version_valueSafeLibraryDispatcherSubPointers; + fn sub_pointers(self: starknet::storage::StoragePointer) -> Ibad_model_no_version_valueSafeLibraryDispatcherSubPointers { + let base_address = self.__storage_pointer_address__; + let mut current_offset = self.__storage_pointer_offset__; + let class_hash_value = starknet::storage::StoragePointer { + __storage_pointer_address__: base_address, + __storage_pointer_offset__: current_offset, + }; + Ibad_model_no_version_valueSafeLibraryDispatcherSubPointers { + class_hash: class_hash_value, + } + } +} +#[derive(Drop, Copy)] +pub struct Ibad_model_no_version_valueSafeLibraryDispatcherSubPointersMut { + pub class_hash: starknet::storage::StoragePointer>, +} +impl Ibad_model_no_version_valueSafeLibraryDispatcherSubPointersMutImpl of starknet::storage::SubPointersMut { + type SubPointersType = Ibad_model_no_version_valueSafeLibraryDispatcherSubPointersMut; + fn sub_pointers_mut(self: starknet::storage::StoragePointer>) -> Ibad_model_no_version_valueSafeLibraryDispatcherSubPointersMut { + let base_address = self.__storage_pointer_address__; + let mut current_offset = self.__storage_pointer_offset__; + let class_hash_value = starknet::storage::StoragePointer { + __storage_pointer_address__: base_address, + __storage_pointer_offset__: current_offset, + }; + Ibad_model_no_version_valueSafeLibraryDispatcherSubPointersMut { + class_hash: class_hash_value, + } + } +} +impl Ibad_model_no_version_valueSafeDispatcherCopy of core::traits::Copy::; +impl Ibad_model_no_version_valueSafeDispatcherDrop of core::traits::Drop::; +impl Ibad_model_no_version_valueSafeDispatcherSerde of core::serde::Serde:: { + fn serialize(self: @Ibad_model_no_version_valueSafeDispatcher, ref output: core::array::Array) { + core::serde::Serde::serialize(self.contract_address, ref output) + } + fn deserialize(ref serialized: core::array::Span) -> core::option::Option { + core::option::Option::Some(Ibad_model_no_version_valueSafeDispatcher { + contract_address: core::serde::Serde::deserialize(ref serialized)?, + }) + } +} +impl StoreIbad_model_no_version_valueSafeDispatcher of starknet::Store:: { + fn read(address_domain: u32, base: starknet::storage_access::StorageBaseAddress) -> starknet::SyscallResult { + let contract_address = starknet::Store::::read(address_domain, base)?; + starknet::SyscallResult::Ok( + Ibad_model_no_version_valueSafeDispatcher { + contract_address, + } + ) + } + fn write(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, value: Ibad_model_no_version_valueSafeDispatcher) -> starknet::SyscallResult<()> { + starknet::Store::::write(address_domain, base, value.contract_address)?; + starknet::SyscallResult::Ok(()) + } + fn read_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8) -> starknet::SyscallResult { + let contract_address = starknet::Store::::read_at_offset(address_domain, base, offset)?; + starknet::SyscallResult::Ok( + Ibad_model_no_version_valueSafeDispatcher { + contract_address, + } + ) + } + #[inline(always)] + fn write_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8, value: Ibad_model_no_version_valueSafeDispatcher) -> starknet::SyscallResult<()> { + starknet::Store::::write_at_offset(address_domain, base, offset, value.contract_address)?; + starknet::SyscallResult::Ok(()) + } + #[inline(always)] + fn size() -> u8 { + starknet::Store::::size() + } +} + +#[derive(Drop, Copy)] +pub struct Ibad_model_no_version_valueSafeDispatcherSubPointers { + pub contract_address: starknet::storage::StoragePointer, +} +impl Ibad_model_no_version_valueSafeDispatcherSubPointersImpl of starknet::storage::SubPointers { + type SubPointersType = Ibad_model_no_version_valueSafeDispatcherSubPointers; + fn sub_pointers(self: starknet::storage::StoragePointer) -> Ibad_model_no_version_valueSafeDispatcherSubPointers { + let base_address = self.__storage_pointer_address__; + let mut current_offset = self.__storage_pointer_offset__; + let contract_address_value = starknet::storage::StoragePointer { + __storage_pointer_address__: base_address, + __storage_pointer_offset__: current_offset, + }; + Ibad_model_no_version_valueSafeDispatcherSubPointers { + contract_address: contract_address_value, + } + } +} +#[derive(Drop, Copy)] +pub struct Ibad_model_no_version_valueSafeDispatcherSubPointersMut { + pub contract_address: starknet::storage::StoragePointer>, +} +impl Ibad_model_no_version_valueSafeDispatcherSubPointersMutImpl of starknet::storage::SubPointersMut { + type SubPointersType = Ibad_model_no_version_valueSafeDispatcherSubPointersMut; + fn sub_pointers_mut(self: starknet::storage::StoragePointer>) -> Ibad_model_no_version_valueSafeDispatcherSubPointersMut { + let base_address = self.__storage_pointer_address__; + let mut current_offset = self.__storage_pointer_offset__; + let contract_address_value = starknet::storage::StoragePointer { + __storage_pointer_address__: base_address, + __storage_pointer_offset__: current_offset, + }; + Ibad_model_no_version_valueSafeDispatcherSubPointersMut { + contract_address: contract_address_value, + } + } +} +impl Ibad_model_unexpected_arg_with_valueDispatcherCopy of core::traits::Copy::; +impl Ibad_model_unexpected_arg_with_valueDispatcherDrop of core::traits::Drop::; +impl Ibad_model_unexpected_arg_with_valueDispatcherSerde of core::serde::Serde:: { + fn serialize(self: @Ibad_model_unexpected_arg_with_valueDispatcher, ref output: core::array::Array) { + core::serde::Serde::serialize(self.contract_address, ref output) + } + fn deserialize(ref serialized: core::array::Span) -> core::option::Option { + core::option::Option::Some(Ibad_model_unexpected_arg_with_valueDispatcher { + contract_address: core::serde::Serde::deserialize(ref serialized)?, + }) + } +} +impl StoreIbad_model_unexpected_arg_with_valueDispatcher of starknet::Store:: { + fn read(address_domain: u32, base: starknet::storage_access::StorageBaseAddress) -> starknet::SyscallResult { + let contract_address = starknet::Store::::read(address_domain, base)?; + starknet::SyscallResult::Ok( + Ibad_model_unexpected_arg_with_valueDispatcher { + contract_address, + } + ) + } + fn write(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, value: Ibad_model_unexpected_arg_with_valueDispatcher) -> starknet::SyscallResult<()> { + starknet::Store::::write(address_domain, base, value.contract_address)?; + starknet::SyscallResult::Ok(()) + } + fn read_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8) -> starknet::SyscallResult { + let contract_address = starknet::Store::::read_at_offset(address_domain, base, offset)?; + starknet::SyscallResult::Ok( + Ibad_model_unexpected_arg_with_valueDispatcher { + contract_address, + } + ) + } + #[inline(always)] + fn write_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8, value: Ibad_model_unexpected_arg_with_valueDispatcher) -> starknet::SyscallResult<()> { + starknet::Store::::write_at_offset(address_domain, base, offset, value.contract_address)?; + starknet::SyscallResult::Ok(()) + } + #[inline(always)] + fn size() -> u8 { + starknet::Store::::size() + } +} + +#[derive(Drop, Copy)] +pub struct Ibad_model_unexpected_arg_with_valueDispatcherSubPointers { + pub contract_address: starknet::storage::StoragePointer, +} +impl Ibad_model_unexpected_arg_with_valueDispatcherSubPointersImpl of starknet::storage::SubPointers { + type SubPointersType = Ibad_model_unexpected_arg_with_valueDispatcherSubPointers; + fn sub_pointers(self: starknet::storage::StoragePointer) -> Ibad_model_unexpected_arg_with_valueDispatcherSubPointers { + let base_address = self.__storage_pointer_address__; + let mut current_offset = self.__storage_pointer_offset__; + let contract_address_value = starknet::storage::StoragePointer { + __storage_pointer_address__: base_address, + __storage_pointer_offset__: current_offset, + }; + Ibad_model_unexpected_arg_with_valueDispatcherSubPointers { + contract_address: contract_address_value, + } + } +} +#[derive(Drop, Copy)] +pub struct Ibad_model_unexpected_arg_with_valueDispatcherSubPointersMut { + pub contract_address: starknet::storage::StoragePointer>, +} +impl Ibad_model_unexpected_arg_with_valueDispatcherSubPointersMutImpl of starknet::storage::SubPointersMut { + type SubPointersType = Ibad_model_unexpected_arg_with_valueDispatcherSubPointersMut; + fn sub_pointers_mut(self: starknet::storage::StoragePointer>) -> Ibad_model_unexpected_arg_with_valueDispatcherSubPointersMut { + let base_address = self.__storage_pointer_address__; + let mut current_offset = self.__storage_pointer_offset__; + let contract_address_value = starknet::storage::StoragePointer { + __storage_pointer_address__: base_address, + __storage_pointer_offset__: current_offset, + }; + Ibad_model_unexpected_arg_with_valueDispatcherSubPointersMut { + contract_address: contract_address_value, + } + } +} +impl Ibad_model_unexpected_arg_with_valueLibraryDispatcherCopy of core::traits::Copy::; +impl Ibad_model_unexpected_arg_with_valueLibraryDispatcherDrop of core::traits::Drop::; +impl Ibad_model_unexpected_arg_with_valueLibraryDispatcherSerde of core::serde::Serde:: { + fn serialize(self: @Ibad_model_unexpected_arg_with_valueLibraryDispatcher, ref output: core::array::Array) { + core::serde::Serde::serialize(self.class_hash, ref output) + } + fn deserialize(ref serialized: core::array::Span) -> core::option::Option { + core::option::Option::Some(Ibad_model_unexpected_arg_with_valueLibraryDispatcher { + class_hash: core::serde::Serde::deserialize(ref serialized)?, + }) + } +} +impl StoreIbad_model_unexpected_arg_with_valueLibraryDispatcher of starknet::Store:: { + fn read(address_domain: u32, base: starknet::storage_access::StorageBaseAddress) -> starknet::SyscallResult { + let class_hash = starknet::Store::::read(address_domain, base)?; + starknet::SyscallResult::Ok( + Ibad_model_unexpected_arg_with_valueLibraryDispatcher { + class_hash, + } + ) + } + fn write(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, value: Ibad_model_unexpected_arg_with_valueLibraryDispatcher) -> starknet::SyscallResult<()> { + starknet::Store::::write(address_domain, base, value.class_hash)?; + starknet::SyscallResult::Ok(()) + } + fn read_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8) -> starknet::SyscallResult { + let class_hash = starknet::Store::::read_at_offset(address_domain, base, offset)?; + starknet::SyscallResult::Ok( + Ibad_model_unexpected_arg_with_valueLibraryDispatcher { + class_hash, + } + ) + } + #[inline(always)] + fn write_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8, value: Ibad_model_unexpected_arg_with_valueLibraryDispatcher) -> starknet::SyscallResult<()> { + starknet::Store::::write_at_offset(address_domain, base, offset, value.class_hash)?; + starknet::SyscallResult::Ok(()) + } + #[inline(always)] + fn size() -> u8 { + starknet::Store::::size() + } +} + +#[derive(Drop, Copy)] +pub struct Ibad_model_unexpected_arg_with_valueLibraryDispatcherSubPointers { + pub class_hash: starknet::storage::StoragePointer, +} +impl Ibad_model_unexpected_arg_with_valueLibraryDispatcherSubPointersImpl of starknet::storage::SubPointers { + type SubPointersType = Ibad_model_unexpected_arg_with_valueLibraryDispatcherSubPointers; + fn sub_pointers(self: starknet::storage::StoragePointer) -> Ibad_model_unexpected_arg_with_valueLibraryDispatcherSubPointers { + let base_address = self.__storage_pointer_address__; + let mut current_offset = self.__storage_pointer_offset__; + let class_hash_value = starknet::storage::StoragePointer { + __storage_pointer_address__: base_address, + __storage_pointer_offset__: current_offset, + }; + Ibad_model_unexpected_arg_with_valueLibraryDispatcherSubPointers { + class_hash: class_hash_value, + } + } +} +#[derive(Drop, Copy)] +pub struct Ibad_model_unexpected_arg_with_valueLibraryDispatcherSubPointersMut { + pub class_hash: starknet::storage::StoragePointer>, +} +impl Ibad_model_unexpected_arg_with_valueLibraryDispatcherSubPointersMutImpl of starknet::storage::SubPointersMut { + type SubPointersType = Ibad_model_unexpected_arg_with_valueLibraryDispatcherSubPointersMut; + fn sub_pointers_mut(self: starknet::storage::StoragePointer>) -> Ibad_model_unexpected_arg_with_valueLibraryDispatcherSubPointersMut { + let base_address = self.__storage_pointer_address__; + let mut current_offset = self.__storage_pointer_offset__; + let class_hash_value = starknet::storage::StoragePointer { + __storage_pointer_address__: base_address, + __storage_pointer_offset__: current_offset, + }; + Ibad_model_unexpected_arg_with_valueLibraryDispatcherSubPointersMut { + class_hash: class_hash_value, + } + } +} +impl Ibad_model_unexpected_arg_with_valueSafeLibraryDispatcherCopy of core::traits::Copy::; +impl Ibad_model_unexpected_arg_with_valueSafeLibraryDispatcherDrop of core::traits::Drop::; +impl Ibad_model_unexpected_arg_with_valueSafeLibraryDispatcherSerde of core::serde::Serde:: { + fn serialize(self: @Ibad_model_unexpected_arg_with_valueSafeLibraryDispatcher, ref output: core::array::Array) { + core::serde::Serde::serialize(self.class_hash, ref output) + } + fn deserialize(ref serialized: core::array::Span) -> core::option::Option { + core::option::Option::Some(Ibad_model_unexpected_arg_with_valueSafeLibraryDispatcher { + class_hash: core::serde::Serde::deserialize(ref serialized)?, + }) + } +} +impl StoreIbad_model_unexpected_arg_with_valueSafeLibraryDispatcher of starknet::Store:: { + fn read(address_domain: u32, base: starknet::storage_access::StorageBaseAddress) -> starknet::SyscallResult { + let class_hash = starknet::Store::::read(address_domain, base)?; + starknet::SyscallResult::Ok( + Ibad_model_unexpected_arg_with_valueSafeLibraryDispatcher { + class_hash, + } + ) + } + fn write(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, value: Ibad_model_unexpected_arg_with_valueSafeLibraryDispatcher) -> starknet::SyscallResult<()> { + starknet::Store::::write(address_domain, base, value.class_hash)?; + starknet::SyscallResult::Ok(()) + } + fn read_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8) -> starknet::SyscallResult { + let class_hash = starknet::Store::::read_at_offset(address_domain, base, offset)?; + starknet::SyscallResult::Ok( + Ibad_model_unexpected_arg_with_valueSafeLibraryDispatcher { + class_hash, + } + ) + } + #[inline(always)] + fn write_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8, value: Ibad_model_unexpected_arg_with_valueSafeLibraryDispatcher) -> starknet::SyscallResult<()> { + starknet::Store::::write_at_offset(address_domain, base, offset, value.class_hash)?; + starknet::SyscallResult::Ok(()) + } + #[inline(always)] + fn size() -> u8 { + starknet::Store::::size() + } +} + +#[derive(Drop, Copy)] +pub struct Ibad_model_unexpected_arg_with_valueSafeLibraryDispatcherSubPointers { + pub class_hash: starknet::storage::StoragePointer, +} +impl Ibad_model_unexpected_arg_with_valueSafeLibraryDispatcherSubPointersImpl of starknet::storage::SubPointers { + type SubPointersType = Ibad_model_unexpected_arg_with_valueSafeLibraryDispatcherSubPointers; + fn sub_pointers(self: starknet::storage::StoragePointer) -> Ibad_model_unexpected_arg_with_valueSafeLibraryDispatcherSubPointers { + let base_address = self.__storage_pointer_address__; + let mut current_offset = self.__storage_pointer_offset__; + let class_hash_value = starknet::storage::StoragePointer { + __storage_pointer_address__: base_address, + __storage_pointer_offset__: current_offset, + }; + Ibad_model_unexpected_arg_with_valueSafeLibraryDispatcherSubPointers { + class_hash: class_hash_value, + } + } +} +#[derive(Drop, Copy)] +pub struct Ibad_model_unexpected_arg_with_valueSafeLibraryDispatcherSubPointersMut { + pub class_hash: starknet::storage::StoragePointer>, +} +impl Ibad_model_unexpected_arg_with_valueSafeLibraryDispatcherSubPointersMutImpl of starknet::storage::SubPointersMut { + type SubPointersType = Ibad_model_unexpected_arg_with_valueSafeLibraryDispatcherSubPointersMut; + fn sub_pointers_mut(self: starknet::storage::StoragePointer>) -> Ibad_model_unexpected_arg_with_valueSafeLibraryDispatcherSubPointersMut { + let base_address = self.__storage_pointer_address__; + let mut current_offset = self.__storage_pointer_offset__; + let class_hash_value = starknet::storage::StoragePointer { + __storage_pointer_address__: base_address, + __storage_pointer_offset__: current_offset, + }; + Ibad_model_unexpected_arg_with_valueSafeLibraryDispatcherSubPointersMut { + class_hash: class_hash_value, + } + } +} +impl Ibad_model_unexpected_arg_with_valueSafeDispatcherCopy of core::traits::Copy::; +impl Ibad_model_unexpected_arg_with_valueSafeDispatcherDrop of core::traits::Drop::; +impl Ibad_model_unexpected_arg_with_valueSafeDispatcherSerde of core::serde::Serde:: { + fn serialize(self: @Ibad_model_unexpected_arg_with_valueSafeDispatcher, ref output: core::array::Array) { + core::serde::Serde::serialize(self.contract_address, ref output) + } + fn deserialize(ref serialized: core::array::Span) -> core::option::Option { + core::option::Option::Some(Ibad_model_unexpected_arg_with_valueSafeDispatcher { + contract_address: core::serde::Serde::deserialize(ref serialized)?, + }) + } +} +impl StoreIbad_model_unexpected_arg_with_valueSafeDispatcher of starknet::Store:: { + fn read(address_domain: u32, base: starknet::storage_access::StorageBaseAddress) -> starknet::SyscallResult { + let contract_address = starknet::Store::::read(address_domain, base)?; + starknet::SyscallResult::Ok( + Ibad_model_unexpected_arg_with_valueSafeDispatcher { + contract_address, + } + ) + } + fn write(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, value: Ibad_model_unexpected_arg_with_valueSafeDispatcher) -> starknet::SyscallResult<()> { + starknet::Store::::write(address_domain, base, value.contract_address)?; + starknet::SyscallResult::Ok(()) + } + fn read_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8) -> starknet::SyscallResult { + let contract_address = starknet::Store::::read_at_offset(address_domain, base, offset)?; + starknet::SyscallResult::Ok( + Ibad_model_unexpected_arg_with_valueSafeDispatcher { + contract_address, + } + ) + } + #[inline(always)] + fn write_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8, value: Ibad_model_unexpected_arg_with_valueSafeDispatcher) -> starknet::SyscallResult<()> { + starknet::Store::::write_at_offset(address_domain, base, offset, value.contract_address)?; + starknet::SyscallResult::Ok(()) + } + #[inline(always)] + fn size() -> u8 { + starknet::Store::::size() + } +} + +#[derive(Drop, Copy)] +pub struct Ibad_model_unexpected_arg_with_valueSafeDispatcherSubPointers { + pub contract_address: starknet::storage::StoragePointer, +} +impl Ibad_model_unexpected_arg_with_valueSafeDispatcherSubPointersImpl of starknet::storage::SubPointers { + type SubPointersType = Ibad_model_unexpected_arg_with_valueSafeDispatcherSubPointers; + fn sub_pointers(self: starknet::storage::StoragePointer) -> Ibad_model_unexpected_arg_with_valueSafeDispatcherSubPointers { + let base_address = self.__storage_pointer_address__; + let mut current_offset = self.__storage_pointer_offset__; + let contract_address_value = starknet::storage::StoragePointer { + __storage_pointer_address__: base_address, + __storage_pointer_offset__: current_offset, + }; + Ibad_model_unexpected_arg_with_valueSafeDispatcherSubPointers { + contract_address: contract_address_value, + } + } +} +#[derive(Drop, Copy)] +pub struct Ibad_model_unexpected_arg_with_valueSafeDispatcherSubPointersMut { + pub contract_address: starknet::storage::StoragePointer>, +} +impl Ibad_model_unexpected_arg_with_valueSafeDispatcherSubPointersMutImpl of starknet::storage::SubPointersMut { + type SubPointersType = Ibad_model_unexpected_arg_with_valueSafeDispatcherSubPointersMut; + fn sub_pointers_mut(self: starknet::storage::StoragePointer>) -> Ibad_model_unexpected_arg_with_valueSafeDispatcherSubPointersMut { + let base_address = self.__storage_pointer_address__; + let mut current_offset = self.__storage_pointer_offset__; + let contract_address_value = starknet::storage::StoragePointer { + __storage_pointer_address__: base_address, + __storage_pointer_offset__: current_offset, + }; + Ibad_model_unexpected_arg_with_valueSafeDispatcherSubPointersMut { + contract_address: contract_address_value, + } + } +} +impl Ibad_model_unexpected_argDispatcherCopy of core::traits::Copy::; +impl Ibad_model_unexpected_argDispatcherDrop of core::traits::Drop::; +impl Ibad_model_unexpected_argDispatcherSerde of core::serde::Serde:: { + fn serialize(self: @Ibad_model_unexpected_argDispatcher, ref output: core::array::Array) { + core::serde::Serde::serialize(self.contract_address, ref output) + } + fn deserialize(ref serialized: core::array::Span) -> core::option::Option { + core::option::Option::Some(Ibad_model_unexpected_argDispatcher { + contract_address: core::serde::Serde::deserialize(ref serialized)?, + }) + } +} +impl StoreIbad_model_unexpected_argDispatcher of starknet::Store:: { + fn read(address_domain: u32, base: starknet::storage_access::StorageBaseAddress) -> starknet::SyscallResult { + let contract_address = starknet::Store::::read(address_domain, base)?; + starknet::SyscallResult::Ok( + Ibad_model_unexpected_argDispatcher { + contract_address, + } + ) + } + fn write(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, value: Ibad_model_unexpected_argDispatcher) -> starknet::SyscallResult<()> { + starknet::Store::::write(address_domain, base, value.contract_address)?; + starknet::SyscallResult::Ok(()) + } + fn read_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8) -> starknet::SyscallResult { + let contract_address = starknet::Store::::read_at_offset(address_domain, base, offset)?; + starknet::SyscallResult::Ok( + Ibad_model_unexpected_argDispatcher { + contract_address, + } + ) + } + #[inline(always)] + fn write_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8, value: Ibad_model_unexpected_argDispatcher) -> starknet::SyscallResult<()> { + starknet::Store::::write_at_offset(address_domain, base, offset, value.contract_address)?; + starknet::SyscallResult::Ok(()) + } + #[inline(always)] + fn size() -> u8 { + starknet::Store::::size() + } +} + +#[derive(Drop, Copy)] +pub struct Ibad_model_unexpected_argDispatcherSubPointers { + pub contract_address: starknet::storage::StoragePointer, +} +impl Ibad_model_unexpected_argDispatcherSubPointersImpl of starknet::storage::SubPointers { + type SubPointersType = Ibad_model_unexpected_argDispatcherSubPointers; + fn sub_pointers(self: starknet::storage::StoragePointer) -> Ibad_model_unexpected_argDispatcherSubPointers { + let base_address = self.__storage_pointer_address__; + let mut current_offset = self.__storage_pointer_offset__; + let contract_address_value = starknet::storage::StoragePointer { + __storage_pointer_address__: base_address, + __storage_pointer_offset__: current_offset, + }; + Ibad_model_unexpected_argDispatcherSubPointers { + contract_address: contract_address_value, + } + } +} +#[derive(Drop, Copy)] +pub struct Ibad_model_unexpected_argDispatcherSubPointersMut { + pub contract_address: starknet::storage::StoragePointer>, +} +impl Ibad_model_unexpected_argDispatcherSubPointersMutImpl of starknet::storage::SubPointersMut { + type SubPointersType = Ibad_model_unexpected_argDispatcherSubPointersMut; + fn sub_pointers_mut(self: starknet::storage::StoragePointer>) -> Ibad_model_unexpected_argDispatcherSubPointersMut { + let base_address = self.__storage_pointer_address__; + let mut current_offset = self.__storage_pointer_offset__; + let contract_address_value = starknet::storage::StoragePointer { + __storage_pointer_address__: base_address, + __storage_pointer_offset__: current_offset, + }; + Ibad_model_unexpected_argDispatcherSubPointersMut { + contract_address: contract_address_value, + } + } +} +impl Ibad_model_unexpected_argLibraryDispatcherCopy of core::traits::Copy::; +impl Ibad_model_unexpected_argLibraryDispatcherDrop of core::traits::Drop::; +impl Ibad_model_unexpected_argLibraryDispatcherSerde of core::serde::Serde:: { + fn serialize(self: @Ibad_model_unexpected_argLibraryDispatcher, ref output: core::array::Array) { + core::serde::Serde::serialize(self.class_hash, ref output) + } + fn deserialize(ref serialized: core::array::Span) -> core::option::Option { + core::option::Option::Some(Ibad_model_unexpected_argLibraryDispatcher { + class_hash: core::serde::Serde::deserialize(ref serialized)?, + }) + } +} +impl StoreIbad_model_unexpected_argLibraryDispatcher of starknet::Store:: { + fn read(address_domain: u32, base: starknet::storage_access::StorageBaseAddress) -> starknet::SyscallResult { + let class_hash = starknet::Store::::read(address_domain, base)?; + starknet::SyscallResult::Ok( + Ibad_model_unexpected_argLibraryDispatcher { + class_hash, + } + ) + } + fn write(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, value: Ibad_model_unexpected_argLibraryDispatcher) -> starknet::SyscallResult<()> { + starknet::Store::::write(address_domain, base, value.class_hash)?; + starknet::SyscallResult::Ok(()) + } + fn read_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8) -> starknet::SyscallResult { + let class_hash = starknet::Store::::read_at_offset(address_domain, base, offset)?; + starknet::SyscallResult::Ok( + Ibad_model_unexpected_argLibraryDispatcher { + class_hash, + } + ) + } + #[inline(always)] + fn write_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8, value: Ibad_model_unexpected_argLibraryDispatcher) -> starknet::SyscallResult<()> { + starknet::Store::::write_at_offset(address_domain, base, offset, value.class_hash)?; + starknet::SyscallResult::Ok(()) + } + #[inline(always)] + fn size() -> u8 { + starknet::Store::::size() + } +} + +#[derive(Drop, Copy)] +pub struct Ibad_model_unexpected_argLibraryDispatcherSubPointers { + pub class_hash: starknet::storage::StoragePointer, +} +impl Ibad_model_unexpected_argLibraryDispatcherSubPointersImpl of starknet::storage::SubPointers { + type SubPointersType = Ibad_model_unexpected_argLibraryDispatcherSubPointers; + fn sub_pointers(self: starknet::storage::StoragePointer) -> Ibad_model_unexpected_argLibraryDispatcherSubPointers { + let base_address = self.__storage_pointer_address__; + let mut current_offset = self.__storage_pointer_offset__; + let class_hash_value = starknet::storage::StoragePointer { + __storage_pointer_address__: base_address, + __storage_pointer_offset__: current_offset, + }; + Ibad_model_unexpected_argLibraryDispatcherSubPointers { + class_hash: class_hash_value, + } + } +} +#[derive(Drop, Copy)] +pub struct Ibad_model_unexpected_argLibraryDispatcherSubPointersMut { + pub class_hash: starknet::storage::StoragePointer>, +} +impl Ibad_model_unexpected_argLibraryDispatcherSubPointersMutImpl of starknet::storage::SubPointersMut { + type SubPointersType = Ibad_model_unexpected_argLibraryDispatcherSubPointersMut; + fn sub_pointers_mut(self: starknet::storage::StoragePointer>) -> Ibad_model_unexpected_argLibraryDispatcherSubPointersMut { + let base_address = self.__storage_pointer_address__; + let mut current_offset = self.__storage_pointer_offset__; + let class_hash_value = starknet::storage::StoragePointer { + __storage_pointer_address__: base_address, + __storage_pointer_offset__: current_offset, + }; + Ibad_model_unexpected_argLibraryDispatcherSubPointersMut { + class_hash: class_hash_value, + } + } +} +impl Ibad_model_unexpected_argSafeLibraryDispatcherCopy of core::traits::Copy::; +impl Ibad_model_unexpected_argSafeLibraryDispatcherDrop of core::traits::Drop::; +impl Ibad_model_unexpected_argSafeLibraryDispatcherSerde of core::serde::Serde:: { + fn serialize(self: @Ibad_model_unexpected_argSafeLibraryDispatcher, ref output: core::array::Array) { + core::serde::Serde::serialize(self.class_hash, ref output) + } + fn deserialize(ref serialized: core::array::Span) -> core::option::Option { + core::option::Option::Some(Ibad_model_unexpected_argSafeLibraryDispatcher { + class_hash: core::serde::Serde::deserialize(ref serialized)?, + }) + } +} +impl StoreIbad_model_unexpected_argSafeLibraryDispatcher of starknet::Store:: { + fn read(address_domain: u32, base: starknet::storage_access::StorageBaseAddress) -> starknet::SyscallResult { + let class_hash = starknet::Store::::read(address_domain, base)?; + starknet::SyscallResult::Ok( + Ibad_model_unexpected_argSafeLibraryDispatcher { + class_hash, + } + ) + } + fn write(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, value: Ibad_model_unexpected_argSafeLibraryDispatcher) -> starknet::SyscallResult<()> { + starknet::Store::::write(address_domain, base, value.class_hash)?; + starknet::SyscallResult::Ok(()) + } + fn read_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8) -> starknet::SyscallResult { + let class_hash = starknet::Store::::read_at_offset(address_domain, base, offset)?; + starknet::SyscallResult::Ok( + Ibad_model_unexpected_argSafeLibraryDispatcher { + class_hash, + } + ) + } + #[inline(always)] + fn write_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8, value: Ibad_model_unexpected_argSafeLibraryDispatcher) -> starknet::SyscallResult<()> { + starknet::Store::::write_at_offset(address_domain, base, offset, value.class_hash)?; + starknet::SyscallResult::Ok(()) + } + #[inline(always)] + fn size() -> u8 { + starknet::Store::::size() + } +} + +#[derive(Drop, Copy)] +pub struct Ibad_model_unexpected_argSafeLibraryDispatcherSubPointers { + pub class_hash: starknet::storage::StoragePointer, +} +impl Ibad_model_unexpected_argSafeLibraryDispatcherSubPointersImpl of starknet::storage::SubPointers { + type SubPointersType = Ibad_model_unexpected_argSafeLibraryDispatcherSubPointers; + fn sub_pointers(self: starknet::storage::StoragePointer) -> Ibad_model_unexpected_argSafeLibraryDispatcherSubPointers { + let base_address = self.__storage_pointer_address__; + let mut current_offset = self.__storage_pointer_offset__; + let class_hash_value = starknet::storage::StoragePointer { + __storage_pointer_address__: base_address, + __storage_pointer_offset__: current_offset, + }; + Ibad_model_unexpected_argSafeLibraryDispatcherSubPointers { + class_hash: class_hash_value, + } + } +} +#[derive(Drop, Copy)] +pub struct Ibad_model_unexpected_argSafeLibraryDispatcherSubPointersMut { + pub class_hash: starknet::storage::StoragePointer>, +} +impl Ibad_model_unexpected_argSafeLibraryDispatcherSubPointersMutImpl of starknet::storage::SubPointersMut { + type SubPointersType = Ibad_model_unexpected_argSafeLibraryDispatcherSubPointersMut; + fn sub_pointers_mut(self: starknet::storage::StoragePointer>) -> Ibad_model_unexpected_argSafeLibraryDispatcherSubPointersMut { + let base_address = self.__storage_pointer_address__; + let mut current_offset = self.__storage_pointer_offset__; + let class_hash_value = starknet::storage::StoragePointer { + __storage_pointer_address__: base_address, + __storage_pointer_offset__: current_offset, + }; + Ibad_model_unexpected_argSafeLibraryDispatcherSubPointersMut { + class_hash: class_hash_value, + } + } +} +impl Ibad_model_unexpected_argSafeDispatcherCopy of core::traits::Copy::; +impl Ibad_model_unexpected_argSafeDispatcherDrop of core::traits::Drop::; +impl Ibad_model_unexpected_argSafeDispatcherSerde of core::serde::Serde:: { + fn serialize(self: @Ibad_model_unexpected_argSafeDispatcher, ref output: core::array::Array) { + core::serde::Serde::serialize(self.contract_address, ref output) + } + fn deserialize(ref serialized: core::array::Span) -> core::option::Option { + core::option::Option::Some(Ibad_model_unexpected_argSafeDispatcher { + contract_address: core::serde::Serde::deserialize(ref serialized)?, + }) + } +} +impl StoreIbad_model_unexpected_argSafeDispatcher of starknet::Store:: { + fn read(address_domain: u32, base: starknet::storage_access::StorageBaseAddress) -> starknet::SyscallResult { + let contract_address = starknet::Store::::read(address_domain, base)?; + starknet::SyscallResult::Ok( + Ibad_model_unexpected_argSafeDispatcher { + contract_address, + } + ) + } + fn write(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, value: Ibad_model_unexpected_argSafeDispatcher) -> starknet::SyscallResult<()> { + starknet::Store::::write(address_domain, base, value.contract_address)?; + starknet::SyscallResult::Ok(()) + } + fn read_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8) -> starknet::SyscallResult { + let contract_address = starknet::Store::::read_at_offset(address_domain, base, offset)?; + starknet::SyscallResult::Ok( + Ibad_model_unexpected_argSafeDispatcher { + contract_address, + } + ) + } + #[inline(always)] + fn write_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8, value: Ibad_model_unexpected_argSafeDispatcher) -> starknet::SyscallResult<()> { + starknet::Store::::write_at_offset(address_domain, base, offset, value.contract_address)?; + starknet::SyscallResult::Ok(()) + } + #[inline(always)] + fn size() -> u8 { + starknet::Store::::size() + } +} + +#[derive(Drop, Copy)] +pub struct Ibad_model_unexpected_argSafeDispatcherSubPointers { + pub contract_address: starknet::storage::StoragePointer, +} +impl Ibad_model_unexpected_argSafeDispatcherSubPointersImpl of starknet::storage::SubPointers { + type SubPointersType = Ibad_model_unexpected_argSafeDispatcherSubPointers; + fn sub_pointers(self: starknet::storage::StoragePointer) -> Ibad_model_unexpected_argSafeDispatcherSubPointers { + let base_address = self.__storage_pointer_address__; + let mut current_offset = self.__storage_pointer_offset__; + let contract_address_value = starknet::storage::StoragePointer { + __storage_pointer_address__: base_address, + __storage_pointer_offset__: current_offset, + }; + Ibad_model_unexpected_argSafeDispatcherSubPointers { + contract_address: contract_address_value, + } + } +} +#[derive(Drop, Copy)] +pub struct Ibad_model_unexpected_argSafeDispatcherSubPointersMut { + pub contract_address: starknet::storage::StoragePointer>, +} +impl Ibad_model_unexpected_argSafeDispatcherSubPointersMutImpl of starknet::storage::SubPointersMut { + type SubPointersType = Ibad_model_unexpected_argSafeDispatcherSubPointersMut; + fn sub_pointers_mut(self: starknet::storage::StoragePointer>) -> Ibad_model_unexpected_argSafeDispatcherSubPointersMut { + let base_address = self.__storage_pointer_address__; + let mut current_offset = self.__storage_pointer_offset__; + let contract_address_value = starknet::storage::StoragePointer { + __storage_pointer_address__: base_address, + __storage_pointer_offset__: current_offset, + }; + Ibad_model_unexpected_argSafeDispatcherSubPointersMut { + contract_address: contract_address_value, + } + } +} +impl Ibad_model_not_supported_versionDispatcherCopy of core::traits::Copy::; +impl Ibad_model_not_supported_versionDispatcherDrop of core::traits::Drop::; +impl Ibad_model_not_supported_versionDispatcherSerde of core::serde::Serde:: { + fn serialize(self: @Ibad_model_not_supported_versionDispatcher, ref output: core::array::Array) { + core::serde::Serde::serialize(self.contract_address, ref output) + } + fn deserialize(ref serialized: core::array::Span) -> core::option::Option { + core::option::Option::Some(Ibad_model_not_supported_versionDispatcher { + contract_address: core::serde::Serde::deserialize(ref serialized)?, + }) + } +} +impl StoreIbad_model_not_supported_versionDispatcher of starknet::Store:: { + fn read(address_domain: u32, base: starknet::storage_access::StorageBaseAddress) -> starknet::SyscallResult { + let contract_address = starknet::Store::::read(address_domain, base)?; + starknet::SyscallResult::Ok( + Ibad_model_not_supported_versionDispatcher { + contract_address, + } + ) + } + fn write(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, value: Ibad_model_not_supported_versionDispatcher) -> starknet::SyscallResult<()> { + starknet::Store::::write(address_domain, base, value.contract_address)?; + starknet::SyscallResult::Ok(()) + } + fn read_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8) -> starknet::SyscallResult { + let contract_address = starknet::Store::::read_at_offset(address_domain, base, offset)?; + starknet::SyscallResult::Ok( + Ibad_model_not_supported_versionDispatcher { + contract_address, + } + ) + } + #[inline(always)] + fn write_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8, value: Ibad_model_not_supported_versionDispatcher) -> starknet::SyscallResult<()> { + starknet::Store::::write_at_offset(address_domain, base, offset, value.contract_address)?; + starknet::SyscallResult::Ok(()) + } + #[inline(always)] + fn size() -> u8 { + starknet::Store::::size() + } +} + +#[derive(Drop, Copy)] +pub struct Ibad_model_not_supported_versionDispatcherSubPointers { + pub contract_address: starknet::storage::StoragePointer, +} +impl Ibad_model_not_supported_versionDispatcherSubPointersImpl of starknet::storage::SubPointers { + type SubPointersType = Ibad_model_not_supported_versionDispatcherSubPointers; + fn sub_pointers(self: starknet::storage::StoragePointer) -> Ibad_model_not_supported_versionDispatcherSubPointers { + let base_address = self.__storage_pointer_address__; + let mut current_offset = self.__storage_pointer_offset__; + let contract_address_value = starknet::storage::StoragePointer { + __storage_pointer_address__: base_address, + __storage_pointer_offset__: current_offset, + }; + Ibad_model_not_supported_versionDispatcherSubPointers { + contract_address: contract_address_value, + } + } +} +#[derive(Drop, Copy)] +pub struct Ibad_model_not_supported_versionDispatcherSubPointersMut { + pub contract_address: starknet::storage::StoragePointer>, +} +impl Ibad_model_not_supported_versionDispatcherSubPointersMutImpl of starknet::storage::SubPointersMut { + type SubPointersType = Ibad_model_not_supported_versionDispatcherSubPointersMut; + fn sub_pointers_mut(self: starknet::storage::StoragePointer>) -> Ibad_model_not_supported_versionDispatcherSubPointersMut { + let base_address = self.__storage_pointer_address__; + let mut current_offset = self.__storage_pointer_offset__; + let contract_address_value = starknet::storage::StoragePointer { + __storage_pointer_address__: base_address, + __storage_pointer_offset__: current_offset, + }; + Ibad_model_not_supported_versionDispatcherSubPointersMut { + contract_address: contract_address_value, + } + } +} +impl Ibad_model_not_supported_versionLibraryDispatcherCopy of core::traits::Copy::; +impl Ibad_model_not_supported_versionLibraryDispatcherDrop of core::traits::Drop::; +impl Ibad_model_not_supported_versionLibraryDispatcherSerde of core::serde::Serde:: { + fn serialize(self: @Ibad_model_not_supported_versionLibraryDispatcher, ref output: core::array::Array) { + core::serde::Serde::serialize(self.class_hash, ref output) + } + fn deserialize(ref serialized: core::array::Span) -> core::option::Option { + core::option::Option::Some(Ibad_model_not_supported_versionLibraryDispatcher { + class_hash: core::serde::Serde::deserialize(ref serialized)?, + }) + } +} +impl StoreIbad_model_not_supported_versionLibraryDispatcher of starknet::Store:: { + fn read(address_domain: u32, base: starknet::storage_access::StorageBaseAddress) -> starknet::SyscallResult { + let class_hash = starknet::Store::::read(address_domain, base)?; + starknet::SyscallResult::Ok( + Ibad_model_not_supported_versionLibraryDispatcher { + class_hash, + } + ) + } + fn write(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, value: Ibad_model_not_supported_versionLibraryDispatcher) -> starknet::SyscallResult<()> { + starknet::Store::::write(address_domain, base, value.class_hash)?; + starknet::SyscallResult::Ok(()) + } + fn read_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8) -> starknet::SyscallResult { + let class_hash = starknet::Store::::read_at_offset(address_domain, base, offset)?; + starknet::SyscallResult::Ok( + Ibad_model_not_supported_versionLibraryDispatcher { + class_hash, + } + ) + } + #[inline(always)] + fn write_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8, value: Ibad_model_not_supported_versionLibraryDispatcher) -> starknet::SyscallResult<()> { + starknet::Store::::write_at_offset(address_domain, base, offset, value.class_hash)?; + starknet::SyscallResult::Ok(()) + } + #[inline(always)] + fn size() -> u8 { + starknet::Store::::size() + } +} + +#[derive(Drop, Copy)] +pub struct Ibad_model_not_supported_versionLibraryDispatcherSubPointers { + pub class_hash: starknet::storage::StoragePointer, +} +impl Ibad_model_not_supported_versionLibraryDispatcherSubPointersImpl of starknet::storage::SubPointers { + type SubPointersType = Ibad_model_not_supported_versionLibraryDispatcherSubPointers; + fn sub_pointers(self: starknet::storage::StoragePointer) -> Ibad_model_not_supported_versionLibraryDispatcherSubPointers { + let base_address = self.__storage_pointer_address__; + let mut current_offset = self.__storage_pointer_offset__; + let class_hash_value = starknet::storage::StoragePointer { + __storage_pointer_address__: base_address, + __storage_pointer_offset__: current_offset, + }; + Ibad_model_not_supported_versionLibraryDispatcherSubPointers { + class_hash: class_hash_value, + } + } +} +#[derive(Drop, Copy)] +pub struct Ibad_model_not_supported_versionLibraryDispatcherSubPointersMut { + pub class_hash: starknet::storage::StoragePointer>, +} +impl Ibad_model_not_supported_versionLibraryDispatcherSubPointersMutImpl of starknet::storage::SubPointersMut { + type SubPointersType = Ibad_model_not_supported_versionLibraryDispatcherSubPointersMut; + fn sub_pointers_mut(self: starknet::storage::StoragePointer>) -> Ibad_model_not_supported_versionLibraryDispatcherSubPointersMut { + let base_address = self.__storage_pointer_address__; + let mut current_offset = self.__storage_pointer_offset__; + let class_hash_value = starknet::storage::StoragePointer { + __storage_pointer_address__: base_address, + __storage_pointer_offset__: current_offset, + }; + Ibad_model_not_supported_versionLibraryDispatcherSubPointersMut { + class_hash: class_hash_value, + } + } +} +impl Ibad_model_not_supported_versionSafeLibraryDispatcherCopy of core::traits::Copy::; +impl Ibad_model_not_supported_versionSafeLibraryDispatcherDrop of core::traits::Drop::; +impl Ibad_model_not_supported_versionSafeLibraryDispatcherSerde of core::serde::Serde:: { + fn serialize(self: @Ibad_model_not_supported_versionSafeLibraryDispatcher, ref output: core::array::Array) { + core::serde::Serde::serialize(self.class_hash, ref output) + } + fn deserialize(ref serialized: core::array::Span) -> core::option::Option { + core::option::Option::Some(Ibad_model_not_supported_versionSafeLibraryDispatcher { + class_hash: core::serde::Serde::deserialize(ref serialized)?, + }) + } +} +impl StoreIbad_model_not_supported_versionSafeLibraryDispatcher of starknet::Store:: { + fn read(address_domain: u32, base: starknet::storage_access::StorageBaseAddress) -> starknet::SyscallResult { + let class_hash = starknet::Store::::read(address_domain, base)?; + starknet::SyscallResult::Ok( + Ibad_model_not_supported_versionSafeLibraryDispatcher { + class_hash, + } + ) + } + fn write(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, value: Ibad_model_not_supported_versionSafeLibraryDispatcher) -> starknet::SyscallResult<()> { + starknet::Store::::write(address_domain, base, value.class_hash)?; + starknet::SyscallResult::Ok(()) + } + fn read_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8) -> starknet::SyscallResult { + let class_hash = starknet::Store::::read_at_offset(address_domain, base, offset)?; + starknet::SyscallResult::Ok( + Ibad_model_not_supported_versionSafeLibraryDispatcher { + class_hash, + } + ) + } + #[inline(always)] + fn write_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8, value: Ibad_model_not_supported_versionSafeLibraryDispatcher) -> starknet::SyscallResult<()> { + starknet::Store::::write_at_offset(address_domain, base, offset, value.class_hash)?; + starknet::SyscallResult::Ok(()) + } + #[inline(always)] + fn size() -> u8 { + starknet::Store::::size() + } +} + +#[derive(Drop, Copy)] +pub struct Ibad_model_not_supported_versionSafeLibraryDispatcherSubPointers { + pub class_hash: starknet::storage::StoragePointer, +} +impl Ibad_model_not_supported_versionSafeLibraryDispatcherSubPointersImpl of starknet::storage::SubPointers { + type SubPointersType = Ibad_model_not_supported_versionSafeLibraryDispatcherSubPointers; + fn sub_pointers(self: starknet::storage::StoragePointer) -> Ibad_model_not_supported_versionSafeLibraryDispatcherSubPointers { + let base_address = self.__storage_pointer_address__; + let mut current_offset = self.__storage_pointer_offset__; + let class_hash_value = starknet::storage::StoragePointer { + __storage_pointer_address__: base_address, + __storage_pointer_offset__: current_offset, + }; + Ibad_model_not_supported_versionSafeLibraryDispatcherSubPointers { + class_hash: class_hash_value, + } + } +} +#[derive(Drop, Copy)] +pub struct Ibad_model_not_supported_versionSafeLibraryDispatcherSubPointersMut { + pub class_hash: starknet::storage::StoragePointer>, +} +impl Ibad_model_not_supported_versionSafeLibraryDispatcherSubPointersMutImpl of starknet::storage::SubPointersMut { + type SubPointersType = Ibad_model_not_supported_versionSafeLibraryDispatcherSubPointersMut; + fn sub_pointers_mut(self: starknet::storage::StoragePointer>) -> Ibad_model_not_supported_versionSafeLibraryDispatcherSubPointersMut { + let base_address = self.__storage_pointer_address__; + let mut current_offset = self.__storage_pointer_offset__; + let class_hash_value = starknet::storage::StoragePointer { + __storage_pointer_address__: base_address, + __storage_pointer_offset__: current_offset, + }; + Ibad_model_not_supported_versionSafeLibraryDispatcherSubPointersMut { + class_hash: class_hash_value, + } + } +} +impl Ibad_model_not_supported_versionSafeDispatcherCopy of core::traits::Copy::; +impl Ibad_model_not_supported_versionSafeDispatcherDrop of core::traits::Drop::; +impl Ibad_model_not_supported_versionSafeDispatcherSerde of core::serde::Serde:: { + fn serialize(self: @Ibad_model_not_supported_versionSafeDispatcher, ref output: core::array::Array) { + core::serde::Serde::serialize(self.contract_address, ref output) + } + fn deserialize(ref serialized: core::array::Span) -> core::option::Option { + core::option::Option::Some(Ibad_model_not_supported_versionSafeDispatcher { + contract_address: core::serde::Serde::deserialize(ref serialized)?, + }) + } +} +impl StoreIbad_model_not_supported_versionSafeDispatcher of starknet::Store:: { + fn read(address_domain: u32, base: starknet::storage_access::StorageBaseAddress) -> starknet::SyscallResult { + let contract_address = starknet::Store::::read(address_domain, base)?; + starknet::SyscallResult::Ok( + Ibad_model_not_supported_versionSafeDispatcher { + contract_address, + } + ) + } + fn write(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, value: Ibad_model_not_supported_versionSafeDispatcher) -> starknet::SyscallResult<()> { + starknet::Store::::write(address_domain, base, value.contract_address)?; + starknet::SyscallResult::Ok(()) + } + fn read_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8) -> starknet::SyscallResult { + let contract_address = starknet::Store::::read_at_offset(address_domain, base, offset)?; + starknet::SyscallResult::Ok( + Ibad_model_not_supported_versionSafeDispatcher { + contract_address, + } + ) + } + #[inline(always)] + fn write_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8, value: Ibad_model_not_supported_versionSafeDispatcher) -> starknet::SyscallResult<()> { + starknet::Store::::write_at_offset(address_domain, base, offset, value.contract_address)?; + starknet::SyscallResult::Ok(()) + } + #[inline(always)] + fn size() -> u8 { + starknet::Store::::size() + } +} + +#[derive(Drop, Copy)] +pub struct Ibad_model_not_supported_versionSafeDispatcherSubPointers { + pub contract_address: starknet::storage::StoragePointer, +} +impl Ibad_model_not_supported_versionSafeDispatcherSubPointersImpl of starknet::storage::SubPointers { + type SubPointersType = Ibad_model_not_supported_versionSafeDispatcherSubPointers; + fn sub_pointers(self: starknet::storage::StoragePointer) -> Ibad_model_not_supported_versionSafeDispatcherSubPointers { + let base_address = self.__storage_pointer_address__; + let mut current_offset = self.__storage_pointer_offset__; + let contract_address_value = starknet::storage::StoragePointer { + __storage_pointer_address__: base_address, + __storage_pointer_offset__: current_offset, + }; + Ibad_model_not_supported_versionSafeDispatcherSubPointers { + contract_address: contract_address_value, + } + } +} +#[derive(Drop, Copy)] +pub struct Ibad_model_not_supported_versionSafeDispatcherSubPointersMut { + pub contract_address: starknet::storage::StoragePointer>, +} +impl Ibad_model_not_supported_versionSafeDispatcherSubPointersMutImpl of starknet::storage::SubPointersMut { + type SubPointersType = Ibad_model_not_supported_versionSafeDispatcherSubPointersMut; + fn sub_pointers_mut(self: starknet::storage::StoragePointer>) -> Ibad_model_not_supported_versionSafeDispatcherSubPointersMut { + let base_address = self.__storage_pointer_address__; + let mut current_offset = self.__storage_pointer_offset__; + let contract_address_value = starknet::storage::StoragePointer { + __storage_pointer_address__: base_address, + __storage_pointer_offset__: current_offset, + }; + Ibad_model_not_supported_versionSafeDispatcherSubPointersMut { + contract_address: contract_address_value, + } + } +} +impl Imodelv_0DispatcherCopy of core::traits::Copy::; +impl Imodelv_0DispatcherDrop of core::traits::Drop::; +impl Imodelv_0DispatcherSerde of core::serde::Serde:: { + fn serialize(self: @Imodelv_0Dispatcher, ref output: core::array::Array) { + core::serde::Serde::serialize(self.contract_address, ref output) + } + fn deserialize(ref serialized: core::array::Span) -> core::option::Option { + core::option::Option::Some(Imodelv_0Dispatcher { + contract_address: core::serde::Serde::deserialize(ref serialized)?, + }) + } +} +impl StoreImodelv_0Dispatcher of starknet::Store:: { + fn read(address_domain: u32, base: starknet::storage_access::StorageBaseAddress) -> starknet::SyscallResult { + let contract_address = starknet::Store::::read(address_domain, base)?; + starknet::SyscallResult::Ok( + Imodelv_0Dispatcher { + contract_address, + } + ) + } + fn write(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, value: Imodelv_0Dispatcher) -> starknet::SyscallResult<()> { + starknet::Store::::write(address_domain, base, value.contract_address)?; + starknet::SyscallResult::Ok(()) + } + fn read_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8) -> starknet::SyscallResult { + let contract_address = starknet::Store::::read_at_offset(address_domain, base, offset)?; + starknet::SyscallResult::Ok( + Imodelv_0Dispatcher { + contract_address, + } + ) + } + #[inline(always)] + fn write_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8, value: Imodelv_0Dispatcher) -> starknet::SyscallResult<()> { + starknet::Store::::write_at_offset(address_domain, base, offset, value.contract_address)?; + starknet::SyscallResult::Ok(()) + } + #[inline(always)] + fn size() -> u8 { + starknet::Store::::size() + } +} + +#[derive(Drop, Copy)] +pub struct Imodelv_0DispatcherSubPointers { + pub contract_address: starknet::storage::StoragePointer, +} +impl Imodelv_0DispatcherSubPointersImpl of starknet::storage::SubPointers { + type SubPointersType = Imodelv_0DispatcherSubPointers; + fn sub_pointers(self: starknet::storage::StoragePointer) -> Imodelv_0DispatcherSubPointers { + let base_address = self.__storage_pointer_address__; + let mut current_offset = self.__storage_pointer_offset__; + let contract_address_value = starknet::storage::StoragePointer { + __storage_pointer_address__: base_address, + __storage_pointer_offset__: current_offset, + }; + Imodelv_0DispatcherSubPointers { + contract_address: contract_address_value, + } + } +} +#[derive(Drop, Copy)] +pub struct Imodelv_0DispatcherSubPointersMut { + pub contract_address: starknet::storage::StoragePointer>, +} +impl Imodelv_0DispatcherSubPointersMutImpl of starknet::storage::SubPointersMut { + type SubPointersType = Imodelv_0DispatcherSubPointersMut; + fn sub_pointers_mut(self: starknet::storage::StoragePointer>) -> Imodelv_0DispatcherSubPointersMut { + let base_address = self.__storage_pointer_address__; + let mut current_offset = self.__storage_pointer_offset__; + let contract_address_value = starknet::storage::StoragePointer { + __storage_pointer_address__: base_address, + __storage_pointer_offset__: current_offset, + }; + Imodelv_0DispatcherSubPointersMut { + contract_address: contract_address_value, + } + } +} +impl Imodelv_0LibraryDispatcherCopy of core::traits::Copy::; +impl Imodelv_0LibraryDispatcherDrop of core::traits::Drop::; +impl Imodelv_0LibraryDispatcherSerde of core::serde::Serde:: { + fn serialize(self: @Imodelv_0LibraryDispatcher, ref output: core::array::Array) { + core::serde::Serde::serialize(self.class_hash, ref output) + } + fn deserialize(ref serialized: core::array::Span) -> core::option::Option { + core::option::Option::Some(Imodelv_0LibraryDispatcher { + class_hash: core::serde::Serde::deserialize(ref serialized)?, + }) + } +} +impl StoreImodelv_0LibraryDispatcher of starknet::Store:: { + fn read(address_domain: u32, base: starknet::storage_access::StorageBaseAddress) -> starknet::SyscallResult { + let class_hash = starknet::Store::::read(address_domain, base)?; + starknet::SyscallResult::Ok( + Imodelv_0LibraryDispatcher { + class_hash, + } + ) + } + fn write(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, value: Imodelv_0LibraryDispatcher) -> starknet::SyscallResult<()> { + starknet::Store::::write(address_domain, base, value.class_hash)?; + starknet::SyscallResult::Ok(()) + } + fn read_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8) -> starknet::SyscallResult { + let class_hash = starknet::Store::::read_at_offset(address_domain, base, offset)?; + starknet::SyscallResult::Ok( + Imodelv_0LibraryDispatcher { + class_hash, + } + ) + } + #[inline(always)] + fn write_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8, value: Imodelv_0LibraryDispatcher) -> starknet::SyscallResult<()> { + starknet::Store::::write_at_offset(address_domain, base, offset, value.class_hash)?; + starknet::SyscallResult::Ok(()) + } + #[inline(always)] + fn size() -> u8 { + starknet::Store::::size() + } +} + +#[derive(Drop, Copy)] +pub struct Imodelv_0LibraryDispatcherSubPointers { + pub class_hash: starknet::storage::StoragePointer, +} +impl Imodelv_0LibraryDispatcherSubPointersImpl of starknet::storage::SubPointers { + type SubPointersType = Imodelv_0LibraryDispatcherSubPointers; + fn sub_pointers(self: starknet::storage::StoragePointer) -> Imodelv_0LibraryDispatcherSubPointers { + let base_address = self.__storage_pointer_address__; + let mut current_offset = self.__storage_pointer_offset__; + let class_hash_value = starknet::storage::StoragePointer { + __storage_pointer_address__: base_address, + __storage_pointer_offset__: current_offset, + }; + Imodelv_0LibraryDispatcherSubPointers { + class_hash: class_hash_value, + } + } +} +#[derive(Drop, Copy)] +pub struct Imodelv_0LibraryDispatcherSubPointersMut { + pub class_hash: starknet::storage::StoragePointer>, +} +impl Imodelv_0LibraryDispatcherSubPointersMutImpl of starknet::storage::SubPointersMut { + type SubPointersType = Imodelv_0LibraryDispatcherSubPointersMut; + fn sub_pointers_mut(self: starknet::storage::StoragePointer>) -> Imodelv_0LibraryDispatcherSubPointersMut { + let base_address = self.__storage_pointer_address__; + let mut current_offset = self.__storage_pointer_offset__; + let class_hash_value = starknet::storage::StoragePointer { + __storage_pointer_address__: base_address, + __storage_pointer_offset__: current_offset, + }; + Imodelv_0LibraryDispatcherSubPointersMut { + class_hash: class_hash_value, + } + } +} +impl Imodelv_0SafeLibraryDispatcherCopy of core::traits::Copy::; +impl Imodelv_0SafeLibraryDispatcherDrop of core::traits::Drop::; +impl Imodelv_0SafeLibraryDispatcherSerde of core::serde::Serde:: { + fn serialize(self: @Imodelv_0SafeLibraryDispatcher, ref output: core::array::Array) { + core::serde::Serde::serialize(self.class_hash, ref output) + } + fn deserialize(ref serialized: core::array::Span) -> core::option::Option { + core::option::Option::Some(Imodelv_0SafeLibraryDispatcher { + class_hash: core::serde::Serde::deserialize(ref serialized)?, + }) + } +} +impl StoreImodelv_0SafeLibraryDispatcher of starknet::Store:: { + fn read(address_domain: u32, base: starknet::storage_access::StorageBaseAddress) -> starknet::SyscallResult { + let class_hash = starknet::Store::::read(address_domain, base)?; + starknet::SyscallResult::Ok( + Imodelv_0SafeLibraryDispatcher { + class_hash, + } + ) + } + fn write(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, value: Imodelv_0SafeLibraryDispatcher) -> starknet::SyscallResult<()> { + starknet::Store::::write(address_domain, base, value.class_hash)?; + starknet::SyscallResult::Ok(()) + } + fn read_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8) -> starknet::SyscallResult { + let class_hash = starknet::Store::::read_at_offset(address_domain, base, offset)?; + starknet::SyscallResult::Ok( + Imodelv_0SafeLibraryDispatcher { + class_hash, + } + ) + } + #[inline(always)] + fn write_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8, value: Imodelv_0SafeLibraryDispatcher) -> starknet::SyscallResult<()> { + starknet::Store::::write_at_offset(address_domain, base, offset, value.class_hash)?; + starknet::SyscallResult::Ok(()) + } + #[inline(always)] + fn size() -> u8 { + starknet::Store::::size() + } +} + +#[derive(Drop, Copy)] +pub struct Imodelv_0SafeLibraryDispatcherSubPointers { + pub class_hash: starknet::storage::StoragePointer, +} +impl Imodelv_0SafeLibraryDispatcherSubPointersImpl of starknet::storage::SubPointers { + type SubPointersType = Imodelv_0SafeLibraryDispatcherSubPointers; + fn sub_pointers(self: starknet::storage::StoragePointer) -> Imodelv_0SafeLibraryDispatcherSubPointers { + let base_address = self.__storage_pointer_address__; + let mut current_offset = self.__storage_pointer_offset__; + let class_hash_value = starknet::storage::StoragePointer { + __storage_pointer_address__: base_address, + __storage_pointer_offset__: current_offset, + }; + Imodelv_0SafeLibraryDispatcherSubPointers { + class_hash: class_hash_value, + } + } +} +#[derive(Drop, Copy)] +pub struct Imodelv_0SafeLibraryDispatcherSubPointersMut { + pub class_hash: starknet::storage::StoragePointer>, +} +impl Imodelv_0SafeLibraryDispatcherSubPointersMutImpl of starknet::storage::SubPointersMut { + type SubPointersType = Imodelv_0SafeLibraryDispatcherSubPointersMut; + fn sub_pointers_mut(self: starknet::storage::StoragePointer>) -> Imodelv_0SafeLibraryDispatcherSubPointersMut { + let base_address = self.__storage_pointer_address__; + let mut current_offset = self.__storage_pointer_offset__; + let class_hash_value = starknet::storage::StoragePointer { + __storage_pointer_address__: base_address, + __storage_pointer_offset__: current_offset, + }; + Imodelv_0SafeLibraryDispatcherSubPointersMut { + class_hash: class_hash_value, + } + } +} +impl Imodelv_0SafeDispatcherCopy of core::traits::Copy::; +impl Imodelv_0SafeDispatcherDrop of core::traits::Drop::; +impl Imodelv_0SafeDispatcherSerde of core::serde::Serde:: { + fn serialize(self: @Imodelv_0SafeDispatcher, ref output: core::array::Array) { + core::serde::Serde::serialize(self.contract_address, ref output) + } + fn deserialize(ref serialized: core::array::Span) -> core::option::Option { + core::option::Option::Some(Imodelv_0SafeDispatcher { + contract_address: core::serde::Serde::deserialize(ref serialized)?, + }) + } +} +impl StoreImodelv_0SafeDispatcher of starknet::Store:: { + fn read(address_domain: u32, base: starknet::storage_access::StorageBaseAddress) -> starknet::SyscallResult { + let contract_address = starknet::Store::::read(address_domain, base)?; + starknet::SyscallResult::Ok( + Imodelv_0SafeDispatcher { + contract_address, + } + ) + } + fn write(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, value: Imodelv_0SafeDispatcher) -> starknet::SyscallResult<()> { + starknet::Store::::write(address_domain, base, value.contract_address)?; + starknet::SyscallResult::Ok(()) + } + fn read_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8) -> starknet::SyscallResult { + let contract_address = starknet::Store::::read_at_offset(address_domain, base, offset)?; + starknet::SyscallResult::Ok( + Imodelv_0SafeDispatcher { + contract_address, + } + ) + } + #[inline(always)] + fn write_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8, value: Imodelv_0SafeDispatcher) -> starknet::SyscallResult<()> { + starknet::Store::::write_at_offset(address_domain, base, offset, value.contract_address)?; + starknet::SyscallResult::Ok(()) + } + #[inline(always)] + fn size() -> u8 { + starknet::Store::::size() + } +} + +#[derive(Drop, Copy)] +pub struct Imodelv_0SafeDispatcherSubPointers { + pub contract_address: starknet::storage::StoragePointer, +} +impl Imodelv_0SafeDispatcherSubPointersImpl of starknet::storage::SubPointers { + type SubPointersType = Imodelv_0SafeDispatcherSubPointers; + fn sub_pointers(self: starknet::storage::StoragePointer) -> Imodelv_0SafeDispatcherSubPointers { + let base_address = self.__storage_pointer_address__; + let mut current_offset = self.__storage_pointer_offset__; + let contract_address_value = starknet::storage::StoragePointer { + __storage_pointer_address__: base_address, + __storage_pointer_offset__: current_offset, + }; + Imodelv_0SafeDispatcherSubPointers { + contract_address: contract_address_value, + } + } +} +#[derive(Drop, Copy)] +pub struct Imodelv_0SafeDispatcherSubPointersMut { + pub contract_address: starknet::storage::StoragePointer>, +} +impl Imodelv_0SafeDispatcherSubPointersMutImpl of starknet::storage::SubPointersMut { + type SubPointersType = Imodelv_0SafeDispatcherSubPointersMut; + fn sub_pointers_mut(self: starknet::storage::StoragePointer>) -> Imodelv_0SafeDispatcherSubPointersMut { + let base_address = self.__storage_pointer_address__; + let mut current_offset = self.__storage_pointer_offset__; + let contract_address_value = starknet::storage::StoragePointer { + __storage_pointer_address__: base_address, + __storage_pointer_offset__: current_offset, + }; + Imodelv_0SafeDispatcherSubPointersMut { + contract_address: contract_address_value, + } + } +} +impl Imodel_with_bad_namespace_formatDispatcherCopy of core::traits::Copy::; +impl Imodel_with_bad_namespace_formatDispatcherDrop of core::traits::Drop::; +impl Imodel_with_bad_namespace_formatDispatcherSerde of core::serde::Serde:: { + fn serialize(self: @Imodel_with_bad_namespace_formatDispatcher, ref output: core::array::Array) { + core::serde::Serde::serialize(self.contract_address, ref output) + } + fn deserialize(ref serialized: core::array::Span) -> core::option::Option { + core::option::Option::Some(Imodel_with_bad_namespace_formatDispatcher { + contract_address: core::serde::Serde::deserialize(ref serialized)?, + }) + } +} +impl StoreImodel_with_bad_namespace_formatDispatcher of starknet::Store:: { + fn read(address_domain: u32, base: starknet::storage_access::StorageBaseAddress) -> starknet::SyscallResult { + let contract_address = starknet::Store::::read(address_domain, base)?; + starknet::SyscallResult::Ok( + Imodel_with_bad_namespace_formatDispatcher { + contract_address, + } + ) + } + fn write(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, value: Imodel_with_bad_namespace_formatDispatcher) -> starknet::SyscallResult<()> { + starknet::Store::::write(address_domain, base, value.contract_address)?; + starknet::SyscallResult::Ok(()) + } + fn read_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8) -> starknet::SyscallResult { + let contract_address = starknet::Store::::read_at_offset(address_domain, base, offset)?; + starknet::SyscallResult::Ok( + Imodel_with_bad_namespace_formatDispatcher { + contract_address, + } + ) + } + #[inline(always)] + fn write_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8, value: Imodel_with_bad_namespace_formatDispatcher) -> starknet::SyscallResult<()> { + starknet::Store::::write_at_offset(address_domain, base, offset, value.contract_address)?; + starknet::SyscallResult::Ok(()) + } + #[inline(always)] + fn size() -> u8 { + starknet::Store::::size() + } +} + +#[derive(Drop, Copy)] +pub struct Imodel_with_bad_namespace_formatDispatcherSubPointers { + pub contract_address: starknet::storage::StoragePointer, +} +impl Imodel_with_bad_namespace_formatDispatcherSubPointersImpl of starknet::storage::SubPointers { + type SubPointersType = Imodel_with_bad_namespace_formatDispatcherSubPointers; + fn sub_pointers(self: starknet::storage::StoragePointer) -> Imodel_with_bad_namespace_formatDispatcherSubPointers { + let base_address = self.__storage_pointer_address__; + let mut current_offset = self.__storage_pointer_offset__; + let contract_address_value = starknet::storage::StoragePointer { + __storage_pointer_address__: base_address, + __storage_pointer_offset__: current_offset, + }; + Imodel_with_bad_namespace_formatDispatcherSubPointers { + contract_address: contract_address_value, + } + } +} +#[derive(Drop, Copy)] +pub struct Imodel_with_bad_namespace_formatDispatcherSubPointersMut { + pub contract_address: starknet::storage::StoragePointer>, +} +impl Imodel_with_bad_namespace_formatDispatcherSubPointersMutImpl of starknet::storage::SubPointersMut { + type SubPointersType = Imodel_with_bad_namespace_formatDispatcherSubPointersMut; + fn sub_pointers_mut(self: starknet::storage::StoragePointer>) -> Imodel_with_bad_namespace_formatDispatcherSubPointersMut { + let base_address = self.__storage_pointer_address__; + let mut current_offset = self.__storage_pointer_offset__; + let contract_address_value = starknet::storage::StoragePointer { + __storage_pointer_address__: base_address, + __storage_pointer_offset__: current_offset, + }; + Imodel_with_bad_namespace_formatDispatcherSubPointersMut { + contract_address: contract_address_value, + } + } +} +impl Imodel_with_bad_namespace_formatLibraryDispatcherCopy of core::traits::Copy::; +impl Imodel_with_bad_namespace_formatLibraryDispatcherDrop of core::traits::Drop::; +impl Imodel_with_bad_namespace_formatLibraryDispatcherSerde of core::serde::Serde:: { + fn serialize(self: @Imodel_with_bad_namespace_formatLibraryDispatcher, ref output: core::array::Array) { + core::serde::Serde::serialize(self.class_hash, ref output) + } + fn deserialize(ref serialized: core::array::Span) -> core::option::Option { + core::option::Option::Some(Imodel_with_bad_namespace_formatLibraryDispatcher { + class_hash: core::serde::Serde::deserialize(ref serialized)?, + }) + } +} +impl StoreImodel_with_bad_namespace_formatLibraryDispatcher of starknet::Store:: { + fn read(address_domain: u32, base: starknet::storage_access::StorageBaseAddress) -> starknet::SyscallResult { + let class_hash = starknet::Store::::read(address_domain, base)?; + starknet::SyscallResult::Ok( + Imodel_with_bad_namespace_formatLibraryDispatcher { + class_hash, + } + ) + } + fn write(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, value: Imodel_with_bad_namespace_formatLibraryDispatcher) -> starknet::SyscallResult<()> { + starknet::Store::::write(address_domain, base, value.class_hash)?; + starknet::SyscallResult::Ok(()) + } + fn read_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8) -> starknet::SyscallResult { + let class_hash = starknet::Store::::read_at_offset(address_domain, base, offset)?; + starknet::SyscallResult::Ok( + Imodel_with_bad_namespace_formatLibraryDispatcher { + class_hash, + } + ) + } + #[inline(always)] + fn write_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8, value: Imodel_with_bad_namespace_formatLibraryDispatcher) -> starknet::SyscallResult<()> { + starknet::Store::::write_at_offset(address_domain, base, offset, value.class_hash)?; + starknet::SyscallResult::Ok(()) + } + #[inline(always)] + fn size() -> u8 { + starknet::Store::::size() + } +} + +#[derive(Drop, Copy)] +pub struct Imodel_with_bad_namespace_formatLibraryDispatcherSubPointers { + pub class_hash: starknet::storage::StoragePointer, +} +impl Imodel_with_bad_namespace_formatLibraryDispatcherSubPointersImpl of starknet::storage::SubPointers { + type SubPointersType = Imodel_with_bad_namespace_formatLibraryDispatcherSubPointers; + fn sub_pointers(self: starknet::storage::StoragePointer) -> Imodel_with_bad_namespace_formatLibraryDispatcherSubPointers { + let base_address = self.__storage_pointer_address__; + let mut current_offset = self.__storage_pointer_offset__; + let class_hash_value = starknet::storage::StoragePointer { + __storage_pointer_address__: base_address, + __storage_pointer_offset__: current_offset, + }; + Imodel_with_bad_namespace_formatLibraryDispatcherSubPointers { + class_hash: class_hash_value, + } + } +} +#[derive(Drop, Copy)] +pub struct Imodel_with_bad_namespace_formatLibraryDispatcherSubPointersMut { + pub class_hash: starknet::storage::StoragePointer>, +} +impl Imodel_with_bad_namespace_formatLibraryDispatcherSubPointersMutImpl of starknet::storage::SubPointersMut { + type SubPointersType = Imodel_with_bad_namespace_formatLibraryDispatcherSubPointersMut; + fn sub_pointers_mut(self: starknet::storage::StoragePointer>) -> Imodel_with_bad_namespace_formatLibraryDispatcherSubPointersMut { + let base_address = self.__storage_pointer_address__; + let mut current_offset = self.__storage_pointer_offset__; + let class_hash_value = starknet::storage::StoragePointer { + __storage_pointer_address__: base_address, + __storage_pointer_offset__: current_offset, + }; + Imodel_with_bad_namespace_formatLibraryDispatcherSubPointersMut { + class_hash: class_hash_value, + } + } +} +impl Imodel_with_bad_namespace_formatSafeLibraryDispatcherCopy of core::traits::Copy::; +impl Imodel_with_bad_namespace_formatSafeLibraryDispatcherDrop of core::traits::Drop::; +impl Imodel_with_bad_namespace_formatSafeLibraryDispatcherSerde of core::serde::Serde:: { + fn serialize(self: @Imodel_with_bad_namespace_formatSafeLibraryDispatcher, ref output: core::array::Array) { + core::serde::Serde::serialize(self.class_hash, ref output) + } + fn deserialize(ref serialized: core::array::Span) -> core::option::Option { + core::option::Option::Some(Imodel_with_bad_namespace_formatSafeLibraryDispatcher { + class_hash: core::serde::Serde::deserialize(ref serialized)?, + }) + } +} +impl StoreImodel_with_bad_namespace_formatSafeLibraryDispatcher of starknet::Store:: { + fn read(address_domain: u32, base: starknet::storage_access::StorageBaseAddress) -> starknet::SyscallResult { + let class_hash = starknet::Store::::read(address_domain, base)?; + starknet::SyscallResult::Ok( + Imodel_with_bad_namespace_formatSafeLibraryDispatcher { + class_hash, + } + ) + } + fn write(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, value: Imodel_with_bad_namespace_formatSafeLibraryDispatcher) -> starknet::SyscallResult<()> { + starknet::Store::::write(address_domain, base, value.class_hash)?; + starknet::SyscallResult::Ok(()) + } + fn read_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8) -> starknet::SyscallResult { + let class_hash = starknet::Store::::read_at_offset(address_domain, base, offset)?; + starknet::SyscallResult::Ok( + Imodel_with_bad_namespace_formatSafeLibraryDispatcher { + class_hash, + } + ) + } + #[inline(always)] + fn write_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8, value: Imodel_with_bad_namespace_formatSafeLibraryDispatcher) -> starknet::SyscallResult<()> { + starknet::Store::::write_at_offset(address_domain, base, offset, value.class_hash)?; + starknet::SyscallResult::Ok(()) + } + #[inline(always)] + fn size() -> u8 { + starknet::Store::::size() + } +} + +#[derive(Drop, Copy)] +pub struct Imodel_with_bad_namespace_formatSafeLibraryDispatcherSubPointers { + pub class_hash: starknet::storage::StoragePointer, +} +impl Imodel_with_bad_namespace_formatSafeLibraryDispatcherSubPointersImpl of starknet::storage::SubPointers { + type SubPointersType = Imodel_with_bad_namespace_formatSafeLibraryDispatcherSubPointers; + fn sub_pointers(self: starknet::storage::StoragePointer) -> Imodel_with_bad_namespace_formatSafeLibraryDispatcherSubPointers { + let base_address = self.__storage_pointer_address__; + let mut current_offset = self.__storage_pointer_offset__; + let class_hash_value = starknet::storage::StoragePointer { + __storage_pointer_address__: base_address, + __storage_pointer_offset__: current_offset, + }; + Imodel_with_bad_namespace_formatSafeLibraryDispatcherSubPointers { + class_hash: class_hash_value, + } + } +} +#[derive(Drop, Copy)] +pub struct Imodel_with_bad_namespace_formatSafeLibraryDispatcherSubPointersMut { + pub class_hash: starknet::storage::StoragePointer>, +} +impl Imodel_with_bad_namespace_formatSafeLibraryDispatcherSubPointersMutImpl of starknet::storage::SubPointersMut { + type SubPointersType = Imodel_with_bad_namespace_formatSafeLibraryDispatcherSubPointersMut; + fn sub_pointers_mut(self: starknet::storage::StoragePointer>) -> Imodel_with_bad_namespace_formatSafeLibraryDispatcherSubPointersMut { + let base_address = self.__storage_pointer_address__; + let mut current_offset = self.__storage_pointer_offset__; + let class_hash_value = starknet::storage::StoragePointer { + __storage_pointer_address__: base_address, + __storage_pointer_offset__: current_offset, + }; + Imodel_with_bad_namespace_formatSafeLibraryDispatcherSubPointersMut { + class_hash: class_hash_value, + } + } +} +impl Imodel_with_bad_namespace_formatSafeDispatcherCopy of core::traits::Copy::; +impl Imodel_with_bad_namespace_formatSafeDispatcherDrop of core::traits::Drop::; +impl Imodel_with_bad_namespace_formatSafeDispatcherSerde of core::serde::Serde:: { + fn serialize(self: @Imodel_with_bad_namespace_formatSafeDispatcher, ref output: core::array::Array) { + core::serde::Serde::serialize(self.contract_address, ref output) + } + fn deserialize(ref serialized: core::array::Span) -> core::option::Option { + core::option::Option::Some(Imodel_with_bad_namespace_formatSafeDispatcher { + contract_address: core::serde::Serde::deserialize(ref serialized)?, + }) + } +} +impl StoreImodel_with_bad_namespace_formatSafeDispatcher of starknet::Store:: { + fn read(address_domain: u32, base: starknet::storage_access::StorageBaseAddress) -> starknet::SyscallResult { + let contract_address = starknet::Store::::read(address_domain, base)?; + starknet::SyscallResult::Ok( + Imodel_with_bad_namespace_formatSafeDispatcher { + contract_address, + } + ) + } + fn write(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, value: Imodel_with_bad_namespace_formatSafeDispatcher) -> starknet::SyscallResult<()> { + starknet::Store::::write(address_domain, base, value.contract_address)?; + starknet::SyscallResult::Ok(()) + } + fn read_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8) -> starknet::SyscallResult { + let contract_address = starknet::Store::::read_at_offset(address_domain, base, offset)?; + starknet::SyscallResult::Ok( + Imodel_with_bad_namespace_formatSafeDispatcher { + contract_address, + } + ) + } + #[inline(always)] + fn write_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8, value: Imodel_with_bad_namespace_formatSafeDispatcher) -> starknet::SyscallResult<()> { + starknet::Store::::write_at_offset(address_domain, base, offset, value.contract_address)?; + starknet::SyscallResult::Ok(()) + } + #[inline(always)] + fn size() -> u8 { + starknet::Store::::size() + } +} + +#[derive(Drop, Copy)] +pub struct Imodel_with_bad_namespace_formatSafeDispatcherSubPointers { + pub contract_address: starknet::storage::StoragePointer, +} +impl Imodel_with_bad_namespace_formatSafeDispatcherSubPointersImpl of starknet::storage::SubPointers { + type SubPointersType = Imodel_with_bad_namespace_formatSafeDispatcherSubPointers; + fn sub_pointers(self: starknet::storage::StoragePointer) -> Imodel_with_bad_namespace_formatSafeDispatcherSubPointers { + let base_address = self.__storage_pointer_address__; + let mut current_offset = self.__storage_pointer_offset__; + let contract_address_value = starknet::storage::StoragePointer { + __storage_pointer_address__: base_address, + __storage_pointer_offset__: current_offset, + }; + Imodel_with_bad_namespace_formatSafeDispatcherSubPointers { + contract_address: contract_address_value, + } + } +} +#[derive(Drop, Copy)] +pub struct Imodel_with_bad_namespace_formatSafeDispatcherSubPointersMut { + pub contract_address: starknet::storage::StoragePointer>, +} +impl Imodel_with_bad_namespace_formatSafeDispatcherSubPointersMutImpl of starknet::storage::SubPointersMut { + type SubPointersType = Imodel_with_bad_namespace_formatSafeDispatcherSubPointersMut; + fn sub_pointers_mut(self: starknet::storage::StoragePointer>) -> Imodel_with_bad_namespace_formatSafeDispatcherSubPointersMut { + let base_address = self.__storage_pointer_address__; + let mut current_offset = self.__storage_pointer_offset__; + let contract_address_value = starknet::storage::StoragePointer { + __storage_pointer_address__: base_address, + __storage_pointer_offset__: current_offset, + }; + Imodel_with_bad_namespace_formatSafeDispatcherSubPointersMut { + contract_address: contract_address_value, + } + } +} +impl Imodel_with_short_string_namespaceDispatcherCopy of core::traits::Copy::; +impl Imodel_with_short_string_namespaceDispatcherDrop of core::traits::Drop::; +impl Imodel_with_short_string_namespaceDispatcherSerde of core::serde::Serde:: { + fn serialize(self: @Imodel_with_short_string_namespaceDispatcher, ref output: core::array::Array) { + core::serde::Serde::serialize(self.contract_address, ref output) + } + fn deserialize(ref serialized: core::array::Span) -> core::option::Option { + core::option::Option::Some(Imodel_with_short_string_namespaceDispatcher { + contract_address: core::serde::Serde::deserialize(ref serialized)?, + }) + } +} +impl StoreImodel_with_short_string_namespaceDispatcher of starknet::Store:: { + fn read(address_domain: u32, base: starknet::storage_access::StorageBaseAddress) -> starknet::SyscallResult { + let contract_address = starknet::Store::::read(address_domain, base)?; + starknet::SyscallResult::Ok( + Imodel_with_short_string_namespaceDispatcher { + contract_address, + } + ) + } + fn write(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, value: Imodel_with_short_string_namespaceDispatcher) -> starknet::SyscallResult<()> { + starknet::Store::::write(address_domain, base, value.contract_address)?; + starknet::SyscallResult::Ok(()) + } + fn read_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8) -> starknet::SyscallResult { + let contract_address = starknet::Store::::read_at_offset(address_domain, base, offset)?; + starknet::SyscallResult::Ok( + Imodel_with_short_string_namespaceDispatcher { + contract_address, + } + ) + } + #[inline(always)] + fn write_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8, value: Imodel_with_short_string_namespaceDispatcher) -> starknet::SyscallResult<()> { + starknet::Store::::write_at_offset(address_domain, base, offset, value.contract_address)?; + starknet::SyscallResult::Ok(()) + } + #[inline(always)] + fn size() -> u8 { + starknet::Store::::size() + } +} + +#[derive(Drop, Copy)] +pub struct Imodel_with_short_string_namespaceDispatcherSubPointers { + pub contract_address: starknet::storage::StoragePointer, +} +impl Imodel_with_short_string_namespaceDispatcherSubPointersImpl of starknet::storage::SubPointers { + type SubPointersType = Imodel_with_short_string_namespaceDispatcherSubPointers; + fn sub_pointers(self: starknet::storage::StoragePointer) -> Imodel_with_short_string_namespaceDispatcherSubPointers { + let base_address = self.__storage_pointer_address__; + let mut current_offset = self.__storage_pointer_offset__; + let contract_address_value = starknet::storage::StoragePointer { + __storage_pointer_address__: base_address, + __storage_pointer_offset__: current_offset, + }; + Imodel_with_short_string_namespaceDispatcherSubPointers { + contract_address: contract_address_value, + } + } +} +#[derive(Drop, Copy)] +pub struct Imodel_with_short_string_namespaceDispatcherSubPointersMut { + pub contract_address: starknet::storage::StoragePointer>, +} +impl Imodel_with_short_string_namespaceDispatcherSubPointersMutImpl of starknet::storage::SubPointersMut { + type SubPointersType = Imodel_with_short_string_namespaceDispatcherSubPointersMut; + fn sub_pointers_mut(self: starknet::storage::StoragePointer>) -> Imodel_with_short_string_namespaceDispatcherSubPointersMut { + let base_address = self.__storage_pointer_address__; + let mut current_offset = self.__storage_pointer_offset__; + let contract_address_value = starknet::storage::StoragePointer { + __storage_pointer_address__: base_address, + __storage_pointer_offset__: current_offset, + }; + Imodel_with_short_string_namespaceDispatcherSubPointersMut { + contract_address: contract_address_value, + } + } +} +impl Imodel_with_short_string_namespaceLibraryDispatcherCopy of core::traits::Copy::; +impl Imodel_with_short_string_namespaceLibraryDispatcherDrop of core::traits::Drop::; +impl Imodel_with_short_string_namespaceLibraryDispatcherSerde of core::serde::Serde:: { + fn serialize(self: @Imodel_with_short_string_namespaceLibraryDispatcher, ref output: core::array::Array) { + core::serde::Serde::serialize(self.class_hash, ref output) + } + fn deserialize(ref serialized: core::array::Span) -> core::option::Option { + core::option::Option::Some(Imodel_with_short_string_namespaceLibraryDispatcher { + class_hash: core::serde::Serde::deserialize(ref serialized)?, + }) + } +} +impl StoreImodel_with_short_string_namespaceLibraryDispatcher of starknet::Store:: { + fn read(address_domain: u32, base: starknet::storage_access::StorageBaseAddress) -> starknet::SyscallResult { + let class_hash = starknet::Store::::read(address_domain, base)?; + starknet::SyscallResult::Ok( + Imodel_with_short_string_namespaceLibraryDispatcher { + class_hash, + } + ) + } + fn write(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, value: Imodel_with_short_string_namespaceLibraryDispatcher) -> starknet::SyscallResult<()> { + starknet::Store::::write(address_domain, base, value.class_hash)?; + starknet::SyscallResult::Ok(()) + } + fn read_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8) -> starknet::SyscallResult { + let class_hash = starknet::Store::::read_at_offset(address_domain, base, offset)?; + starknet::SyscallResult::Ok( + Imodel_with_short_string_namespaceLibraryDispatcher { + class_hash, + } + ) + } + #[inline(always)] + fn write_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8, value: Imodel_with_short_string_namespaceLibraryDispatcher) -> starknet::SyscallResult<()> { + starknet::Store::::write_at_offset(address_domain, base, offset, value.class_hash)?; + starknet::SyscallResult::Ok(()) + } + #[inline(always)] + fn size() -> u8 { + starknet::Store::::size() + } +} + +#[derive(Drop, Copy)] +pub struct Imodel_with_short_string_namespaceLibraryDispatcherSubPointers { + pub class_hash: starknet::storage::StoragePointer, +} +impl Imodel_with_short_string_namespaceLibraryDispatcherSubPointersImpl of starknet::storage::SubPointers { + type SubPointersType = Imodel_with_short_string_namespaceLibraryDispatcherSubPointers; + fn sub_pointers(self: starknet::storage::StoragePointer) -> Imodel_with_short_string_namespaceLibraryDispatcherSubPointers { + let base_address = self.__storage_pointer_address__; + let mut current_offset = self.__storage_pointer_offset__; + let class_hash_value = starknet::storage::StoragePointer { + __storage_pointer_address__: base_address, + __storage_pointer_offset__: current_offset, + }; + Imodel_with_short_string_namespaceLibraryDispatcherSubPointers { + class_hash: class_hash_value, + } + } +} +#[derive(Drop, Copy)] +pub struct Imodel_with_short_string_namespaceLibraryDispatcherSubPointersMut { + pub class_hash: starknet::storage::StoragePointer>, +} +impl Imodel_with_short_string_namespaceLibraryDispatcherSubPointersMutImpl of starknet::storage::SubPointersMut { + type SubPointersType = Imodel_with_short_string_namespaceLibraryDispatcherSubPointersMut; + fn sub_pointers_mut(self: starknet::storage::StoragePointer>) -> Imodel_with_short_string_namespaceLibraryDispatcherSubPointersMut { + let base_address = self.__storage_pointer_address__; + let mut current_offset = self.__storage_pointer_offset__; + let class_hash_value = starknet::storage::StoragePointer { + __storage_pointer_address__: base_address, + __storage_pointer_offset__: current_offset, + }; + Imodel_with_short_string_namespaceLibraryDispatcherSubPointersMut { + class_hash: class_hash_value, + } + } +} +impl Imodel_with_short_string_namespaceSafeLibraryDispatcherCopy of core::traits::Copy::; +impl Imodel_with_short_string_namespaceSafeLibraryDispatcherDrop of core::traits::Drop::; +impl Imodel_with_short_string_namespaceSafeLibraryDispatcherSerde of core::serde::Serde:: { + fn serialize(self: @Imodel_with_short_string_namespaceSafeLibraryDispatcher, ref output: core::array::Array) { + core::serde::Serde::serialize(self.class_hash, ref output) + } + fn deserialize(ref serialized: core::array::Span) -> core::option::Option { + core::option::Option::Some(Imodel_with_short_string_namespaceSafeLibraryDispatcher { + class_hash: core::serde::Serde::deserialize(ref serialized)?, + }) + } +} +impl StoreImodel_with_short_string_namespaceSafeLibraryDispatcher of starknet::Store:: { + fn read(address_domain: u32, base: starknet::storage_access::StorageBaseAddress) -> starknet::SyscallResult { + let class_hash = starknet::Store::::read(address_domain, base)?; + starknet::SyscallResult::Ok( + Imodel_with_short_string_namespaceSafeLibraryDispatcher { + class_hash, + } + ) + } + fn write(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, value: Imodel_with_short_string_namespaceSafeLibraryDispatcher) -> starknet::SyscallResult<()> { + starknet::Store::::write(address_domain, base, value.class_hash)?; + starknet::SyscallResult::Ok(()) + } + fn read_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8) -> starknet::SyscallResult { + let class_hash = starknet::Store::::read_at_offset(address_domain, base, offset)?; + starknet::SyscallResult::Ok( + Imodel_with_short_string_namespaceSafeLibraryDispatcher { + class_hash, + } + ) + } + #[inline(always)] + fn write_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8, value: Imodel_with_short_string_namespaceSafeLibraryDispatcher) -> starknet::SyscallResult<()> { + starknet::Store::::write_at_offset(address_domain, base, offset, value.class_hash)?; + starknet::SyscallResult::Ok(()) + } + #[inline(always)] + fn size() -> u8 { + starknet::Store::::size() + } +} + +#[derive(Drop, Copy)] +pub struct Imodel_with_short_string_namespaceSafeLibraryDispatcherSubPointers { + pub class_hash: starknet::storage::StoragePointer, +} +impl Imodel_with_short_string_namespaceSafeLibraryDispatcherSubPointersImpl of starknet::storage::SubPointers { + type SubPointersType = Imodel_with_short_string_namespaceSafeLibraryDispatcherSubPointers; + fn sub_pointers(self: starknet::storage::StoragePointer) -> Imodel_with_short_string_namespaceSafeLibraryDispatcherSubPointers { + let base_address = self.__storage_pointer_address__; + let mut current_offset = self.__storage_pointer_offset__; + let class_hash_value = starknet::storage::StoragePointer { + __storage_pointer_address__: base_address, + __storage_pointer_offset__: current_offset, + }; + Imodel_with_short_string_namespaceSafeLibraryDispatcherSubPointers { + class_hash: class_hash_value, + } + } +} +#[derive(Drop, Copy)] +pub struct Imodel_with_short_string_namespaceSafeLibraryDispatcherSubPointersMut { + pub class_hash: starknet::storage::StoragePointer>, +} +impl Imodel_with_short_string_namespaceSafeLibraryDispatcherSubPointersMutImpl of starknet::storage::SubPointersMut { + type SubPointersType = Imodel_with_short_string_namespaceSafeLibraryDispatcherSubPointersMut; + fn sub_pointers_mut(self: starknet::storage::StoragePointer>) -> Imodel_with_short_string_namespaceSafeLibraryDispatcherSubPointersMut { + let base_address = self.__storage_pointer_address__; + let mut current_offset = self.__storage_pointer_offset__; + let class_hash_value = starknet::storage::StoragePointer { + __storage_pointer_address__: base_address, + __storage_pointer_offset__: current_offset, + }; + Imodel_with_short_string_namespaceSafeLibraryDispatcherSubPointersMut { + class_hash: class_hash_value, + } + } +} +impl Imodel_with_short_string_namespaceSafeDispatcherCopy of core::traits::Copy::; +impl Imodel_with_short_string_namespaceSafeDispatcherDrop of core::traits::Drop::; +impl Imodel_with_short_string_namespaceSafeDispatcherSerde of core::serde::Serde:: { + fn serialize(self: @Imodel_with_short_string_namespaceSafeDispatcher, ref output: core::array::Array) { + core::serde::Serde::serialize(self.contract_address, ref output) + } + fn deserialize(ref serialized: core::array::Span) -> core::option::Option { + core::option::Option::Some(Imodel_with_short_string_namespaceSafeDispatcher { + contract_address: core::serde::Serde::deserialize(ref serialized)?, + }) + } +} +impl StoreImodel_with_short_string_namespaceSafeDispatcher of starknet::Store:: { + fn read(address_domain: u32, base: starknet::storage_access::StorageBaseAddress) -> starknet::SyscallResult { + let contract_address = starknet::Store::::read(address_domain, base)?; + starknet::SyscallResult::Ok( + Imodel_with_short_string_namespaceSafeDispatcher { + contract_address, + } + ) + } + fn write(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, value: Imodel_with_short_string_namespaceSafeDispatcher) -> starknet::SyscallResult<()> { + starknet::Store::::write(address_domain, base, value.contract_address)?; + starknet::SyscallResult::Ok(()) + } + fn read_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8) -> starknet::SyscallResult { + let contract_address = starknet::Store::::read_at_offset(address_domain, base, offset)?; + starknet::SyscallResult::Ok( + Imodel_with_short_string_namespaceSafeDispatcher { + contract_address, + } + ) + } + #[inline(always)] + fn write_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8, value: Imodel_with_short_string_namespaceSafeDispatcher) -> starknet::SyscallResult<()> { + starknet::Store::::write_at_offset(address_domain, base, offset, value.contract_address)?; + starknet::SyscallResult::Ok(()) + } + #[inline(always)] + fn size() -> u8 { + starknet::Store::::size() + } +} + +#[derive(Drop, Copy)] +pub struct Imodel_with_short_string_namespaceSafeDispatcherSubPointers { + pub contract_address: starknet::storage::StoragePointer, +} +impl Imodel_with_short_string_namespaceSafeDispatcherSubPointersImpl of starknet::storage::SubPointers { + type SubPointersType = Imodel_with_short_string_namespaceSafeDispatcherSubPointers; + fn sub_pointers(self: starknet::storage::StoragePointer) -> Imodel_with_short_string_namespaceSafeDispatcherSubPointers { + let base_address = self.__storage_pointer_address__; + let mut current_offset = self.__storage_pointer_offset__; + let contract_address_value = starknet::storage::StoragePointer { + __storage_pointer_address__: base_address, + __storage_pointer_offset__: current_offset, + }; + Imodel_with_short_string_namespaceSafeDispatcherSubPointers { + contract_address: contract_address_value, + } + } +} +#[derive(Drop, Copy)] +pub struct Imodel_with_short_string_namespaceSafeDispatcherSubPointersMut { + pub contract_address: starknet::storage::StoragePointer>, +} +impl Imodel_with_short_string_namespaceSafeDispatcherSubPointersMutImpl of starknet::storage::SubPointersMut { + type SubPointersType = Imodel_with_short_string_namespaceSafeDispatcherSubPointersMut; + fn sub_pointers_mut(self: starknet::storage::StoragePointer>) -> Imodel_with_short_string_namespaceSafeDispatcherSubPointersMut { + let base_address = self.__storage_pointer_address__; + let mut current_offset = self.__storage_pointer_offset__; + let contract_address_value = starknet::storage::StoragePointer { + __storage_pointer_address__: base_address, + __storage_pointer_offset__: current_offset, + }; + Imodel_with_short_string_namespaceSafeDispatcherSubPointersMut { + contract_address: contract_address_value, + } + } +} +impl Imodel_with_string_namespaceDispatcherCopy of core::traits::Copy::; +impl Imodel_with_string_namespaceDispatcherDrop of core::traits::Drop::; +impl Imodel_with_string_namespaceDispatcherSerde of core::serde::Serde:: { + fn serialize(self: @Imodel_with_string_namespaceDispatcher, ref output: core::array::Array) { + core::serde::Serde::serialize(self.contract_address, ref output) + } + fn deserialize(ref serialized: core::array::Span) -> core::option::Option { + core::option::Option::Some(Imodel_with_string_namespaceDispatcher { + contract_address: core::serde::Serde::deserialize(ref serialized)?, + }) + } +} +impl StoreImodel_with_string_namespaceDispatcher of starknet::Store:: { + fn read(address_domain: u32, base: starknet::storage_access::StorageBaseAddress) -> starknet::SyscallResult { + let contract_address = starknet::Store::::read(address_domain, base)?; + starknet::SyscallResult::Ok( + Imodel_with_string_namespaceDispatcher { + contract_address, + } + ) + } + fn write(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, value: Imodel_with_string_namespaceDispatcher) -> starknet::SyscallResult<()> { + starknet::Store::::write(address_domain, base, value.contract_address)?; + starknet::SyscallResult::Ok(()) + } + fn read_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8) -> starknet::SyscallResult { + let contract_address = starknet::Store::::read_at_offset(address_domain, base, offset)?; + starknet::SyscallResult::Ok( + Imodel_with_string_namespaceDispatcher { + contract_address, + } + ) + } + #[inline(always)] + fn write_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8, value: Imodel_with_string_namespaceDispatcher) -> starknet::SyscallResult<()> { + starknet::Store::::write_at_offset(address_domain, base, offset, value.contract_address)?; + starknet::SyscallResult::Ok(()) + } + #[inline(always)] + fn size() -> u8 { + starknet::Store::::size() + } +} + +#[derive(Drop, Copy)] +pub struct Imodel_with_string_namespaceDispatcherSubPointers { + pub contract_address: starknet::storage::StoragePointer, +} +impl Imodel_with_string_namespaceDispatcherSubPointersImpl of starknet::storage::SubPointers { + type SubPointersType = Imodel_with_string_namespaceDispatcherSubPointers; + fn sub_pointers(self: starknet::storage::StoragePointer) -> Imodel_with_string_namespaceDispatcherSubPointers { + let base_address = self.__storage_pointer_address__; + let mut current_offset = self.__storage_pointer_offset__; + let contract_address_value = starknet::storage::StoragePointer { + __storage_pointer_address__: base_address, + __storage_pointer_offset__: current_offset, + }; + Imodel_with_string_namespaceDispatcherSubPointers { + contract_address: contract_address_value, + } + } +} +#[derive(Drop, Copy)] +pub struct Imodel_with_string_namespaceDispatcherSubPointersMut { + pub contract_address: starknet::storage::StoragePointer>, +} +impl Imodel_with_string_namespaceDispatcherSubPointersMutImpl of starknet::storage::SubPointersMut { + type SubPointersType = Imodel_with_string_namespaceDispatcherSubPointersMut; + fn sub_pointers_mut(self: starknet::storage::StoragePointer>) -> Imodel_with_string_namespaceDispatcherSubPointersMut { + let base_address = self.__storage_pointer_address__; + let mut current_offset = self.__storage_pointer_offset__; + let contract_address_value = starknet::storage::StoragePointer { + __storage_pointer_address__: base_address, + __storage_pointer_offset__: current_offset, + }; + Imodel_with_string_namespaceDispatcherSubPointersMut { + contract_address: contract_address_value, + } + } +} +impl Imodel_with_string_namespaceLibraryDispatcherCopy of core::traits::Copy::; +impl Imodel_with_string_namespaceLibraryDispatcherDrop of core::traits::Drop::; +impl Imodel_with_string_namespaceLibraryDispatcherSerde of core::serde::Serde:: { + fn serialize(self: @Imodel_with_string_namespaceLibraryDispatcher, ref output: core::array::Array) { + core::serde::Serde::serialize(self.class_hash, ref output) + } + fn deserialize(ref serialized: core::array::Span) -> core::option::Option { + core::option::Option::Some(Imodel_with_string_namespaceLibraryDispatcher { + class_hash: core::serde::Serde::deserialize(ref serialized)?, + }) + } +} +impl StoreImodel_with_string_namespaceLibraryDispatcher of starknet::Store:: { + fn read(address_domain: u32, base: starknet::storage_access::StorageBaseAddress) -> starknet::SyscallResult { + let class_hash = starknet::Store::::read(address_domain, base)?; + starknet::SyscallResult::Ok( + Imodel_with_string_namespaceLibraryDispatcher { + class_hash, + } + ) + } + fn write(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, value: Imodel_with_string_namespaceLibraryDispatcher) -> starknet::SyscallResult<()> { + starknet::Store::::write(address_domain, base, value.class_hash)?; + starknet::SyscallResult::Ok(()) + } + fn read_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8) -> starknet::SyscallResult { + let class_hash = starknet::Store::::read_at_offset(address_domain, base, offset)?; + starknet::SyscallResult::Ok( + Imodel_with_string_namespaceLibraryDispatcher { + class_hash, + } + ) + } + #[inline(always)] + fn write_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8, value: Imodel_with_string_namespaceLibraryDispatcher) -> starknet::SyscallResult<()> { + starknet::Store::::write_at_offset(address_domain, base, offset, value.class_hash)?; + starknet::SyscallResult::Ok(()) + } + #[inline(always)] + fn size() -> u8 { + starknet::Store::::size() + } +} + +#[derive(Drop, Copy)] +pub struct Imodel_with_string_namespaceLibraryDispatcherSubPointers { + pub class_hash: starknet::storage::StoragePointer, +} +impl Imodel_with_string_namespaceLibraryDispatcherSubPointersImpl of starknet::storage::SubPointers { + type SubPointersType = Imodel_with_string_namespaceLibraryDispatcherSubPointers; + fn sub_pointers(self: starknet::storage::StoragePointer) -> Imodel_with_string_namespaceLibraryDispatcherSubPointers { + let base_address = self.__storage_pointer_address__; + let mut current_offset = self.__storage_pointer_offset__; + let class_hash_value = starknet::storage::StoragePointer { + __storage_pointer_address__: base_address, + __storage_pointer_offset__: current_offset, + }; + Imodel_with_string_namespaceLibraryDispatcherSubPointers { + class_hash: class_hash_value, + } + } +} +#[derive(Drop, Copy)] +pub struct Imodel_with_string_namespaceLibraryDispatcherSubPointersMut { + pub class_hash: starknet::storage::StoragePointer>, +} +impl Imodel_with_string_namespaceLibraryDispatcherSubPointersMutImpl of starknet::storage::SubPointersMut { + type SubPointersType = Imodel_with_string_namespaceLibraryDispatcherSubPointersMut; + fn sub_pointers_mut(self: starknet::storage::StoragePointer>) -> Imodel_with_string_namespaceLibraryDispatcherSubPointersMut { + let base_address = self.__storage_pointer_address__; + let mut current_offset = self.__storage_pointer_offset__; + let class_hash_value = starknet::storage::StoragePointer { + __storage_pointer_address__: base_address, + __storage_pointer_offset__: current_offset, + }; + Imodel_with_string_namespaceLibraryDispatcherSubPointersMut { + class_hash: class_hash_value, + } + } +} +impl Imodel_with_string_namespaceSafeLibraryDispatcherCopy of core::traits::Copy::; +impl Imodel_with_string_namespaceSafeLibraryDispatcherDrop of core::traits::Drop::; +impl Imodel_with_string_namespaceSafeLibraryDispatcherSerde of core::serde::Serde:: { + fn serialize(self: @Imodel_with_string_namespaceSafeLibraryDispatcher, ref output: core::array::Array) { + core::serde::Serde::serialize(self.class_hash, ref output) + } + fn deserialize(ref serialized: core::array::Span) -> core::option::Option { + core::option::Option::Some(Imodel_with_string_namespaceSafeLibraryDispatcher { + class_hash: core::serde::Serde::deserialize(ref serialized)?, + }) + } +} +impl StoreImodel_with_string_namespaceSafeLibraryDispatcher of starknet::Store:: { + fn read(address_domain: u32, base: starknet::storage_access::StorageBaseAddress) -> starknet::SyscallResult { + let class_hash = starknet::Store::::read(address_domain, base)?; + starknet::SyscallResult::Ok( + Imodel_with_string_namespaceSafeLibraryDispatcher { + class_hash, + } + ) + } + fn write(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, value: Imodel_with_string_namespaceSafeLibraryDispatcher) -> starknet::SyscallResult<()> { + starknet::Store::::write(address_domain, base, value.class_hash)?; + starknet::SyscallResult::Ok(()) + } + fn read_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8) -> starknet::SyscallResult { + let class_hash = starknet::Store::::read_at_offset(address_domain, base, offset)?; + starknet::SyscallResult::Ok( + Imodel_with_string_namespaceSafeLibraryDispatcher { + class_hash, + } + ) + } + #[inline(always)] + fn write_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8, value: Imodel_with_string_namespaceSafeLibraryDispatcher) -> starknet::SyscallResult<()> { + starknet::Store::::write_at_offset(address_domain, base, offset, value.class_hash)?; + starknet::SyscallResult::Ok(()) + } + #[inline(always)] + fn size() -> u8 { + starknet::Store::::size() + } +} + +#[derive(Drop, Copy)] +pub struct Imodel_with_string_namespaceSafeLibraryDispatcherSubPointers { + pub class_hash: starknet::storage::StoragePointer, +} +impl Imodel_with_string_namespaceSafeLibraryDispatcherSubPointersImpl of starknet::storage::SubPointers { + type SubPointersType = Imodel_with_string_namespaceSafeLibraryDispatcherSubPointers; + fn sub_pointers(self: starknet::storage::StoragePointer) -> Imodel_with_string_namespaceSafeLibraryDispatcherSubPointers { + let base_address = self.__storage_pointer_address__; + let mut current_offset = self.__storage_pointer_offset__; + let class_hash_value = starknet::storage::StoragePointer { + __storage_pointer_address__: base_address, + __storage_pointer_offset__: current_offset, + }; + Imodel_with_string_namespaceSafeLibraryDispatcherSubPointers { + class_hash: class_hash_value, + } + } +} +#[derive(Drop, Copy)] +pub struct Imodel_with_string_namespaceSafeLibraryDispatcherSubPointersMut { + pub class_hash: starknet::storage::StoragePointer>, +} +impl Imodel_with_string_namespaceSafeLibraryDispatcherSubPointersMutImpl of starknet::storage::SubPointersMut { + type SubPointersType = Imodel_with_string_namespaceSafeLibraryDispatcherSubPointersMut; + fn sub_pointers_mut(self: starknet::storage::StoragePointer>) -> Imodel_with_string_namespaceSafeLibraryDispatcherSubPointersMut { + let base_address = self.__storage_pointer_address__; + let mut current_offset = self.__storage_pointer_offset__; + let class_hash_value = starknet::storage::StoragePointer { + __storage_pointer_address__: base_address, + __storage_pointer_offset__: current_offset, + }; + Imodel_with_string_namespaceSafeLibraryDispatcherSubPointersMut { + class_hash: class_hash_value, + } + } +} +impl Imodel_with_string_namespaceSafeDispatcherCopy of core::traits::Copy::; +impl Imodel_with_string_namespaceSafeDispatcherDrop of core::traits::Drop::; +impl Imodel_with_string_namespaceSafeDispatcherSerde of core::serde::Serde:: { + fn serialize(self: @Imodel_with_string_namespaceSafeDispatcher, ref output: core::array::Array) { + core::serde::Serde::serialize(self.contract_address, ref output) + } + fn deserialize(ref serialized: core::array::Span) -> core::option::Option { + core::option::Option::Some(Imodel_with_string_namespaceSafeDispatcher { + contract_address: core::serde::Serde::deserialize(ref serialized)?, + }) + } +} +impl StoreImodel_with_string_namespaceSafeDispatcher of starknet::Store:: { + fn read(address_domain: u32, base: starknet::storage_access::StorageBaseAddress) -> starknet::SyscallResult { + let contract_address = starknet::Store::::read(address_domain, base)?; + starknet::SyscallResult::Ok( + Imodel_with_string_namespaceSafeDispatcher { + contract_address, + } + ) + } + fn write(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, value: Imodel_with_string_namespaceSafeDispatcher) -> starknet::SyscallResult<()> { + starknet::Store::::write(address_domain, base, value.contract_address)?; + starknet::SyscallResult::Ok(()) + } + fn read_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8) -> starknet::SyscallResult { + let contract_address = starknet::Store::::read_at_offset(address_domain, base, offset)?; + starknet::SyscallResult::Ok( + Imodel_with_string_namespaceSafeDispatcher { + contract_address, + } + ) + } + #[inline(always)] + fn write_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8, value: Imodel_with_string_namespaceSafeDispatcher) -> starknet::SyscallResult<()> { + starknet::Store::::write_at_offset(address_domain, base, offset, value.contract_address)?; + starknet::SyscallResult::Ok(()) + } + #[inline(always)] + fn size() -> u8 { + starknet::Store::::size() + } +} + +#[derive(Drop, Copy)] +pub struct Imodel_with_string_namespaceSafeDispatcherSubPointers { + pub contract_address: starknet::storage::StoragePointer, +} +impl Imodel_with_string_namespaceSafeDispatcherSubPointersImpl of starknet::storage::SubPointers { + type SubPointersType = Imodel_with_string_namespaceSafeDispatcherSubPointers; + fn sub_pointers(self: starknet::storage::StoragePointer) -> Imodel_with_string_namespaceSafeDispatcherSubPointers { + let base_address = self.__storage_pointer_address__; + let mut current_offset = self.__storage_pointer_offset__; + let contract_address_value = starknet::storage::StoragePointer { + __storage_pointer_address__: base_address, + __storage_pointer_offset__: current_offset, + }; + Imodel_with_string_namespaceSafeDispatcherSubPointers { + contract_address: contract_address_value, + } + } +} +#[derive(Drop, Copy)] +pub struct Imodel_with_string_namespaceSafeDispatcherSubPointersMut { + pub contract_address: starknet::storage::StoragePointer>, +} +impl Imodel_with_string_namespaceSafeDispatcherSubPointersMutImpl of starknet::storage::SubPointersMut { + type SubPointersType = Imodel_with_string_namespaceSafeDispatcherSubPointersMut; + fn sub_pointers_mut(self: starknet::storage::StoragePointer>) -> Imodel_with_string_namespaceSafeDispatcherSubPointersMut { + let base_address = self.__storage_pointer_address__; + let mut current_offset = self.__storage_pointer_offset__; + let contract_address_value = starknet::storage::StoragePointer { + __storage_pointer_address__: base_address, + __storage_pointer_offset__: current_offset, + }; + Imodel_with_string_namespaceSafeDispatcherSubPointersMut { + contract_address: contract_address_value, + } + } +} +impl IpositionDispatcherCopy of core::traits::Copy::; +impl IpositionDispatcherDrop of core::traits::Drop::; +impl IpositionDispatcherSerde of core::serde::Serde:: { + fn serialize(self: @IpositionDispatcher, ref output: core::array::Array) { + core::serde::Serde::serialize(self.contract_address, ref output) + } + fn deserialize(ref serialized: core::array::Span) -> core::option::Option { + core::option::Option::Some(IpositionDispatcher { + contract_address: core::serde::Serde::deserialize(ref serialized)?, + }) + } +} +impl StoreIpositionDispatcher of starknet::Store:: { + fn read(address_domain: u32, base: starknet::storage_access::StorageBaseAddress) -> starknet::SyscallResult { + let contract_address = starknet::Store::::read(address_domain, base)?; + starknet::SyscallResult::Ok( + IpositionDispatcher { + contract_address, + } + ) + } + fn write(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, value: IpositionDispatcher) -> starknet::SyscallResult<()> { + starknet::Store::::write(address_domain, base, value.contract_address)?; + starknet::SyscallResult::Ok(()) + } + fn read_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8) -> starknet::SyscallResult { + let contract_address = starknet::Store::::read_at_offset(address_domain, base, offset)?; + starknet::SyscallResult::Ok( + IpositionDispatcher { + contract_address, + } + ) + } + #[inline(always)] + fn write_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8, value: IpositionDispatcher) -> starknet::SyscallResult<()> { + starknet::Store::::write_at_offset(address_domain, base, offset, value.contract_address)?; + starknet::SyscallResult::Ok(()) + } + #[inline(always)] + fn size() -> u8 { + starknet::Store::::size() + } +} + +#[derive(Drop, Copy)] +pub struct IpositionDispatcherSubPointers { + pub contract_address: starknet::storage::StoragePointer, +} +impl IpositionDispatcherSubPointersImpl of starknet::storage::SubPointers { + type SubPointersType = IpositionDispatcherSubPointers; + fn sub_pointers(self: starknet::storage::StoragePointer) -> IpositionDispatcherSubPointers { + let base_address = self.__storage_pointer_address__; + let mut current_offset = self.__storage_pointer_offset__; + let contract_address_value = starknet::storage::StoragePointer { + __storage_pointer_address__: base_address, + __storage_pointer_offset__: current_offset, + }; + IpositionDispatcherSubPointers { + contract_address: contract_address_value, + } + } +} +#[derive(Drop, Copy)] +pub struct IpositionDispatcherSubPointersMut { + pub contract_address: starknet::storage::StoragePointer>, +} +impl IpositionDispatcherSubPointersMutImpl of starknet::storage::SubPointersMut { + type SubPointersType = IpositionDispatcherSubPointersMut; + fn sub_pointers_mut(self: starknet::storage::StoragePointer>) -> IpositionDispatcherSubPointersMut { + let base_address = self.__storage_pointer_address__; + let mut current_offset = self.__storage_pointer_offset__; + let contract_address_value = starknet::storage::StoragePointer { + __storage_pointer_address__: base_address, + __storage_pointer_offset__: current_offset, + }; + IpositionDispatcherSubPointersMut { + contract_address: contract_address_value, + } + } +} +impl IpositionLibraryDispatcherCopy of core::traits::Copy::; +impl IpositionLibraryDispatcherDrop of core::traits::Drop::; +impl IpositionLibraryDispatcherSerde of core::serde::Serde:: { + fn serialize(self: @IpositionLibraryDispatcher, ref output: core::array::Array) { + core::serde::Serde::serialize(self.class_hash, ref output) + } + fn deserialize(ref serialized: core::array::Span) -> core::option::Option { + core::option::Option::Some(IpositionLibraryDispatcher { + class_hash: core::serde::Serde::deserialize(ref serialized)?, + }) + } +} +impl StoreIpositionLibraryDispatcher of starknet::Store:: { + fn read(address_domain: u32, base: starknet::storage_access::StorageBaseAddress) -> starknet::SyscallResult { + let class_hash = starknet::Store::::read(address_domain, base)?; + starknet::SyscallResult::Ok( + IpositionLibraryDispatcher { + class_hash, + } + ) + } + fn write(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, value: IpositionLibraryDispatcher) -> starknet::SyscallResult<()> { + starknet::Store::::write(address_domain, base, value.class_hash)?; + starknet::SyscallResult::Ok(()) + } + fn read_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8) -> starknet::SyscallResult { + let class_hash = starknet::Store::::read_at_offset(address_domain, base, offset)?; + starknet::SyscallResult::Ok( + IpositionLibraryDispatcher { + class_hash, + } + ) + } + #[inline(always)] + fn write_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8, value: IpositionLibraryDispatcher) -> starknet::SyscallResult<()> { + starknet::Store::::write_at_offset(address_domain, base, offset, value.class_hash)?; + starknet::SyscallResult::Ok(()) + } + #[inline(always)] + fn size() -> u8 { + starknet::Store::::size() + } +} + +#[derive(Drop, Copy)] +pub struct IpositionLibraryDispatcherSubPointers { + pub class_hash: starknet::storage::StoragePointer, +} +impl IpositionLibraryDispatcherSubPointersImpl of starknet::storage::SubPointers { + type SubPointersType = IpositionLibraryDispatcherSubPointers; + fn sub_pointers(self: starknet::storage::StoragePointer) -> IpositionLibraryDispatcherSubPointers { + let base_address = self.__storage_pointer_address__; + let mut current_offset = self.__storage_pointer_offset__; + let class_hash_value = starknet::storage::StoragePointer { + __storage_pointer_address__: base_address, + __storage_pointer_offset__: current_offset, + }; + IpositionLibraryDispatcherSubPointers { + class_hash: class_hash_value, + } + } +} +#[derive(Drop, Copy)] +pub struct IpositionLibraryDispatcherSubPointersMut { + pub class_hash: starknet::storage::StoragePointer>, +} +impl IpositionLibraryDispatcherSubPointersMutImpl of starknet::storage::SubPointersMut { + type SubPointersType = IpositionLibraryDispatcherSubPointersMut; + fn sub_pointers_mut(self: starknet::storage::StoragePointer>) -> IpositionLibraryDispatcherSubPointersMut { + let base_address = self.__storage_pointer_address__; + let mut current_offset = self.__storage_pointer_offset__; + let class_hash_value = starknet::storage::StoragePointer { + __storage_pointer_address__: base_address, + __storage_pointer_offset__: current_offset, + }; + IpositionLibraryDispatcherSubPointersMut { + class_hash: class_hash_value, + } + } +} +impl IpositionSafeLibraryDispatcherCopy of core::traits::Copy::; +impl IpositionSafeLibraryDispatcherDrop of core::traits::Drop::; +impl IpositionSafeLibraryDispatcherSerde of core::serde::Serde:: { + fn serialize(self: @IpositionSafeLibraryDispatcher, ref output: core::array::Array) { + core::serde::Serde::serialize(self.class_hash, ref output) + } + fn deserialize(ref serialized: core::array::Span) -> core::option::Option { + core::option::Option::Some(IpositionSafeLibraryDispatcher { + class_hash: core::serde::Serde::deserialize(ref serialized)?, + }) + } +} +impl StoreIpositionSafeLibraryDispatcher of starknet::Store:: { + fn read(address_domain: u32, base: starknet::storage_access::StorageBaseAddress) -> starknet::SyscallResult { + let class_hash = starknet::Store::::read(address_domain, base)?; + starknet::SyscallResult::Ok( + IpositionSafeLibraryDispatcher { + class_hash, + } + ) + } + fn write(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, value: IpositionSafeLibraryDispatcher) -> starknet::SyscallResult<()> { + starknet::Store::::write(address_domain, base, value.class_hash)?; + starknet::SyscallResult::Ok(()) + } + fn read_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8) -> starknet::SyscallResult { + let class_hash = starknet::Store::::read_at_offset(address_domain, base, offset)?; + starknet::SyscallResult::Ok( + IpositionSafeLibraryDispatcher { + class_hash, + } + ) + } + #[inline(always)] + fn write_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8, value: IpositionSafeLibraryDispatcher) -> starknet::SyscallResult<()> { + starknet::Store::::write_at_offset(address_domain, base, offset, value.class_hash)?; + starknet::SyscallResult::Ok(()) + } + #[inline(always)] + fn size() -> u8 { + starknet::Store::::size() + } +} + +#[derive(Drop, Copy)] +pub struct IpositionSafeLibraryDispatcherSubPointers { + pub class_hash: starknet::storage::StoragePointer, +} +impl IpositionSafeLibraryDispatcherSubPointersImpl of starknet::storage::SubPointers { + type SubPointersType = IpositionSafeLibraryDispatcherSubPointers; + fn sub_pointers(self: starknet::storage::StoragePointer) -> IpositionSafeLibraryDispatcherSubPointers { + let base_address = self.__storage_pointer_address__; + let mut current_offset = self.__storage_pointer_offset__; + let class_hash_value = starknet::storage::StoragePointer { + __storage_pointer_address__: base_address, + __storage_pointer_offset__: current_offset, + }; + IpositionSafeLibraryDispatcherSubPointers { + class_hash: class_hash_value, + } + } +} +#[derive(Drop, Copy)] +pub struct IpositionSafeLibraryDispatcherSubPointersMut { + pub class_hash: starknet::storage::StoragePointer>, +} +impl IpositionSafeLibraryDispatcherSubPointersMutImpl of starknet::storage::SubPointersMut { + type SubPointersType = IpositionSafeLibraryDispatcherSubPointersMut; + fn sub_pointers_mut(self: starknet::storage::StoragePointer>) -> IpositionSafeLibraryDispatcherSubPointersMut { + let base_address = self.__storage_pointer_address__; + let mut current_offset = self.__storage_pointer_offset__; + let class_hash_value = starknet::storage::StoragePointer { + __storage_pointer_address__: base_address, + __storage_pointer_offset__: current_offset, + }; + IpositionSafeLibraryDispatcherSubPointersMut { + class_hash: class_hash_value, + } + } +} +impl IpositionSafeDispatcherCopy of core::traits::Copy::; +impl IpositionSafeDispatcherDrop of core::traits::Drop::; +impl IpositionSafeDispatcherSerde of core::serde::Serde:: { + fn serialize(self: @IpositionSafeDispatcher, ref output: core::array::Array) { + core::serde::Serde::serialize(self.contract_address, ref output) + } + fn deserialize(ref serialized: core::array::Span) -> core::option::Option { + core::option::Option::Some(IpositionSafeDispatcher { + contract_address: core::serde::Serde::deserialize(ref serialized)?, + }) + } +} +impl StoreIpositionSafeDispatcher of starknet::Store:: { + fn read(address_domain: u32, base: starknet::storage_access::StorageBaseAddress) -> starknet::SyscallResult { + let contract_address = starknet::Store::::read(address_domain, base)?; + starknet::SyscallResult::Ok( + IpositionSafeDispatcher { + contract_address, + } + ) + } + fn write(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, value: IpositionSafeDispatcher) -> starknet::SyscallResult<()> { + starknet::Store::::write(address_domain, base, value.contract_address)?; + starknet::SyscallResult::Ok(()) + } + fn read_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8) -> starknet::SyscallResult { + let contract_address = starknet::Store::::read_at_offset(address_domain, base, offset)?; + starknet::SyscallResult::Ok( + IpositionSafeDispatcher { + contract_address, + } + ) + } + #[inline(always)] + fn write_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8, value: IpositionSafeDispatcher) -> starknet::SyscallResult<()> { + starknet::Store::::write_at_offset(address_domain, base, offset, value.contract_address)?; + starknet::SyscallResult::Ok(()) + } + #[inline(always)] + fn size() -> u8 { + starknet::Store::::size() + } +} + +#[derive(Drop, Copy)] +pub struct IpositionSafeDispatcherSubPointers { + pub contract_address: starknet::storage::StoragePointer, +} +impl IpositionSafeDispatcherSubPointersImpl of starknet::storage::SubPointers { + type SubPointersType = IpositionSafeDispatcherSubPointers; + fn sub_pointers(self: starknet::storage::StoragePointer) -> IpositionSafeDispatcherSubPointers { + let base_address = self.__storage_pointer_address__; + let mut current_offset = self.__storage_pointer_offset__; + let contract_address_value = starknet::storage::StoragePointer { + __storage_pointer_address__: base_address, + __storage_pointer_offset__: current_offset, + }; + IpositionSafeDispatcherSubPointers { + contract_address: contract_address_value, + } + } +} +#[derive(Drop, Copy)] +pub struct IpositionSafeDispatcherSubPointersMut { + pub contract_address: starknet::storage::StoragePointer>, +} +impl IpositionSafeDispatcherSubPointersMutImpl of starknet::storage::SubPointersMut { + type SubPointersType = IpositionSafeDispatcherSubPointersMut; + fn sub_pointers_mut(self: starknet::storage::StoragePointer>) -> IpositionSafeDispatcherSubPointersMut { + let base_address = self.__storage_pointer_address__; + let mut current_offset = self.__storage_pointer_offset__; + let contract_address_value = starknet::storage::StoragePointer { + __storage_pointer_address__: base_address, + __storage_pointer_offset__: current_offset, + }; + IpositionSafeDispatcherSubPointersMut { + contract_address: contract_address_value, + } + } +} +impl IrolesDispatcherCopy of core::traits::Copy::; +impl IrolesDispatcherDrop of core::traits::Drop::; +impl IrolesDispatcherSerde of core::serde::Serde:: { + fn serialize(self: @IrolesDispatcher, ref output: core::array::Array) { + core::serde::Serde::serialize(self.contract_address, ref output) + } + fn deserialize(ref serialized: core::array::Span) -> core::option::Option { + core::option::Option::Some(IrolesDispatcher { + contract_address: core::serde::Serde::deserialize(ref serialized)?, + }) + } +} +impl StoreIrolesDispatcher of starknet::Store:: { + fn read(address_domain: u32, base: starknet::storage_access::StorageBaseAddress) -> starknet::SyscallResult { + let contract_address = starknet::Store::::read(address_domain, base)?; + starknet::SyscallResult::Ok( + IrolesDispatcher { + contract_address, + } + ) + } + fn write(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, value: IrolesDispatcher) -> starknet::SyscallResult<()> { + starknet::Store::::write(address_domain, base, value.contract_address)?; + starknet::SyscallResult::Ok(()) + } + fn read_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8) -> starknet::SyscallResult { + let contract_address = starknet::Store::::read_at_offset(address_domain, base, offset)?; + starknet::SyscallResult::Ok( + IrolesDispatcher { + contract_address, + } + ) + } + #[inline(always)] + fn write_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8, value: IrolesDispatcher) -> starknet::SyscallResult<()> { + starknet::Store::::write_at_offset(address_domain, base, offset, value.contract_address)?; + starknet::SyscallResult::Ok(()) + } + #[inline(always)] + fn size() -> u8 { + starknet::Store::::size() + } +} + +#[derive(Drop, Copy)] +pub struct IrolesDispatcherSubPointers { + pub contract_address: starknet::storage::StoragePointer, +} +impl IrolesDispatcherSubPointersImpl of starknet::storage::SubPointers { + type SubPointersType = IrolesDispatcherSubPointers; + fn sub_pointers(self: starknet::storage::StoragePointer) -> IrolesDispatcherSubPointers { + let base_address = self.__storage_pointer_address__; + let mut current_offset = self.__storage_pointer_offset__; + let contract_address_value = starknet::storage::StoragePointer { + __storage_pointer_address__: base_address, + __storage_pointer_offset__: current_offset, + }; + IrolesDispatcherSubPointers { + contract_address: contract_address_value, + } + } +} +#[derive(Drop, Copy)] +pub struct IrolesDispatcherSubPointersMut { + pub contract_address: starknet::storage::StoragePointer>, +} +impl IrolesDispatcherSubPointersMutImpl of starknet::storage::SubPointersMut { + type SubPointersType = IrolesDispatcherSubPointersMut; + fn sub_pointers_mut(self: starknet::storage::StoragePointer>) -> IrolesDispatcherSubPointersMut { + let base_address = self.__storage_pointer_address__; + let mut current_offset = self.__storage_pointer_offset__; + let contract_address_value = starknet::storage::StoragePointer { + __storage_pointer_address__: base_address, + __storage_pointer_offset__: current_offset, + }; + IrolesDispatcherSubPointersMut { + contract_address: contract_address_value, + } + } +} +impl IrolesLibraryDispatcherCopy of core::traits::Copy::; +impl IrolesLibraryDispatcherDrop of core::traits::Drop::; +impl IrolesLibraryDispatcherSerde of core::serde::Serde:: { + fn serialize(self: @IrolesLibraryDispatcher, ref output: core::array::Array) { + core::serde::Serde::serialize(self.class_hash, ref output) + } + fn deserialize(ref serialized: core::array::Span) -> core::option::Option { + core::option::Option::Some(IrolesLibraryDispatcher { + class_hash: core::serde::Serde::deserialize(ref serialized)?, + }) + } +} +impl StoreIrolesLibraryDispatcher of starknet::Store:: { + fn read(address_domain: u32, base: starknet::storage_access::StorageBaseAddress) -> starknet::SyscallResult { + let class_hash = starknet::Store::::read(address_domain, base)?; + starknet::SyscallResult::Ok( + IrolesLibraryDispatcher { + class_hash, + } + ) + } + fn write(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, value: IrolesLibraryDispatcher) -> starknet::SyscallResult<()> { + starknet::Store::::write(address_domain, base, value.class_hash)?; + starknet::SyscallResult::Ok(()) + } + fn read_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8) -> starknet::SyscallResult { + let class_hash = starknet::Store::::read_at_offset(address_domain, base, offset)?; + starknet::SyscallResult::Ok( + IrolesLibraryDispatcher { + class_hash, + } + ) + } + #[inline(always)] + fn write_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8, value: IrolesLibraryDispatcher) -> starknet::SyscallResult<()> { + starknet::Store::::write_at_offset(address_domain, base, offset, value.class_hash)?; + starknet::SyscallResult::Ok(()) + } + #[inline(always)] + fn size() -> u8 { + starknet::Store::::size() + } +} + +#[derive(Drop, Copy)] +pub struct IrolesLibraryDispatcherSubPointers { + pub class_hash: starknet::storage::StoragePointer, +} +impl IrolesLibraryDispatcherSubPointersImpl of starknet::storage::SubPointers { + type SubPointersType = IrolesLibraryDispatcherSubPointers; + fn sub_pointers(self: starknet::storage::StoragePointer) -> IrolesLibraryDispatcherSubPointers { + let base_address = self.__storage_pointer_address__; + let mut current_offset = self.__storage_pointer_offset__; + let class_hash_value = starknet::storage::StoragePointer { + __storage_pointer_address__: base_address, + __storage_pointer_offset__: current_offset, + }; + IrolesLibraryDispatcherSubPointers { + class_hash: class_hash_value, + } + } +} +#[derive(Drop, Copy)] +pub struct IrolesLibraryDispatcherSubPointersMut { + pub class_hash: starknet::storage::StoragePointer>, +} +impl IrolesLibraryDispatcherSubPointersMutImpl of starknet::storage::SubPointersMut { + type SubPointersType = IrolesLibraryDispatcherSubPointersMut; + fn sub_pointers_mut(self: starknet::storage::StoragePointer>) -> IrolesLibraryDispatcherSubPointersMut { + let base_address = self.__storage_pointer_address__; + let mut current_offset = self.__storage_pointer_offset__; + let class_hash_value = starknet::storage::StoragePointer { + __storage_pointer_address__: base_address, + __storage_pointer_offset__: current_offset, + }; + IrolesLibraryDispatcherSubPointersMut { + class_hash: class_hash_value, + } + } +} +impl IrolesSafeLibraryDispatcherCopy of core::traits::Copy::; +impl IrolesSafeLibraryDispatcherDrop of core::traits::Drop::; +impl IrolesSafeLibraryDispatcherSerde of core::serde::Serde:: { + fn serialize(self: @IrolesSafeLibraryDispatcher, ref output: core::array::Array) { + core::serde::Serde::serialize(self.class_hash, ref output) + } + fn deserialize(ref serialized: core::array::Span) -> core::option::Option { + core::option::Option::Some(IrolesSafeLibraryDispatcher { + class_hash: core::serde::Serde::deserialize(ref serialized)?, + }) + } +} +impl StoreIrolesSafeLibraryDispatcher of starknet::Store:: { + fn read(address_domain: u32, base: starknet::storage_access::StorageBaseAddress) -> starknet::SyscallResult { + let class_hash = starknet::Store::::read(address_domain, base)?; + starknet::SyscallResult::Ok( + IrolesSafeLibraryDispatcher { + class_hash, + } + ) + } + fn write(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, value: IrolesSafeLibraryDispatcher) -> starknet::SyscallResult<()> { + starknet::Store::::write(address_domain, base, value.class_hash)?; + starknet::SyscallResult::Ok(()) + } + fn read_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8) -> starknet::SyscallResult { + let class_hash = starknet::Store::::read_at_offset(address_domain, base, offset)?; + starknet::SyscallResult::Ok( + IrolesSafeLibraryDispatcher { + class_hash, + } + ) + } + #[inline(always)] + fn write_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8, value: IrolesSafeLibraryDispatcher) -> starknet::SyscallResult<()> { + starknet::Store::::write_at_offset(address_domain, base, offset, value.class_hash)?; + starknet::SyscallResult::Ok(()) + } + #[inline(always)] + fn size() -> u8 { + starknet::Store::::size() + } +} + +#[derive(Drop, Copy)] +pub struct IrolesSafeLibraryDispatcherSubPointers { + pub class_hash: starknet::storage::StoragePointer, +} +impl IrolesSafeLibraryDispatcherSubPointersImpl of starknet::storage::SubPointers { + type SubPointersType = IrolesSafeLibraryDispatcherSubPointers; + fn sub_pointers(self: starknet::storage::StoragePointer) -> IrolesSafeLibraryDispatcherSubPointers { + let base_address = self.__storage_pointer_address__; + let mut current_offset = self.__storage_pointer_offset__; + let class_hash_value = starknet::storage::StoragePointer { + __storage_pointer_address__: base_address, + __storage_pointer_offset__: current_offset, + }; + IrolesSafeLibraryDispatcherSubPointers { + class_hash: class_hash_value, + } + } +} +#[derive(Drop, Copy)] +pub struct IrolesSafeLibraryDispatcherSubPointersMut { + pub class_hash: starknet::storage::StoragePointer>, +} +impl IrolesSafeLibraryDispatcherSubPointersMutImpl of starknet::storage::SubPointersMut { + type SubPointersType = IrolesSafeLibraryDispatcherSubPointersMut; + fn sub_pointers_mut(self: starknet::storage::StoragePointer>) -> IrolesSafeLibraryDispatcherSubPointersMut { + let base_address = self.__storage_pointer_address__; + let mut current_offset = self.__storage_pointer_offset__; + let class_hash_value = starknet::storage::StoragePointer { + __storage_pointer_address__: base_address, + __storage_pointer_offset__: current_offset, + }; + IrolesSafeLibraryDispatcherSubPointersMut { + class_hash: class_hash_value, + } + } +} +impl IrolesSafeDispatcherCopy of core::traits::Copy::; +impl IrolesSafeDispatcherDrop of core::traits::Drop::; +impl IrolesSafeDispatcherSerde of core::serde::Serde:: { + fn serialize(self: @IrolesSafeDispatcher, ref output: core::array::Array) { + core::serde::Serde::serialize(self.contract_address, ref output) + } + fn deserialize(ref serialized: core::array::Span) -> core::option::Option { + core::option::Option::Some(IrolesSafeDispatcher { + contract_address: core::serde::Serde::deserialize(ref serialized)?, + }) + } +} +impl StoreIrolesSafeDispatcher of starknet::Store:: { + fn read(address_domain: u32, base: starknet::storage_access::StorageBaseAddress) -> starknet::SyscallResult { + let contract_address = starknet::Store::::read(address_domain, base)?; + starknet::SyscallResult::Ok( + IrolesSafeDispatcher { + contract_address, + } + ) + } + fn write(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, value: IrolesSafeDispatcher) -> starknet::SyscallResult<()> { + starknet::Store::::write(address_domain, base, value.contract_address)?; + starknet::SyscallResult::Ok(()) + } + fn read_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8) -> starknet::SyscallResult { + let contract_address = starknet::Store::::read_at_offset(address_domain, base, offset)?; + starknet::SyscallResult::Ok( + IrolesSafeDispatcher { + contract_address, + } + ) + } + #[inline(always)] + fn write_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8, value: IrolesSafeDispatcher) -> starknet::SyscallResult<()> { + starknet::Store::::write_at_offset(address_domain, base, offset, value.contract_address)?; + starknet::SyscallResult::Ok(()) + } + #[inline(always)] + fn size() -> u8 { + starknet::Store::::size() + } +} + +#[derive(Drop, Copy)] +pub struct IrolesSafeDispatcherSubPointers { + pub contract_address: starknet::storage::StoragePointer, +} +impl IrolesSafeDispatcherSubPointersImpl of starknet::storage::SubPointers { + type SubPointersType = IrolesSafeDispatcherSubPointers; + fn sub_pointers(self: starknet::storage::StoragePointer) -> IrolesSafeDispatcherSubPointers { + let base_address = self.__storage_pointer_address__; + let mut current_offset = self.__storage_pointer_offset__; + let contract_address_value = starknet::storage::StoragePointer { + __storage_pointer_address__: base_address, + __storage_pointer_offset__: current_offset, + }; + IrolesSafeDispatcherSubPointers { + contract_address: contract_address_value, + } + } +} +#[derive(Drop, Copy)] +pub struct IrolesSafeDispatcherSubPointersMut { + pub contract_address: starknet::storage::StoragePointer>, +} +impl IrolesSafeDispatcherSubPointersMutImpl of starknet::storage::SubPointersMut { + type SubPointersType = IrolesSafeDispatcherSubPointersMut; + fn sub_pointers_mut(self: starknet::storage::StoragePointer>) -> IrolesSafeDispatcherSubPointersMut { + let base_address = self.__storage_pointer_address__; + let mut current_offset = self.__storage_pointer_offset__; + let contract_address_value = starknet::storage::StoragePointer { + __storage_pointer_address__: base_address, + __storage_pointer_offset__: current_offset, + }; + IrolesSafeDispatcherSubPointersMut { + contract_address: contract_address_value, + } + } +} +impl Ionly_key_modelDispatcherCopy of core::traits::Copy::; +impl Ionly_key_modelDispatcherDrop of core::traits::Drop::; +impl Ionly_key_modelDispatcherSerde of core::serde::Serde:: { + fn serialize(self: @Ionly_key_modelDispatcher, ref output: core::array::Array) { + core::serde::Serde::serialize(self.contract_address, ref output) + } + fn deserialize(ref serialized: core::array::Span) -> core::option::Option { + core::option::Option::Some(Ionly_key_modelDispatcher { + contract_address: core::serde::Serde::deserialize(ref serialized)?, + }) + } +} +impl StoreIonly_key_modelDispatcher of starknet::Store:: { + fn read(address_domain: u32, base: starknet::storage_access::StorageBaseAddress) -> starknet::SyscallResult { + let contract_address = starknet::Store::::read(address_domain, base)?; + starknet::SyscallResult::Ok( + Ionly_key_modelDispatcher { + contract_address, + } + ) + } + fn write(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, value: Ionly_key_modelDispatcher) -> starknet::SyscallResult<()> { + starknet::Store::::write(address_domain, base, value.contract_address)?; + starknet::SyscallResult::Ok(()) + } + fn read_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8) -> starknet::SyscallResult { + let contract_address = starknet::Store::::read_at_offset(address_domain, base, offset)?; + starknet::SyscallResult::Ok( + Ionly_key_modelDispatcher { + contract_address, + } + ) + } + #[inline(always)] + fn write_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8, value: Ionly_key_modelDispatcher) -> starknet::SyscallResult<()> { + starknet::Store::::write_at_offset(address_domain, base, offset, value.contract_address)?; + starknet::SyscallResult::Ok(()) + } + #[inline(always)] + fn size() -> u8 { + starknet::Store::::size() + } +} + +#[derive(Drop, Copy)] +pub struct Ionly_key_modelDispatcherSubPointers { + pub contract_address: starknet::storage::StoragePointer, +} +impl Ionly_key_modelDispatcherSubPointersImpl of starknet::storage::SubPointers { + type SubPointersType = Ionly_key_modelDispatcherSubPointers; + fn sub_pointers(self: starknet::storage::StoragePointer) -> Ionly_key_modelDispatcherSubPointers { + let base_address = self.__storage_pointer_address__; + let mut current_offset = self.__storage_pointer_offset__; + let contract_address_value = starknet::storage::StoragePointer { + __storage_pointer_address__: base_address, + __storage_pointer_offset__: current_offset, + }; + Ionly_key_modelDispatcherSubPointers { + contract_address: contract_address_value, + } + } +} +#[derive(Drop, Copy)] +pub struct Ionly_key_modelDispatcherSubPointersMut { + pub contract_address: starknet::storage::StoragePointer>, +} +impl Ionly_key_modelDispatcherSubPointersMutImpl of starknet::storage::SubPointersMut { + type SubPointersType = Ionly_key_modelDispatcherSubPointersMut; + fn sub_pointers_mut(self: starknet::storage::StoragePointer>) -> Ionly_key_modelDispatcherSubPointersMut { + let base_address = self.__storage_pointer_address__; + let mut current_offset = self.__storage_pointer_offset__; + let contract_address_value = starknet::storage::StoragePointer { + __storage_pointer_address__: base_address, + __storage_pointer_offset__: current_offset, + }; + Ionly_key_modelDispatcherSubPointersMut { + contract_address: contract_address_value, + } + } +} +impl Ionly_key_modelLibraryDispatcherCopy of core::traits::Copy::; +impl Ionly_key_modelLibraryDispatcherDrop of core::traits::Drop::; +impl Ionly_key_modelLibraryDispatcherSerde of core::serde::Serde:: { + fn serialize(self: @Ionly_key_modelLibraryDispatcher, ref output: core::array::Array) { + core::serde::Serde::serialize(self.class_hash, ref output) + } + fn deserialize(ref serialized: core::array::Span) -> core::option::Option { + core::option::Option::Some(Ionly_key_modelLibraryDispatcher { + class_hash: core::serde::Serde::deserialize(ref serialized)?, + }) + } +} +impl StoreIonly_key_modelLibraryDispatcher of starknet::Store:: { + fn read(address_domain: u32, base: starknet::storage_access::StorageBaseAddress) -> starknet::SyscallResult { + let class_hash = starknet::Store::::read(address_domain, base)?; + starknet::SyscallResult::Ok( + Ionly_key_modelLibraryDispatcher { + class_hash, + } + ) + } + fn write(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, value: Ionly_key_modelLibraryDispatcher) -> starknet::SyscallResult<()> { + starknet::Store::::write(address_domain, base, value.class_hash)?; + starknet::SyscallResult::Ok(()) + } + fn read_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8) -> starknet::SyscallResult { + let class_hash = starknet::Store::::read_at_offset(address_domain, base, offset)?; + starknet::SyscallResult::Ok( + Ionly_key_modelLibraryDispatcher { + class_hash, + } + ) + } + #[inline(always)] + fn write_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8, value: Ionly_key_modelLibraryDispatcher) -> starknet::SyscallResult<()> { + starknet::Store::::write_at_offset(address_domain, base, offset, value.class_hash)?; + starknet::SyscallResult::Ok(()) + } + #[inline(always)] + fn size() -> u8 { + starknet::Store::::size() + } +} + +#[derive(Drop, Copy)] +pub struct Ionly_key_modelLibraryDispatcherSubPointers { + pub class_hash: starknet::storage::StoragePointer, +} +impl Ionly_key_modelLibraryDispatcherSubPointersImpl of starknet::storage::SubPointers { + type SubPointersType = Ionly_key_modelLibraryDispatcherSubPointers; + fn sub_pointers(self: starknet::storage::StoragePointer) -> Ionly_key_modelLibraryDispatcherSubPointers { + let base_address = self.__storage_pointer_address__; + let mut current_offset = self.__storage_pointer_offset__; + let class_hash_value = starknet::storage::StoragePointer { + __storage_pointer_address__: base_address, + __storage_pointer_offset__: current_offset, + }; + Ionly_key_modelLibraryDispatcherSubPointers { + class_hash: class_hash_value, + } + } +} +#[derive(Drop, Copy)] +pub struct Ionly_key_modelLibraryDispatcherSubPointersMut { + pub class_hash: starknet::storage::StoragePointer>, +} +impl Ionly_key_modelLibraryDispatcherSubPointersMutImpl of starknet::storage::SubPointersMut { + type SubPointersType = Ionly_key_modelLibraryDispatcherSubPointersMut; + fn sub_pointers_mut(self: starknet::storage::StoragePointer>) -> Ionly_key_modelLibraryDispatcherSubPointersMut { + let base_address = self.__storage_pointer_address__; + let mut current_offset = self.__storage_pointer_offset__; + let class_hash_value = starknet::storage::StoragePointer { + __storage_pointer_address__: base_address, + __storage_pointer_offset__: current_offset, + }; + Ionly_key_modelLibraryDispatcherSubPointersMut { + class_hash: class_hash_value, + } + } +} +impl Ionly_key_modelSafeLibraryDispatcherCopy of core::traits::Copy::; +impl Ionly_key_modelSafeLibraryDispatcherDrop of core::traits::Drop::; +impl Ionly_key_modelSafeLibraryDispatcherSerde of core::serde::Serde:: { + fn serialize(self: @Ionly_key_modelSafeLibraryDispatcher, ref output: core::array::Array) { + core::serde::Serde::serialize(self.class_hash, ref output) + } + fn deserialize(ref serialized: core::array::Span) -> core::option::Option { + core::option::Option::Some(Ionly_key_modelSafeLibraryDispatcher { + class_hash: core::serde::Serde::deserialize(ref serialized)?, + }) + } +} +impl StoreIonly_key_modelSafeLibraryDispatcher of starknet::Store:: { + fn read(address_domain: u32, base: starknet::storage_access::StorageBaseAddress) -> starknet::SyscallResult { + let class_hash = starknet::Store::::read(address_domain, base)?; + starknet::SyscallResult::Ok( + Ionly_key_modelSafeLibraryDispatcher { + class_hash, + } + ) + } + fn write(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, value: Ionly_key_modelSafeLibraryDispatcher) -> starknet::SyscallResult<()> { + starknet::Store::::write(address_domain, base, value.class_hash)?; + starknet::SyscallResult::Ok(()) + } + fn read_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8) -> starknet::SyscallResult { + let class_hash = starknet::Store::::read_at_offset(address_domain, base, offset)?; + starknet::SyscallResult::Ok( + Ionly_key_modelSafeLibraryDispatcher { + class_hash, + } + ) + } + #[inline(always)] + fn write_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8, value: Ionly_key_modelSafeLibraryDispatcher) -> starknet::SyscallResult<()> { + starknet::Store::::write_at_offset(address_domain, base, offset, value.class_hash)?; + starknet::SyscallResult::Ok(()) + } + #[inline(always)] + fn size() -> u8 { + starknet::Store::::size() + } +} + +#[derive(Drop, Copy)] +pub struct Ionly_key_modelSafeLibraryDispatcherSubPointers { + pub class_hash: starknet::storage::StoragePointer, +} +impl Ionly_key_modelSafeLibraryDispatcherSubPointersImpl of starknet::storage::SubPointers { + type SubPointersType = Ionly_key_modelSafeLibraryDispatcherSubPointers; + fn sub_pointers(self: starknet::storage::StoragePointer) -> Ionly_key_modelSafeLibraryDispatcherSubPointers { + let base_address = self.__storage_pointer_address__; + let mut current_offset = self.__storage_pointer_offset__; + let class_hash_value = starknet::storage::StoragePointer { + __storage_pointer_address__: base_address, + __storage_pointer_offset__: current_offset, + }; + Ionly_key_modelSafeLibraryDispatcherSubPointers { + class_hash: class_hash_value, + } + } +} +#[derive(Drop, Copy)] +pub struct Ionly_key_modelSafeLibraryDispatcherSubPointersMut { + pub class_hash: starknet::storage::StoragePointer>, +} +impl Ionly_key_modelSafeLibraryDispatcherSubPointersMutImpl of starknet::storage::SubPointersMut { + type SubPointersType = Ionly_key_modelSafeLibraryDispatcherSubPointersMut; + fn sub_pointers_mut(self: starknet::storage::StoragePointer>) -> Ionly_key_modelSafeLibraryDispatcherSubPointersMut { + let base_address = self.__storage_pointer_address__; + let mut current_offset = self.__storage_pointer_offset__; + let class_hash_value = starknet::storage::StoragePointer { + __storage_pointer_address__: base_address, + __storage_pointer_offset__: current_offset, + }; + Ionly_key_modelSafeLibraryDispatcherSubPointersMut { + class_hash: class_hash_value, + } + } +} +impl Ionly_key_modelSafeDispatcherCopy of core::traits::Copy::; +impl Ionly_key_modelSafeDispatcherDrop of core::traits::Drop::; +impl Ionly_key_modelSafeDispatcherSerde of core::serde::Serde:: { + fn serialize(self: @Ionly_key_modelSafeDispatcher, ref output: core::array::Array) { + core::serde::Serde::serialize(self.contract_address, ref output) + } + fn deserialize(ref serialized: core::array::Span) -> core::option::Option { + core::option::Option::Some(Ionly_key_modelSafeDispatcher { + contract_address: core::serde::Serde::deserialize(ref serialized)?, + }) + } +} +impl StoreIonly_key_modelSafeDispatcher of starknet::Store:: { + fn read(address_domain: u32, base: starknet::storage_access::StorageBaseAddress) -> starknet::SyscallResult { + let contract_address = starknet::Store::::read(address_domain, base)?; + starknet::SyscallResult::Ok( + Ionly_key_modelSafeDispatcher { + contract_address, + } + ) + } + fn write(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, value: Ionly_key_modelSafeDispatcher) -> starknet::SyscallResult<()> { + starknet::Store::::write(address_domain, base, value.contract_address)?; + starknet::SyscallResult::Ok(()) + } + fn read_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8) -> starknet::SyscallResult { + let contract_address = starknet::Store::::read_at_offset(address_domain, base, offset)?; + starknet::SyscallResult::Ok( + Ionly_key_modelSafeDispatcher { + contract_address, + } + ) + } + #[inline(always)] + fn write_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8, value: Ionly_key_modelSafeDispatcher) -> starknet::SyscallResult<()> { + starknet::Store::::write_at_offset(address_domain, base, offset, value.contract_address)?; + starknet::SyscallResult::Ok(()) + } + #[inline(always)] + fn size() -> u8 { + starknet::Store::::size() + } +} + +#[derive(Drop, Copy)] +pub struct Ionly_key_modelSafeDispatcherSubPointers { + pub contract_address: starknet::storage::StoragePointer, +} +impl Ionly_key_modelSafeDispatcherSubPointersImpl of starknet::storage::SubPointers { + type SubPointersType = Ionly_key_modelSafeDispatcherSubPointers; + fn sub_pointers(self: starknet::storage::StoragePointer) -> Ionly_key_modelSafeDispatcherSubPointers { + let base_address = self.__storage_pointer_address__; + let mut current_offset = self.__storage_pointer_offset__; + let contract_address_value = starknet::storage::StoragePointer { + __storage_pointer_address__: base_address, + __storage_pointer_offset__: current_offset, + }; + Ionly_key_modelSafeDispatcherSubPointers { + contract_address: contract_address_value, + } + } +} +#[derive(Drop, Copy)] +pub struct Ionly_key_modelSafeDispatcherSubPointersMut { + pub contract_address: starknet::storage::StoragePointer>, +} +impl Ionly_key_modelSafeDispatcherSubPointersMutImpl of starknet::storage::SubPointersMut { + type SubPointersType = Ionly_key_modelSafeDispatcherSubPointersMut; + fn sub_pointers_mut(self: starknet::storage::StoragePointer>) -> Ionly_key_modelSafeDispatcherSubPointersMut { + let base_address = self.__storage_pointer_address__; + let mut current_offset = self.__storage_pointer_offset__; + let contract_address_value = starknet::storage::StoragePointer { + __storage_pointer_address__: base_address, + __storage_pointer_offset__: current_offset, + }; + Ionly_key_modelSafeDispatcherSubPointersMut { + contract_address: contract_address_value, + } + } +} +impl Iu_256_key_modelDispatcherCopy of core::traits::Copy::; +impl Iu_256_key_modelDispatcherDrop of core::traits::Drop::; +impl Iu_256_key_modelDispatcherSerde of core::serde::Serde:: { + fn serialize(self: @Iu_256_key_modelDispatcher, ref output: core::array::Array) { + core::serde::Serde::serialize(self.contract_address, ref output) + } + fn deserialize(ref serialized: core::array::Span) -> core::option::Option { + core::option::Option::Some(Iu_256_key_modelDispatcher { + contract_address: core::serde::Serde::deserialize(ref serialized)?, + }) + } +} +impl StoreIu_256_key_modelDispatcher of starknet::Store:: { + fn read(address_domain: u32, base: starknet::storage_access::StorageBaseAddress) -> starknet::SyscallResult { + let contract_address = starknet::Store::::read(address_domain, base)?; + starknet::SyscallResult::Ok( + Iu_256_key_modelDispatcher { + contract_address, + } + ) + } + fn write(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, value: Iu_256_key_modelDispatcher) -> starknet::SyscallResult<()> { + starknet::Store::::write(address_domain, base, value.contract_address)?; + starknet::SyscallResult::Ok(()) + } + fn read_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8) -> starknet::SyscallResult { + let contract_address = starknet::Store::::read_at_offset(address_domain, base, offset)?; + starknet::SyscallResult::Ok( + Iu_256_key_modelDispatcher { + contract_address, + } + ) + } + #[inline(always)] + fn write_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8, value: Iu_256_key_modelDispatcher) -> starknet::SyscallResult<()> { + starknet::Store::::write_at_offset(address_domain, base, offset, value.contract_address)?; + starknet::SyscallResult::Ok(()) + } + #[inline(always)] + fn size() -> u8 { + starknet::Store::::size() + } +} + +#[derive(Drop, Copy)] +pub struct Iu_256_key_modelDispatcherSubPointers { + pub contract_address: starknet::storage::StoragePointer, +} +impl Iu_256_key_modelDispatcherSubPointersImpl of starknet::storage::SubPointers { + type SubPointersType = Iu_256_key_modelDispatcherSubPointers; + fn sub_pointers(self: starknet::storage::StoragePointer) -> Iu_256_key_modelDispatcherSubPointers { + let base_address = self.__storage_pointer_address__; + let mut current_offset = self.__storage_pointer_offset__; + let contract_address_value = starknet::storage::StoragePointer { + __storage_pointer_address__: base_address, + __storage_pointer_offset__: current_offset, + }; + Iu_256_key_modelDispatcherSubPointers { + contract_address: contract_address_value, + } + } +} +#[derive(Drop, Copy)] +pub struct Iu_256_key_modelDispatcherSubPointersMut { + pub contract_address: starknet::storage::StoragePointer>, +} +impl Iu_256_key_modelDispatcherSubPointersMutImpl of starknet::storage::SubPointersMut { + type SubPointersType = Iu_256_key_modelDispatcherSubPointersMut; + fn sub_pointers_mut(self: starknet::storage::StoragePointer>) -> Iu_256_key_modelDispatcherSubPointersMut { + let base_address = self.__storage_pointer_address__; + let mut current_offset = self.__storage_pointer_offset__; + let contract_address_value = starknet::storage::StoragePointer { + __storage_pointer_address__: base_address, + __storage_pointer_offset__: current_offset, + }; + Iu_256_key_modelDispatcherSubPointersMut { + contract_address: contract_address_value, + } + } +} +impl Iu_256_key_modelLibraryDispatcherCopy of core::traits::Copy::; +impl Iu_256_key_modelLibraryDispatcherDrop of core::traits::Drop::; +impl Iu_256_key_modelLibraryDispatcherSerde of core::serde::Serde:: { + fn serialize(self: @Iu_256_key_modelLibraryDispatcher, ref output: core::array::Array) { + core::serde::Serde::serialize(self.class_hash, ref output) + } + fn deserialize(ref serialized: core::array::Span) -> core::option::Option { + core::option::Option::Some(Iu_256_key_modelLibraryDispatcher { + class_hash: core::serde::Serde::deserialize(ref serialized)?, + }) + } +} +impl StoreIu_256_key_modelLibraryDispatcher of starknet::Store:: { + fn read(address_domain: u32, base: starknet::storage_access::StorageBaseAddress) -> starknet::SyscallResult { + let class_hash = starknet::Store::::read(address_domain, base)?; + starknet::SyscallResult::Ok( + Iu_256_key_modelLibraryDispatcher { + class_hash, + } + ) + } + fn write(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, value: Iu_256_key_modelLibraryDispatcher) -> starknet::SyscallResult<()> { + starknet::Store::::write(address_domain, base, value.class_hash)?; + starknet::SyscallResult::Ok(()) + } + fn read_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8) -> starknet::SyscallResult { + let class_hash = starknet::Store::::read_at_offset(address_domain, base, offset)?; + starknet::SyscallResult::Ok( + Iu_256_key_modelLibraryDispatcher { + class_hash, + } + ) + } + #[inline(always)] + fn write_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8, value: Iu_256_key_modelLibraryDispatcher) -> starknet::SyscallResult<()> { + starknet::Store::::write_at_offset(address_domain, base, offset, value.class_hash)?; + starknet::SyscallResult::Ok(()) + } + #[inline(always)] + fn size() -> u8 { + starknet::Store::::size() + } +} + +#[derive(Drop, Copy)] +pub struct Iu_256_key_modelLibraryDispatcherSubPointers { + pub class_hash: starknet::storage::StoragePointer, +} +impl Iu_256_key_modelLibraryDispatcherSubPointersImpl of starknet::storage::SubPointers { + type SubPointersType = Iu_256_key_modelLibraryDispatcherSubPointers; + fn sub_pointers(self: starknet::storage::StoragePointer) -> Iu_256_key_modelLibraryDispatcherSubPointers { + let base_address = self.__storage_pointer_address__; + let mut current_offset = self.__storage_pointer_offset__; + let class_hash_value = starknet::storage::StoragePointer { + __storage_pointer_address__: base_address, + __storage_pointer_offset__: current_offset, + }; + Iu_256_key_modelLibraryDispatcherSubPointers { + class_hash: class_hash_value, + } + } +} +#[derive(Drop, Copy)] +pub struct Iu_256_key_modelLibraryDispatcherSubPointersMut { + pub class_hash: starknet::storage::StoragePointer>, +} +impl Iu_256_key_modelLibraryDispatcherSubPointersMutImpl of starknet::storage::SubPointersMut { + type SubPointersType = Iu_256_key_modelLibraryDispatcherSubPointersMut; + fn sub_pointers_mut(self: starknet::storage::StoragePointer>) -> Iu_256_key_modelLibraryDispatcherSubPointersMut { + let base_address = self.__storage_pointer_address__; + let mut current_offset = self.__storage_pointer_offset__; + let class_hash_value = starknet::storage::StoragePointer { + __storage_pointer_address__: base_address, + __storage_pointer_offset__: current_offset, + }; + Iu_256_key_modelLibraryDispatcherSubPointersMut { + class_hash: class_hash_value, + } + } +} +impl Iu_256_key_modelSafeLibraryDispatcherCopy of core::traits::Copy::; +impl Iu_256_key_modelSafeLibraryDispatcherDrop of core::traits::Drop::; +impl Iu_256_key_modelSafeLibraryDispatcherSerde of core::serde::Serde:: { + fn serialize(self: @Iu_256_key_modelSafeLibraryDispatcher, ref output: core::array::Array) { + core::serde::Serde::serialize(self.class_hash, ref output) + } + fn deserialize(ref serialized: core::array::Span) -> core::option::Option { + core::option::Option::Some(Iu_256_key_modelSafeLibraryDispatcher { + class_hash: core::serde::Serde::deserialize(ref serialized)?, + }) + } +} +impl StoreIu_256_key_modelSafeLibraryDispatcher of starknet::Store:: { + fn read(address_domain: u32, base: starknet::storage_access::StorageBaseAddress) -> starknet::SyscallResult { + let class_hash = starknet::Store::::read(address_domain, base)?; + starknet::SyscallResult::Ok( + Iu_256_key_modelSafeLibraryDispatcher { + class_hash, + } + ) + } + fn write(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, value: Iu_256_key_modelSafeLibraryDispatcher) -> starknet::SyscallResult<()> { + starknet::Store::::write(address_domain, base, value.class_hash)?; + starknet::SyscallResult::Ok(()) + } + fn read_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8) -> starknet::SyscallResult { + let class_hash = starknet::Store::::read_at_offset(address_domain, base, offset)?; + starknet::SyscallResult::Ok( + Iu_256_key_modelSafeLibraryDispatcher { + class_hash, + } + ) + } + #[inline(always)] + fn write_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8, value: Iu_256_key_modelSafeLibraryDispatcher) -> starknet::SyscallResult<()> { + starknet::Store::::write_at_offset(address_domain, base, offset, value.class_hash)?; + starknet::SyscallResult::Ok(()) + } + #[inline(always)] + fn size() -> u8 { + starknet::Store::::size() + } +} + +#[derive(Drop, Copy)] +pub struct Iu_256_key_modelSafeLibraryDispatcherSubPointers { + pub class_hash: starknet::storage::StoragePointer, +} +impl Iu_256_key_modelSafeLibraryDispatcherSubPointersImpl of starknet::storage::SubPointers { + type SubPointersType = Iu_256_key_modelSafeLibraryDispatcherSubPointers; + fn sub_pointers(self: starknet::storage::StoragePointer) -> Iu_256_key_modelSafeLibraryDispatcherSubPointers { + let base_address = self.__storage_pointer_address__; + let mut current_offset = self.__storage_pointer_offset__; + let class_hash_value = starknet::storage::StoragePointer { + __storage_pointer_address__: base_address, + __storage_pointer_offset__: current_offset, + }; + Iu_256_key_modelSafeLibraryDispatcherSubPointers { + class_hash: class_hash_value, + } + } +} +#[derive(Drop, Copy)] +pub struct Iu_256_key_modelSafeLibraryDispatcherSubPointersMut { + pub class_hash: starknet::storage::StoragePointer>, +} +impl Iu_256_key_modelSafeLibraryDispatcherSubPointersMutImpl of starknet::storage::SubPointersMut { + type SubPointersType = Iu_256_key_modelSafeLibraryDispatcherSubPointersMut; + fn sub_pointers_mut(self: starknet::storage::StoragePointer>) -> Iu_256_key_modelSafeLibraryDispatcherSubPointersMut { + let base_address = self.__storage_pointer_address__; + let mut current_offset = self.__storage_pointer_offset__; + let class_hash_value = starknet::storage::StoragePointer { + __storage_pointer_address__: base_address, + __storage_pointer_offset__: current_offset, + }; + Iu_256_key_modelSafeLibraryDispatcherSubPointersMut { + class_hash: class_hash_value, + } + } +} +impl Iu_256_key_modelSafeDispatcherCopy of core::traits::Copy::; +impl Iu_256_key_modelSafeDispatcherDrop of core::traits::Drop::; +impl Iu_256_key_modelSafeDispatcherSerde of core::serde::Serde:: { + fn serialize(self: @Iu_256_key_modelSafeDispatcher, ref output: core::array::Array) { + core::serde::Serde::serialize(self.contract_address, ref output) + } + fn deserialize(ref serialized: core::array::Span) -> core::option::Option { + core::option::Option::Some(Iu_256_key_modelSafeDispatcher { + contract_address: core::serde::Serde::deserialize(ref serialized)?, + }) + } +} +impl StoreIu_256_key_modelSafeDispatcher of starknet::Store:: { + fn read(address_domain: u32, base: starknet::storage_access::StorageBaseAddress) -> starknet::SyscallResult { + let contract_address = starknet::Store::::read(address_domain, base)?; + starknet::SyscallResult::Ok( + Iu_256_key_modelSafeDispatcher { + contract_address, + } + ) + } + fn write(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, value: Iu_256_key_modelSafeDispatcher) -> starknet::SyscallResult<()> { + starknet::Store::::write(address_domain, base, value.contract_address)?; + starknet::SyscallResult::Ok(()) + } + fn read_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8) -> starknet::SyscallResult { + let contract_address = starknet::Store::::read_at_offset(address_domain, base, offset)?; + starknet::SyscallResult::Ok( + Iu_256_key_modelSafeDispatcher { + contract_address, + } + ) + } + #[inline(always)] + fn write_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8, value: Iu_256_key_modelSafeDispatcher) -> starknet::SyscallResult<()> { + starknet::Store::::write_at_offset(address_domain, base, offset, value.contract_address)?; + starknet::SyscallResult::Ok(()) + } + #[inline(always)] + fn size() -> u8 { + starknet::Store::::size() + } +} + +#[derive(Drop, Copy)] +pub struct Iu_256_key_modelSafeDispatcherSubPointers { + pub contract_address: starknet::storage::StoragePointer, +} +impl Iu_256_key_modelSafeDispatcherSubPointersImpl of starknet::storage::SubPointers { + type SubPointersType = Iu_256_key_modelSafeDispatcherSubPointers; + fn sub_pointers(self: starknet::storage::StoragePointer) -> Iu_256_key_modelSafeDispatcherSubPointers { + let base_address = self.__storage_pointer_address__; + let mut current_offset = self.__storage_pointer_offset__; + let contract_address_value = starknet::storage::StoragePointer { + __storage_pointer_address__: base_address, + __storage_pointer_offset__: current_offset, + }; + Iu_256_key_modelSafeDispatcherSubPointers { + contract_address: contract_address_value, + } + } +} +#[derive(Drop, Copy)] +pub struct Iu_256_key_modelSafeDispatcherSubPointersMut { + pub contract_address: starknet::storage::StoragePointer>, +} +impl Iu_256_key_modelSafeDispatcherSubPointersMutImpl of starknet::storage::SubPointersMut { + type SubPointersType = Iu_256_key_modelSafeDispatcherSubPointersMut; + fn sub_pointers_mut(self: starknet::storage::StoragePointer>) -> Iu_256_key_modelSafeDispatcherSubPointersMut { + let base_address = self.__storage_pointer_address__; + let mut current_offset = self.__storage_pointer_offset__; + let contract_address_value = starknet::storage::StoragePointer { + __storage_pointer_address__: base_address, + __storage_pointer_offset__: current_offset, + }; + Iu_256_key_modelSafeDispatcherSubPointersMut { + contract_address: contract_address_value, + } + } +} +impl IplayerDispatcherCopy of core::traits::Copy::; +impl IplayerDispatcherDrop of core::traits::Drop::; +impl IplayerDispatcherSerde of core::serde::Serde:: { + fn serialize(self: @IplayerDispatcher, ref output: core::array::Array) { + core::serde::Serde::serialize(self.contract_address, ref output) + } + fn deserialize(ref serialized: core::array::Span) -> core::option::Option { + core::option::Option::Some(IplayerDispatcher { + contract_address: core::serde::Serde::deserialize(ref serialized)?, + }) + } +} +impl StoreIplayerDispatcher of starknet::Store:: { + fn read(address_domain: u32, base: starknet::storage_access::StorageBaseAddress) -> starknet::SyscallResult { + let contract_address = starknet::Store::::read(address_domain, base)?; + starknet::SyscallResult::Ok( + IplayerDispatcher { + contract_address, + } + ) + } + fn write(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, value: IplayerDispatcher) -> starknet::SyscallResult<()> { + starknet::Store::::write(address_domain, base, value.contract_address)?; + starknet::SyscallResult::Ok(()) + } + fn read_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8) -> starknet::SyscallResult { + let contract_address = starknet::Store::::read_at_offset(address_domain, base, offset)?; + starknet::SyscallResult::Ok( + IplayerDispatcher { + contract_address, + } + ) + } + #[inline(always)] + fn write_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8, value: IplayerDispatcher) -> starknet::SyscallResult<()> { + starknet::Store::::write_at_offset(address_domain, base, offset, value.contract_address)?; + starknet::SyscallResult::Ok(()) + } + #[inline(always)] + fn size() -> u8 { + starknet::Store::::size() + } +} + +#[derive(Drop, Copy)] +pub struct IplayerDispatcherSubPointers { + pub contract_address: starknet::storage::StoragePointer, +} +impl IplayerDispatcherSubPointersImpl of starknet::storage::SubPointers { + type SubPointersType = IplayerDispatcherSubPointers; + fn sub_pointers(self: starknet::storage::StoragePointer) -> IplayerDispatcherSubPointers { + let base_address = self.__storage_pointer_address__; + let mut current_offset = self.__storage_pointer_offset__; + let contract_address_value = starknet::storage::StoragePointer { + __storage_pointer_address__: base_address, + __storage_pointer_offset__: current_offset, + }; + IplayerDispatcherSubPointers { + contract_address: contract_address_value, + } + } +} +#[derive(Drop, Copy)] +pub struct IplayerDispatcherSubPointersMut { + pub contract_address: starknet::storage::StoragePointer>, +} +impl IplayerDispatcherSubPointersMutImpl of starknet::storage::SubPointersMut { + type SubPointersType = IplayerDispatcherSubPointersMut; + fn sub_pointers_mut(self: starknet::storage::StoragePointer>) -> IplayerDispatcherSubPointersMut { + let base_address = self.__storage_pointer_address__; + let mut current_offset = self.__storage_pointer_offset__; + let contract_address_value = starknet::storage::StoragePointer { + __storage_pointer_address__: base_address, + __storage_pointer_offset__: current_offset, + }; + IplayerDispatcherSubPointersMut { + contract_address: contract_address_value, + } + } +} +impl IplayerLibraryDispatcherCopy of core::traits::Copy::; +impl IplayerLibraryDispatcherDrop of core::traits::Drop::; +impl IplayerLibraryDispatcherSerde of core::serde::Serde:: { + fn serialize(self: @IplayerLibraryDispatcher, ref output: core::array::Array) { + core::serde::Serde::serialize(self.class_hash, ref output) + } + fn deserialize(ref serialized: core::array::Span) -> core::option::Option { + core::option::Option::Some(IplayerLibraryDispatcher { + class_hash: core::serde::Serde::deserialize(ref serialized)?, + }) + } +} +impl StoreIplayerLibraryDispatcher of starknet::Store:: { + fn read(address_domain: u32, base: starknet::storage_access::StorageBaseAddress) -> starknet::SyscallResult { + let class_hash = starknet::Store::::read(address_domain, base)?; + starknet::SyscallResult::Ok( + IplayerLibraryDispatcher { + class_hash, + } + ) + } + fn write(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, value: IplayerLibraryDispatcher) -> starknet::SyscallResult<()> { + starknet::Store::::write(address_domain, base, value.class_hash)?; + starknet::SyscallResult::Ok(()) + } + fn read_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8) -> starknet::SyscallResult { + let class_hash = starknet::Store::::read_at_offset(address_domain, base, offset)?; + starknet::SyscallResult::Ok( + IplayerLibraryDispatcher { + class_hash, + } + ) + } + #[inline(always)] + fn write_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8, value: IplayerLibraryDispatcher) -> starknet::SyscallResult<()> { + starknet::Store::::write_at_offset(address_domain, base, offset, value.class_hash)?; + starknet::SyscallResult::Ok(()) + } + #[inline(always)] + fn size() -> u8 { + starknet::Store::::size() + } +} + +#[derive(Drop, Copy)] +pub struct IplayerLibraryDispatcherSubPointers { + pub class_hash: starknet::storage::StoragePointer, +} +impl IplayerLibraryDispatcherSubPointersImpl of starknet::storage::SubPointers { + type SubPointersType = IplayerLibraryDispatcherSubPointers; + fn sub_pointers(self: starknet::storage::StoragePointer) -> IplayerLibraryDispatcherSubPointers { + let base_address = self.__storage_pointer_address__; + let mut current_offset = self.__storage_pointer_offset__; + let class_hash_value = starknet::storage::StoragePointer { + __storage_pointer_address__: base_address, + __storage_pointer_offset__: current_offset, + }; + IplayerLibraryDispatcherSubPointers { + class_hash: class_hash_value, + } + } +} +#[derive(Drop, Copy)] +pub struct IplayerLibraryDispatcherSubPointersMut { + pub class_hash: starknet::storage::StoragePointer>, +} +impl IplayerLibraryDispatcherSubPointersMutImpl of starknet::storage::SubPointersMut { + type SubPointersType = IplayerLibraryDispatcherSubPointersMut; + fn sub_pointers_mut(self: starknet::storage::StoragePointer>) -> IplayerLibraryDispatcherSubPointersMut { + let base_address = self.__storage_pointer_address__; + let mut current_offset = self.__storage_pointer_offset__; + let class_hash_value = starknet::storage::StoragePointer { + __storage_pointer_address__: base_address, + __storage_pointer_offset__: current_offset, + }; + IplayerLibraryDispatcherSubPointersMut { + class_hash: class_hash_value, + } + } +} +impl IplayerSafeLibraryDispatcherCopy of core::traits::Copy::; +impl IplayerSafeLibraryDispatcherDrop of core::traits::Drop::; +impl IplayerSafeLibraryDispatcherSerde of core::serde::Serde:: { + fn serialize(self: @IplayerSafeLibraryDispatcher, ref output: core::array::Array) { + core::serde::Serde::serialize(self.class_hash, ref output) + } + fn deserialize(ref serialized: core::array::Span) -> core::option::Option { + core::option::Option::Some(IplayerSafeLibraryDispatcher { + class_hash: core::serde::Serde::deserialize(ref serialized)?, + }) + } +} +impl StoreIplayerSafeLibraryDispatcher of starknet::Store:: { + fn read(address_domain: u32, base: starknet::storage_access::StorageBaseAddress) -> starknet::SyscallResult { + let class_hash = starknet::Store::::read(address_domain, base)?; + starknet::SyscallResult::Ok( + IplayerSafeLibraryDispatcher { + class_hash, + } + ) + } + fn write(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, value: IplayerSafeLibraryDispatcher) -> starknet::SyscallResult<()> { + starknet::Store::::write(address_domain, base, value.class_hash)?; + starknet::SyscallResult::Ok(()) + } + fn read_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8) -> starknet::SyscallResult { + let class_hash = starknet::Store::::read_at_offset(address_domain, base, offset)?; + starknet::SyscallResult::Ok( + IplayerSafeLibraryDispatcher { + class_hash, + } + ) + } + #[inline(always)] + fn write_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8, value: IplayerSafeLibraryDispatcher) -> starknet::SyscallResult<()> { + starknet::Store::::write_at_offset(address_domain, base, offset, value.class_hash)?; + starknet::SyscallResult::Ok(()) + } + #[inline(always)] + fn size() -> u8 { + starknet::Store::::size() + } +} + +#[derive(Drop, Copy)] +pub struct IplayerSafeLibraryDispatcherSubPointers { + pub class_hash: starknet::storage::StoragePointer, +} +impl IplayerSafeLibraryDispatcherSubPointersImpl of starknet::storage::SubPointers { + type SubPointersType = IplayerSafeLibraryDispatcherSubPointers; + fn sub_pointers(self: starknet::storage::StoragePointer) -> IplayerSafeLibraryDispatcherSubPointers { + let base_address = self.__storage_pointer_address__; + let mut current_offset = self.__storage_pointer_offset__; + let class_hash_value = starknet::storage::StoragePointer { + __storage_pointer_address__: base_address, + __storage_pointer_offset__: current_offset, + }; + IplayerSafeLibraryDispatcherSubPointers { + class_hash: class_hash_value, + } + } +} +#[derive(Drop, Copy)] +pub struct IplayerSafeLibraryDispatcherSubPointersMut { + pub class_hash: starknet::storage::StoragePointer>, +} +impl IplayerSafeLibraryDispatcherSubPointersMutImpl of starknet::storage::SubPointersMut { + type SubPointersType = IplayerSafeLibraryDispatcherSubPointersMut; + fn sub_pointers_mut(self: starknet::storage::StoragePointer>) -> IplayerSafeLibraryDispatcherSubPointersMut { + let base_address = self.__storage_pointer_address__; + let mut current_offset = self.__storage_pointer_offset__; + let class_hash_value = starknet::storage::StoragePointer { + __storage_pointer_address__: base_address, + __storage_pointer_offset__: current_offset, + }; + IplayerSafeLibraryDispatcherSubPointersMut { + class_hash: class_hash_value, + } + } +} +impl IplayerSafeDispatcherCopy of core::traits::Copy::; +impl IplayerSafeDispatcherDrop of core::traits::Drop::; +impl IplayerSafeDispatcherSerde of core::serde::Serde:: { + fn serialize(self: @IplayerSafeDispatcher, ref output: core::array::Array) { + core::serde::Serde::serialize(self.contract_address, ref output) + } + fn deserialize(ref serialized: core::array::Span) -> core::option::Option { + core::option::Option::Some(IplayerSafeDispatcher { + contract_address: core::serde::Serde::deserialize(ref serialized)?, + }) + } +} +impl StoreIplayerSafeDispatcher of starknet::Store:: { + fn read(address_domain: u32, base: starknet::storage_access::StorageBaseAddress) -> starknet::SyscallResult { + let contract_address = starknet::Store::::read(address_domain, base)?; + starknet::SyscallResult::Ok( + IplayerSafeDispatcher { + contract_address, + } + ) + } + fn write(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, value: IplayerSafeDispatcher) -> starknet::SyscallResult<()> { + starknet::Store::::write(address_domain, base, value.contract_address)?; + starknet::SyscallResult::Ok(()) + } + fn read_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8) -> starknet::SyscallResult { + let contract_address = starknet::Store::::read_at_offset(address_domain, base, offset)?; + starknet::SyscallResult::Ok( + IplayerSafeDispatcher { + contract_address, + } + ) + } + #[inline(always)] + fn write_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8, value: IplayerSafeDispatcher) -> starknet::SyscallResult<()> { + starknet::Store::::write_at_offset(address_domain, base, offset, value.contract_address)?; + starknet::SyscallResult::Ok(()) + } + #[inline(always)] + fn size() -> u8 { + starknet::Store::::size() + } +} + +#[derive(Drop, Copy)] +pub struct IplayerSafeDispatcherSubPointers { + pub contract_address: starknet::storage::StoragePointer, +} +impl IplayerSafeDispatcherSubPointersImpl of starknet::storage::SubPointers { + type SubPointersType = IplayerSafeDispatcherSubPointers; + fn sub_pointers(self: starknet::storage::StoragePointer) -> IplayerSafeDispatcherSubPointers { + let base_address = self.__storage_pointer_address__; + let mut current_offset = self.__storage_pointer_offset__; + let contract_address_value = starknet::storage::StoragePointer { + __storage_pointer_address__: base_address, + __storage_pointer_offset__: current_offset, + }; + IplayerSafeDispatcherSubPointers { + contract_address: contract_address_value, + } + } +} +#[derive(Drop, Copy)] +pub struct IplayerSafeDispatcherSubPointersMut { + pub contract_address: starknet::storage::StoragePointer>, +} +impl IplayerSafeDispatcherSubPointersMutImpl of starknet::storage::SubPointersMut { + type SubPointersType = IplayerSafeDispatcherSubPointersMut; + fn sub_pointers_mut(self: starknet::storage::StoragePointer>) -> IplayerSafeDispatcherSubPointersMut { + let base_address = self.__storage_pointer_address__; + let mut current_offset = self.__storage_pointer_offset__; + let contract_address_value = starknet::storage::StoragePointer { + __storage_pointer_address__: base_address, + __storage_pointer_offset__: current_offset, + }; + IplayerSafeDispatcherSubPointersMut { + contract_address: contract_address_value, + } + } +} +impl Imodel_with_simple_arrayDispatcherCopy of core::traits::Copy::; +impl Imodel_with_simple_arrayDispatcherDrop of core::traits::Drop::; +impl Imodel_with_simple_arrayDispatcherSerde of core::serde::Serde:: { + fn serialize(self: @Imodel_with_simple_arrayDispatcher, ref output: core::array::Array) { + core::serde::Serde::serialize(self.contract_address, ref output) + } + fn deserialize(ref serialized: core::array::Span) -> core::option::Option { + core::option::Option::Some(Imodel_with_simple_arrayDispatcher { + contract_address: core::serde::Serde::deserialize(ref serialized)?, + }) + } +} +impl StoreImodel_with_simple_arrayDispatcher of starknet::Store:: { + fn read(address_domain: u32, base: starknet::storage_access::StorageBaseAddress) -> starknet::SyscallResult { + let contract_address = starknet::Store::::read(address_domain, base)?; + starknet::SyscallResult::Ok( + Imodel_with_simple_arrayDispatcher { + contract_address, + } + ) + } + fn write(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, value: Imodel_with_simple_arrayDispatcher) -> starknet::SyscallResult<()> { + starknet::Store::::write(address_domain, base, value.contract_address)?; + starknet::SyscallResult::Ok(()) + } + fn read_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8) -> starknet::SyscallResult { + let contract_address = starknet::Store::::read_at_offset(address_domain, base, offset)?; + starknet::SyscallResult::Ok( + Imodel_with_simple_arrayDispatcher { + contract_address, + } + ) + } + #[inline(always)] + fn write_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8, value: Imodel_with_simple_arrayDispatcher) -> starknet::SyscallResult<()> { + starknet::Store::::write_at_offset(address_domain, base, offset, value.contract_address)?; + starknet::SyscallResult::Ok(()) + } + #[inline(always)] + fn size() -> u8 { + starknet::Store::::size() + } +} + +#[derive(Drop, Copy)] +pub struct Imodel_with_simple_arrayDispatcherSubPointers { + pub contract_address: starknet::storage::StoragePointer, +} +impl Imodel_with_simple_arrayDispatcherSubPointersImpl of starknet::storage::SubPointers { + type SubPointersType = Imodel_with_simple_arrayDispatcherSubPointers; + fn sub_pointers(self: starknet::storage::StoragePointer) -> Imodel_with_simple_arrayDispatcherSubPointers { + let base_address = self.__storage_pointer_address__; + let mut current_offset = self.__storage_pointer_offset__; + let contract_address_value = starknet::storage::StoragePointer { + __storage_pointer_address__: base_address, + __storage_pointer_offset__: current_offset, + }; + Imodel_with_simple_arrayDispatcherSubPointers { + contract_address: contract_address_value, + } + } +} +#[derive(Drop, Copy)] +pub struct Imodel_with_simple_arrayDispatcherSubPointersMut { + pub contract_address: starknet::storage::StoragePointer>, +} +impl Imodel_with_simple_arrayDispatcherSubPointersMutImpl of starknet::storage::SubPointersMut { + type SubPointersType = Imodel_with_simple_arrayDispatcherSubPointersMut; + fn sub_pointers_mut(self: starknet::storage::StoragePointer>) -> Imodel_with_simple_arrayDispatcherSubPointersMut { + let base_address = self.__storage_pointer_address__; + let mut current_offset = self.__storage_pointer_offset__; + let contract_address_value = starknet::storage::StoragePointer { + __storage_pointer_address__: base_address, + __storage_pointer_offset__: current_offset, + }; + Imodel_with_simple_arrayDispatcherSubPointersMut { + contract_address: contract_address_value, + } + } +} +impl Imodel_with_simple_arrayLibraryDispatcherCopy of core::traits::Copy::; +impl Imodel_with_simple_arrayLibraryDispatcherDrop of core::traits::Drop::; +impl Imodel_with_simple_arrayLibraryDispatcherSerde of core::serde::Serde:: { + fn serialize(self: @Imodel_with_simple_arrayLibraryDispatcher, ref output: core::array::Array) { + core::serde::Serde::serialize(self.class_hash, ref output) + } + fn deserialize(ref serialized: core::array::Span) -> core::option::Option { + core::option::Option::Some(Imodel_with_simple_arrayLibraryDispatcher { + class_hash: core::serde::Serde::deserialize(ref serialized)?, + }) + } +} +impl StoreImodel_with_simple_arrayLibraryDispatcher of starknet::Store:: { + fn read(address_domain: u32, base: starknet::storage_access::StorageBaseAddress) -> starknet::SyscallResult { + let class_hash = starknet::Store::::read(address_domain, base)?; + starknet::SyscallResult::Ok( + Imodel_with_simple_arrayLibraryDispatcher { + class_hash, + } + ) + } + fn write(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, value: Imodel_with_simple_arrayLibraryDispatcher) -> starknet::SyscallResult<()> { + starknet::Store::::write(address_domain, base, value.class_hash)?; + starknet::SyscallResult::Ok(()) + } + fn read_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8) -> starknet::SyscallResult { + let class_hash = starknet::Store::::read_at_offset(address_domain, base, offset)?; + starknet::SyscallResult::Ok( + Imodel_with_simple_arrayLibraryDispatcher { + class_hash, + } + ) + } + #[inline(always)] + fn write_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8, value: Imodel_with_simple_arrayLibraryDispatcher) -> starknet::SyscallResult<()> { + starknet::Store::::write_at_offset(address_domain, base, offset, value.class_hash)?; + starknet::SyscallResult::Ok(()) + } + #[inline(always)] + fn size() -> u8 { + starknet::Store::::size() + } +} + +#[derive(Drop, Copy)] +pub struct Imodel_with_simple_arrayLibraryDispatcherSubPointers { + pub class_hash: starknet::storage::StoragePointer, +} +impl Imodel_with_simple_arrayLibraryDispatcherSubPointersImpl of starknet::storage::SubPointers { + type SubPointersType = Imodel_with_simple_arrayLibraryDispatcherSubPointers; + fn sub_pointers(self: starknet::storage::StoragePointer) -> Imodel_with_simple_arrayLibraryDispatcherSubPointers { + let base_address = self.__storage_pointer_address__; + let mut current_offset = self.__storage_pointer_offset__; + let class_hash_value = starknet::storage::StoragePointer { + __storage_pointer_address__: base_address, + __storage_pointer_offset__: current_offset, + }; + Imodel_with_simple_arrayLibraryDispatcherSubPointers { + class_hash: class_hash_value, + } + } +} +#[derive(Drop, Copy)] +pub struct Imodel_with_simple_arrayLibraryDispatcherSubPointersMut { + pub class_hash: starknet::storage::StoragePointer>, +} +impl Imodel_with_simple_arrayLibraryDispatcherSubPointersMutImpl of starknet::storage::SubPointersMut { + type SubPointersType = Imodel_with_simple_arrayLibraryDispatcherSubPointersMut; + fn sub_pointers_mut(self: starknet::storage::StoragePointer>) -> Imodel_with_simple_arrayLibraryDispatcherSubPointersMut { + let base_address = self.__storage_pointer_address__; + let mut current_offset = self.__storage_pointer_offset__; + let class_hash_value = starknet::storage::StoragePointer { + __storage_pointer_address__: base_address, + __storage_pointer_offset__: current_offset, + }; + Imodel_with_simple_arrayLibraryDispatcherSubPointersMut { + class_hash: class_hash_value, + } + } +} +impl Imodel_with_simple_arraySafeLibraryDispatcherCopy of core::traits::Copy::; +impl Imodel_with_simple_arraySafeLibraryDispatcherDrop of core::traits::Drop::; +impl Imodel_with_simple_arraySafeLibraryDispatcherSerde of core::serde::Serde:: { + fn serialize(self: @Imodel_with_simple_arraySafeLibraryDispatcher, ref output: core::array::Array) { + core::serde::Serde::serialize(self.class_hash, ref output) + } + fn deserialize(ref serialized: core::array::Span) -> core::option::Option { + core::option::Option::Some(Imodel_with_simple_arraySafeLibraryDispatcher { + class_hash: core::serde::Serde::deserialize(ref serialized)?, + }) + } +} +impl StoreImodel_with_simple_arraySafeLibraryDispatcher of starknet::Store:: { + fn read(address_domain: u32, base: starknet::storage_access::StorageBaseAddress) -> starknet::SyscallResult { + let class_hash = starknet::Store::::read(address_domain, base)?; + starknet::SyscallResult::Ok( + Imodel_with_simple_arraySafeLibraryDispatcher { + class_hash, + } + ) + } + fn write(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, value: Imodel_with_simple_arraySafeLibraryDispatcher) -> starknet::SyscallResult<()> { + starknet::Store::::write(address_domain, base, value.class_hash)?; + starknet::SyscallResult::Ok(()) + } + fn read_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8) -> starknet::SyscallResult { + let class_hash = starknet::Store::::read_at_offset(address_domain, base, offset)?; + starknet::SyscallResult::Ok( + Imodel_with_simple_arraySafeLibraryDispatcher { + class_hash, + } + ) + } + #[inline(always)] + fn write_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8, value: Imodel_with_simple_arraySafeLibraryDispatcher) -> starknet::SyscallResult<()> { + starknet::Store::::write_at_offset(address_domain, base, offset, value.class_hash)?; + starknet::SyscallResult::Ok(()) + } + #[inline(always)] + fn size() -> u8 { + starknet::Store::::size() + } +} + +#[derive(Drop, Copy)] +pub struct Imodel_with_simple_arraySafeLibraryDispatcherSubPointers { + pub class_hash: starknet::storage::StoragePointer, +} +impl Imodel_with_simple_arraySafeLibraryDispatcherSubPointersImpl of starknet::storage::SubPointers { + type SubPointersType = Imodel_with_simple_arraySafeLibraryDispatcherSubPointers; + fn sub_pointers(self: starknet::storage::StoragePointer) -> Imodel_with_simple_arraySafeLibraryDispatcherSubPointers { + let base_address = self.__storage_pointer_address__; + let mut current_offset = self.__storage_pointer_offset__; + let class_hash_value = starknet::storage::StoragePointer { + __storage_pointer_address__: base_address, + __storage_pointer_offset__: current_offset, + }; + Imodel_with_simple_arraySafeLibraryDispatcherSubPointers { + class_hash: class_hash_value, + } + } +} +#[derive(Drop, Copy)] +pub struct Imodel_with_simple_arraySafeLibraryDispatcherSubPointersMut { + pub class_hash: starknet::storage::StoragePointer>, +} +impl Imodel_with_simple_arraySafeLibraryDispatcherSubPointersMutImpl of starknet::storage::SubPointersMut { + type SubPointersType = Imodel_with_simple_arraySafeLibraryDispatcherSubPointersMut; + fn sub_pointers_mut(self: starknet::storage::StoragePointer>) -> Imodel_with_simple_arraySafeLibraryDispatcherSubPointersMut { + let base_address = self.__storage_pointer_address__; + let mut current_offset = self.__storage_pointer_offset__; + let class_hash_value = starknet::storage::StoragePointer { + __storage_pointer_address__: base_address, + __storage_pointer_offset__: current_offset, + }; + Imodel_with_simple_arraySafeLibraryDispatcherSubPointersMut { + class_hash: class_hash_value, + } + } +} +impl Imodel_with_simple_arraySafeDispatcherCopy of core::traits::Copy::; +impl Imodel_with_simple_arraySafeDispatcherDrop of core::traits::Drop::; +impl Imodel_with_simple_arraySafeDispatcherSerde of core::serde::Serde:: { + fn serialize(self: @Imodel_with_simple_arraySafeDispatcher, ref output: core::array::Array) { + core::serde::Serde::serialize(self.contract_address, ref output) + } + fn deserialize(ref serialized: core::array::Span) -> core::option::Option { + core::option::Option::Some(Imodel_with_simple_arraySafeDispatcher { + contract_address: core::serde::Serde::deserialize(ref serialized)?, + }) + } +} +impl StoreImodel_with_simple_arraySafeDispatcher of starknet::Store:: { + fn read(address_domain: u32, base: starknet::storage_access::StorageBaseAddress) -> starknet::SyscallResult { + let contract_address = starknet::Store::::read(address_domain, base)?; + starknet::SyscallResult::Ok( + Imodel_with_simple_arraySafeDispatcher { + contract_address, + } + ) + } + fn write(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, value: Imodel_with_simple_arraySafeDispatcher) -> starknet::SyscallResult<()> { + starknet::Store::::write(address_domain, base, value.contract_address)?; + starknet::SyscallResult::Ok(()) + } + fn read_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8) -> starknet::SyscallResult { + let contract_address = starknet::Store::::read_at_offset(address_domain, base, offset)?; + starknet::SyscallResult::Ok( + Imodel_with_simple_arraySafeDispatcher { + contract_address, + } + ) + } + #[inline(always)] + fn write_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8, value: Imodel_with_simple_arraySafeDispatcher) -> starknet::SyscallResult<()> { + starknet::Store::::write_at_offset(address_domain, base, offset, value.contract_address)?; + starknet::SyscallResult::Ok(()) + } + #[inline(always)] + fn size() -> u8 { + starknet::Store::::size() + } +} + +#[derive(Drop, Copy)] +pub struct Imodel_with_simple_arraySafeDispatcherSubPointers { + pub contract_address: starknet::storage::StoragePointer, +} +impl Imodel_with_simple_arraySafeDispatcherSubPointersImpl of starknet::storage::SubPointers { + type SubPointersType = Imodel_with_simple_arraySafeDispatcherSubPointers; + fn sub_pointers(self: starknet::storage::StoragePointer) -> Imodel_with_simple_arraySafeDispatcherSubPointers { + let base_address = self.__storage_pointer_address__; + let mut current_offset = self.__storage_pointer_offset__; + let contract_address_value = starknet::storage::StoragePointer { + __storage_pointer_address__: base_address, + __storage_pointer_offset__: current_offset, + }; + Imodel_with_simple_arraySafeDispatcherSubPointers { + contract_address: contract_address_value, + } + } +} +#[derive(Drop, Copy)] +pub struct Imodel_with_simple_arraySafeDispatcherSubPointersMut { + pub contract_address: starknet::storage::StoragePointer>, +} +impl Imodel_with_simple_arraySafeDispatcherSubPointersMutImpl of starknet::storage::SubPointersMut { + type SubPointersType = Imodel_with_simple_arraySafeDispatcherSubPointersMut; + fn sub_pointers_mut(self: starknet::storage::StoragePointer>) -> Imodel_with_simple_arraySafeDispatcherSubPointersMut { + let base_address = self.__storage_pointer_address__; + let mut current_offset = self.__storage_pointer_offset__; + let contract_address_value = starknet::storage::StoragePointer { + __storage_pointer_address__: base_address, + __storage_pointer_offset__: current_offset, + }; + Imodel_with_simple_arraySafeDispatcherSubPointersMut { + contract_address: contract_address_value, + } + } +} +impl Imodel_with_byte_arrayDispatcherCopy of core::traits::Copy::; +impl Imodel_with_byte_arrayDispatcherDrop of core::traits::Drop::; +impl Imodel_with_byte_arrayDispatcherSerde of core::serde::Serde:: { + fn serialize(self: @Imodel_with_byte_arrayDispatcher, ref output: core::array::Array) { + core::serde::Serde::serialize(self.contract_address, ref output) + } + fn deserialize(ref serialized: core::array::Span) -> core::option::Option { + core::option::Option::Some(Imodel_with_byte_arrayDispatcher { + contract_address: core::serde::Serde::deserialize(ref serialized)?, + }) + } +} +impl StoreImodel_with_byte_arrayDispatcher of starknet::Store:: { + fn read(address_domain: u32, base: starknet::storage_access::StorageBaseAddress) -> starknet::SyscallResult { + let contract_address = starknet::Store::::read(address_domain, base)?; + starknet::SyscallResult::Ok( + Imodel_with_byte_arrayDispatcher { + contract_address, + } + ) + } + fn write(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, value: Imodel_with_byte_arrayDispatcher) -> starknet::SyscallResult<()> { + starknet::Store::::write(address_domain, base, value.contract_address)?; + starknet::SyscallResult::Ok(()) + } + fn read_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8) -> starknet::SyscallResult { + let contract_address = starknet::Store::::read_at_offset(address_domain, base, offset)?; + starknet::SyscallResult::Ok( + Imodel_with_byte_arrayDispatcher { + contract_address, + } + ) + } + #[inline(always)] + fn write_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8, value: Imodel_with_byte_arrayDispatcher) -> starknet::SyscallResult<()> { + starknet::Store::::write_at_offset(address_domain, base, offset, value.contract_address)?; + starknet::SyscallResult::Ok(()) + } + #[inline(always)] + fn size() -> u8 { + starknet::Store::::size() + } +} + +#[derive(Drop, Copy)] +pub struct Imodel_with_byte_arrayDispatcherSubPointers { + pub contract_address: starknet::storage::StoragePointer, +} +impl Imodel_with_byte_arrayDispatcherSubPointersImpl of starknet::storage::SubPointers { + type SubPointersType = Imodel_with_byte_arrayDispatcherSubPointers; + fn sub_pointers(self: starknet::storage::StoragePointer) -> Imodel_with_byte_arrayDispatcherSubPointers { + let base_address = self.__storage_pointer_address__; + let mut current_offset = self.__storage_pointer_offset__; + let contract_address_value = starknet::storage::StoragePointer { + __storage_pointer_address__: base_address, + __storage_pointer_offset__: current_offset, + }; + Imodel_with_byte_arrayDispatcherSubPointers { + contract_address: contract_address_value, + } + } +} +#[derive(Drop, Copy)] +pub struct Imodel_with_byte_arrayDispatcherSubPointersMut { + pub contract_address: starknet::storage::StoragePointer>, +} +impl Imodel_with_byte_arrayDispatcherSubPointersMutImpl of starknet::storage::SubPointersMut { + type SubPointersType = Imodel_with_byte_arrayDispatcherSubPointersMut; + fn sub_pointers_mut(self: starknet::storage::StoragePointer>) -> Imodel_with_byte_arrayDispatcherSubPointersMut { + let base_address = self.__storage_pointer_address__; + let mut current_offset = self.__storage_pointer_offset__; + let contract_address_value = starknet::storage::StoragePointer { + __storage_pointer_address__: base_address, + __storage_pointer_offset__: current_offset, + }; + Imodel_with_byte_arrayDispatcherSubPointersMut { + contract_address: contract_address_value, + } + } +} +impl Imodel_with_byte_arrayLibraryDispatcherCopy of core::traits::Copy::; +impl Imodel_with_byte_arrayLibraryDispatcherDrop of core::traits::Drop::; +impl Imodel_with_byte_arrayLibraryDispatcherSerde of core::serde::Serde:: { + fn serialize(self: @Imodel_with_byte_arrayLibraryDispatcher, ref output: core::array::Array) { + core::serde::Serde::serialize(self.class_hash, ref output) + } + fn deserialize(ref serialized: core::array::Span) -> core::option::Option { + core::option::Option::Some(Imodel_with_byte_arrayLibraryDispatcher { + class_hash: core::serde::Serde::deserialize(ref serialized)?, + }) + } +} +impl StoreImodel_with_byte_arrayLibraryDispatcher of starknet::Store:: { + fn read(address_domain: u32, base: starknet::storage_access::StorageBaseAddress) -> starknet::SyscallResult { + let class_hash = starknet::Store::::read(address_domain, base)?; + starknet::SyscallResult::Ok( + Imodel_with_byte_arrayLibraryDispatcher { + class_hash, + } + ) + } + fn write(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, value: Imodel_with_byte_arrayLibraryDispatcher) -> starknet::SyscallResult<()> { + starknet::Store::::write(address_domain, base, value.class_hash)?; + starknet::SyscallResult::Ok(()) + } + fn read_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8) -> starknet::SyscallResult { + let class_hash = starknet::Store::::read_at_offset(address_domain, base, offset)?; + starknet::SyscallResult::Ok( + Imodel_with_byte_arrayLibraryDispatcher { + class_hash, + } + ) + } + #[inline(always)] + fn write_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8, value: Imodel_with_byte_arrayLibraryDispatcher) -> starknet::SyscallResult<()> { + starknet::Store::::write_at_offset(address_domain, base, offset, value.class_hash)?; + starknet::SyscallResult::Ok(()) + } + #[inline(always)] + fn size() -> u8 { + starknet::Store::::size() + } +} + +#[derive(Drop, Copy)] +pub struct Imodel_with_byte_arrayLibraryDispatcherSubPointers { + pub class_hash: starknet::storage::StoragePointer, +} +impl Imodel_with_byte_arrayLibraryDispatcherSubPointersImpl of starknet::storage::SubPointers { + type SubPointersType = Imodel_with_byte_arrayLibraryDispatcherSubPointers; + fn sub_pointers(self: starknet::storage::StoragePointer) -> Imodel_with_byte_arrayLibraryDispatcherSubPointers { + let base_address = self.__storage_pointer_address__; + let mut current_offset = self.__storage_pointer_offset__; + let class_hash_value = starknet::storage::StoragePointer { + __storage_pointer_address__: base_address, + __storage_pointer_offset__: current_offset, + }; + Imodel_with_byte_arrayLibraryDispatcherSubPointers { + class_hash: class_hash_value, + } + } +} +#[derive(Drop, Copy)] +pub struct Imodel_with_byte_arrayLibraryDispatcherSubPointersMut { + pub class_hash: starknet::storage::StoragePointer>, +} +impl Imodel_with_byte_arrayLibraryDispatcherSubPointersMutImpl of starknet::storage::SubPointersMut { + type SubPointersType = Imodel_with_byte_arrayLibraryDispatcherSubPointersMut; + fn sub_pointers_mut(self: starknet::storage::StoragePointer>) -> Imodel_with_byte_arrayLibraryDispatcherSubPointersMut { + let base_address = self.__storage_pointer_address__; + let mut current_offset = self.__storage_pointer_offset__; + let class_hash_value = starknet::storage::StoragePointer { + __storage_pointer_address__: base_address, + __storage_pointer_offset__: current_offset, + }; + Imodel_with_byte_arrayLibraryDispatcherSubPointersMut { + class_hash: class_hash_value, + } + } +} +impl Imodel_with_byte_arraySafeLibraryDispatcherCopy of core::traits::Copy::; +impl Imodel_with_byte_arraySafeLibraryDispatcherDrop of core::traits::Drop::; +impl Imodel_with_byte_arraySafeLibraryDispatcherSerde of core::serde::Serde:: { + fn serialize(self: @Imodel_with_byte_arraySafeLibraryDispatcher, ref output: core::array::Array) { + core::serde::Serde::serialize(self.class_hash, ref output) + } + fn deserialize(ref serialized: core::array::Span) -> core::option::Option { + core::option::Option::Some(Imodel_with_byte_arraySafeLibraryDispatcher { + class_hash: core::serde::Serde::deserialize(ref serialized)?, + }) + } +} +impl StoreImodel_with_byte_arraySafeLibraryDispatcher of starknet::Store:: { + fn read(address_domain: u32, base: starknet::storage_access::StorageBaseAddress) -> starknet::SyscallResult { + let class_hash = starknet::Store::::read(address_domain, base)?; + starknet::SyscallResult::Ok( + Imodel_with_byte_arraySafeLibraryDispatcher { + class_hash, + } + ) + } + fn write(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, value: Imodel_with_byte_arraySafeLibraryDispatcher) -> starknet::SyscallResult<()> { + starknet::Store::::write(address_domain, base, value.class_hash)?; + starknet::SyscallResult::Ok(()) + } + fn read_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8) -> starknet::SyscallResult { + let class_hash = starknet::Store::::read_at_offset(address_domain, base, offset)?; + starknet::SyscallResult::Ok( + Imodel_with_byte_arraySafeLibraryDispatcher { + class_hash, + } + ) + } + #[inline(always)] + fn write_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8, value: Imodel_with_byte_arraySafeLibraryDispatcher) -> starknet::SyscallResult<()> { + starknet::Store::::write_at_offset(address_domain, base, offset, value.class_hash)?; + starknet::SyscallResult::Ok(()) + } + #[inline(always)] + fn size() -> u8 { + starknet::Store::::size() + } +} + +#[derive(Drop, Copy)] +pub struct Imodel_with_byte_arraySafeLibraryDispatcherSubPointers { + pub class_hash: starknet::storage::StoragePointer, +} +impl Imodel_with_byte_arraySafeLibraryDispatcherSubPointersImpl of starknet::storage::SubPointers { + type SubPointersType = Imodel_with_byte_arraySafeLibraryDispatcherSubPointers; + fn sub_pointers(self: starknet::storage::StoragePointer) -> Imodel_with_byte_arraySafeLibraryDispatcherSubPointers { + let base_address = self.__storage_pointer_address__; + let mut current_offset = self.__storage_pointer_offset__; + let class_hash_value = starknet::storage::StoragePointer { + __storage_pointer_address__: base_address, + __storage_pointer_offset__: current_offset, + }; + Imodel_with_byte_arraySafeLibraryDispatcherSubPointers { + class_hash: class_hash_value, + } + } +} +#[derive(Drop, Copy)] +pub struct Imodel_with_byte_arraySafeLibraryDispatcherSubPointersMut { + pub class_hash: starknet::storage::StoragePointer>, +} +impl Imodel_with_byte_arraySafeLibraryDispatcherSubPointersMutImpl of starknet::storage::SubPointersMut { + type SubPointersType = Imodel_with_byte_arraySafeLibraryDispatcherSubPointersMut; + fn sub_pointers_mut(self: starknet::storage::StoragePointer>) -> Imodel_with_byte_arraySafeLibraryDispatcherSubPointersMut { + let base_address = self.__storage_pointer_address__; + let mut current_offset = self.__storage_pointer_offset__; + let class_hash_value = starknet::storage::StoragePointer { + __storage_pointer_address__: base_address, + __storage_pointer_offset__: current_offset, + }; + Imodel_with_byte_arraySafeLibraryDispatcherSubPointersMut { + class_hash: class_hash_value, + } + } +} +impl Imodel_with_byte_arraySafeDispatcherCopy of core::traits::Copy::; +impl Imodel_with_byte_arraySafeDispatcherDrop of core::traits::Drop::; +impl Imodel_with_byte_arraySafeDispatcherSerde of core::serde::Serde:: { + fn serialize(self: @Imodel_with_byte_arraySafeDispatcher, ref output: core::array::Array) { + core::serde::Serde::serialize(self.contract_address, ref output) + } + fn deserialize(ref serialized: core::array::Span) -> core::option::Option { + core::option::Option::Some(Imodel_with_byte_arraySafeDispatcher { + contract_address: core::serde::Serde::deserialize(ref serialized)?, + }) + } +} +impl StoreImodel_with_byte_arraySafeDispatcher of starknet::Store:: { + fn read(address_domain: u32, base: starknet::storage_access::StorageBaseAddress) -> starknet::SyscallResult { + let contract_address = starknet::Store::::read(address_domain, base)?; + starknet::SyscallResult::Ok( + Imodel_with_byte_arraySafeDispatcher { + contract_address, + } + ) + } + fn write(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, value: Imodel_with_byte_arraySafeDispatcher) -> starknet::SyscallResult<()> { + starknet::Store::::write(address_domain, base, value.contract_address)?; + starknet::SyscallResult::Ok(()) + } + fn read_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8) -> starknet::SyscallResult { + let contract_address = starknet::Store::::read_at_offset(address_domain, base, offset)?; + starknet::SyscallResult::Ok( + Imodel_with_byte_arraySafeDispatcher { + contract_address, + } + ) + } + #[inline(always)] + fn write_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8, value: Imodel_with_byte_arraySafeDispatcher) -> starknet::SyscallResult<()> { + starknet::Store::::write_at_offset(address_domain, base, offset, value.contract_address)?; + starknet::SyscallResult::Ok(()) + } + #[inline(always)] + fn size() -> u8 { + starknet::Store::::size() + } +} + +#[derive(Drop, Copy)] +pub struct Imodel_with_byte_arraySafeDispatcherSubPointers { + pub contract_address: starknet::storage::StoragePointer, +} +impl Imodel_with_byte_arraySafeDispatcherSubPointersImpl of starknet::storage::SubPointers { + type SubPointersType = Imodel_with_byte_arraySafeDispatcherSubPointers; + fn sub_pointers(self: starknet::storage::StoragePointer) -> Imodel_with_byte_arraySafeDispatcherSubPointers { + let base_address = self.__storage_pointer_address__; + let mut current_offset = self.__storage_pointer_offset__; + let contract_address_value = starknet::storage::StoragePointer { + __storage_pointer_address__: base_address, + __storage_pointer_offset__: current_offset, + }; + Imodel_with_byte_arraySafeDispatcherSubPointers { + contract_address: contract_address_value, + } + } +} +#[derive(Drop, Copy)] +pub struct Imodel_with_byte_arraySafeDispatcherSubPointersMut { + pub contract_address: starknet::storage::StoragePointer>, +} +impl Imodel_with_byte_arraySafeDispatcherSubPointersMutImpl of starknet::storage::SubPointersMut { + type SubPointersType = Imodel_with_byte_arraySafeDispatcherSubPointersMut; + fn sub_pointers_mut(self: starknet::storage::StoragePointer>) -> Imodel_with_byte_arraySafeDispatcherSubPointersMut { + let base_address = self.__storage_pointer_address__; + let mut current_offset = self.__storage_pointer_offset__; + let contract_address_value = starknet::storage::StoragePointer { + __storage_pointer_address__: base_address, + __storage_pointer_offset__: current_offset, + }; + Imodel_with_byte_arraySafeDispatcherSubPointersMut { + contract_address: contract_address_value, + } + } +} +impl Imodel_with_complex_arrayDispatcherCopy of core::traits::Copy::; +impl Imodel_with_complex_arrayDispatcherDrop of core::traits::Drop::; +impl Imodel_with_complex_arrayDispatcherSerde of core::serde::Serde:: { + fn serialize(self: @Imodel_with_complex_arrayDispatcher, ref output: core::array::Array) { + core::serde::Serde::serialize(self.contract_address, ref output) + } + fn deserialize(ref serialized: core::array::Span) -> core::option::Option { + core::option::Option::Some(Imodel_with_complex_arrayDispatcher { + contract_address: core::serde::Serde::deserialize(ref serialized)?, + }) + } +} +impl StoreImodel_with_complex_arrayDispatcher of starknet::Store:: { + fn read(address_domain: u32, base: starknet::storage_access::StorageBaseAddress) -> starknet::SyscallResult { + let contract_address = starknet::Store::::read(address_domain, base)?; + starknet::SyscallResult::Ok( + Imodel_with_complex_arrayDispatcher { + contract_address, + } + ) + } + fn write(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, value: Imodel_with_complex_arrayDispatcher) -> starknet::SyscallResult<()> { + starknet::Store::::write(address_domain, base, value.contract_address)?; + starknet::SyscallResult::Ok(()) + } + fn read_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8) -> starknet::SyscallResult { + let contract_address = starknet::Store::::read_at_offset(address_domain, base, offset)?; + starknet::SyscallResult::Ok( + Imodel_with_complex_arrayDispatcher { + contract_address, + } + ) + } + #[inline(always)] + fn write_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8, value: Imodel_with_complex_arrayDispatcher) -> starknet::SyscallResult<()> { + starknet::Store::::write_at_offset(address_domain, base, offset, value.contract_address)?; + starknet::SyscallResult::Ok(()) + } + #[inline(always)] + fn size() -> u8 { + starknet::Store::::size() + } +} + +#[derive(Drop, Copy)] +pub struct Imodel_with_complex_arrayDispatcherSubPointers { + pub contract_address: starknet::storage::StoragePointer, +} +impl Imodel_with_complex_arrayDispatcherSubPointersImpl of starknet::storage::SubPointers { + type SubPointersType = Imodel_with_complex_arrayDispatcherSubPointers; + fn sub_pointers(self: starknet::storage::StoragePointer) -> Imodel_with_complex_arrayDispatcherSubPointers { + let base_address = self.__storage_pointer_address__; + let mut current_offset = self.__storage_pointer_offset__; + let contract_address_value = starknet::storage::StoragePointer { + __storage_pointer_address__: base_address, + __storage_pointer_offset__: current_offset, + }; + Imodel_with_complex_arrayDispatcherSubPointers { + contract_address: contract_address_value, + } + } +} +#[derive(Drop, Copy)] +pub struct Imodel_with_complex_arrayDispatcherSubPointersMut { + pub contract_address: starknet::storage::StoragePointer>, +} +impl Imodel_with_complex_arrayDispatcherSubPointersMutImpl of starknet::storage::SubPointersMut { + type SubPointersType = Imodel_with_complex_arrayDispatcherSubPointersMut; + fn sub_pointers_mut(self: starknet::storage::StoragePointer>) -> Imodel_with_complex_arrayDispatcherSubPointersMut { + let base_address = self.__storage_pointer_address__; + let mut current_offset = self.__storage_pointer_offset__; + let contract_address_value = starknet::storage::StoragePointer { + __storage_pointer_address__: base_address, + __storage_pointer_offset__: current_offset, + }; + Imodel_with_complex_arrayDispatcherSubPointersMut { + contract_address: contract_address_value, + } + } +} +impl Imodel_with_complex_arrayLibraryDispatcherCopy of core::traits::Copy::; +impl Imodel_with_complex_arrayLibraryDispatcherDrop of core::traits::Drop::; +impl Imodel_with_complex_arrayLibraryDispatcherSerde of core::serde::Serde:: { + fn serialize(self: @Imodel_with_complex_arrayLibraryDispatcher, ref output: core::array::Array) { + core::serde::Serde::serialize(self.class_hash, ref output) + } + fn deserialize(ref serialized: core::array::Span) -> core::option::Option { + core::option::Option::Some(Imodel_with_complex_arrayLibraryDispatcher { + class_hash: core::serde::Serde::deserialize(ref serialized)?, + }) + } +} +impl StoreImodel_with_complex_arrayLibraryDispatcher of starknet::Store:: { + fn read(address_domain: u32, base: starknet::storage_access::StorageBaseAddress) -> starknet::SyscallResult { + let class_hash = starknet::Store::::read(address_domain, base)?; + starknet::SyscallResult::Ok( + Imodel_with_complex_arrayLibraryDispatcher { + class_hash, + } + ) + } + fn write(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, value: Imodel_with_complex_arrayLibraryDispatcher) -> starknet::SyscallResult<()> { + starknet::Store::::write(address_domain, base, value.class_hash)?; + starknet::SyscallResult::Ok(()) + } + fn read_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8) -> starknet::SyscallResult { + let class_hash = starknet::Store::::read_at_offset(address_domain, base, offset)?; + starknet::SyscallResult::Ok( + Imodel_with_complex_arrayLibraryDispatcher { + class_hash, + } + ) + } + #[inline(always)] + fn write_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8, value: Imodel_with_complex_arrayLibraryDispatcher) -> starknet::SyscallResult<()> { + starknet::Store::::write_at_offset(address_domain, base, offset, value.class_hash)?; + starknet::SyscallResult::Ok(()) + } + #[inline(always)] + fn size() -> u8 { + starknet::Store::::size() + } +} + +#[derive(Drop, Copy)] +pub struct Imodel_with_complex_arrayLibraryDispatcherSubPointers { + pub class_hash: starknet::storage::StoragePointer, +} +impl Imodel_with_complex_arrayLibraryDispatcherSubPointersImpl of starknet::storage::SubPointers { + type SubPointersType = Imodel_with_complex_arrayLibraryDispatcherSubPointers; + fn sub_pointers(self: starknet::storage::StoragePointer) -> Imodel_with_complex_arrayLibraryDispatcherSubPointers { + let base_address = self.__storage_pointer_address__; + let mut current_offset = self.__storage_pointer_offset__; + let class_hash_value = starknet::storage::StoragePointer { + __storage_pointer_address__: base_address, + __storage_pointer_offset__: current_offset, + }; + Imodel_with_complex_arrayLibraryDispatcherSubPointers { + class_hash: class_hash_value, + } + } +} +#[derive(Drop, Copy)] +pub struct Imodel_with_complex_arrayLibraryDispatcherSubPointersMut { + pub class_hash: starknet::storage::StoragePointer>, +} +impl Imodel_with_complex_arrayLibraryDispatcherSubPointersMutImpl of starknet::storage::SubPointersMut { + type SubPointersType = Imodel_with_complex_arrayLibraryDispatcherSubPointersMut; + fn sub_pointers_mut(self: starknet::storage::StoragePointer>) -> Imodel_with_complex_arrayLibraryDispatcherSubPointersMut { + let base_address = self.__storage_pointer_address__; + let mut current_offset = self.__storage_pointer_offset__; + let class_hash_value = starknet::storage::StoragePointer { + __storage_pointer_address__: base_address, + __storage_pointer_offset__: current_offset, + }; + Imodel_with_complex_arrayLibraryDispatcherSubPointersMut { + class_hash: class_hash_value, + } + } +} +impl Imodel_with_complex_arraySafeLibraryDispatcherCopy of core::traits::Copy::; +impl Imodel_with_complex_arraySafeLibraryDispatcherDrop of core::traits::Drop::; +impl Imodel_with_complex_arraySafeLibraryDispatcherSerde of core::serde::Serde:: { + fn serialize(self: @Imodel_with_complex_arraySafeLibraryDispatcher, ref output: core::array::Array) { + core::serde::Serde::serialize(self.class_hash, ref output) + } + fn deserialize(ref serialized: core::array::Span) -> core::option::Option { + core::option::Option::Some(Imodel_with_complex_arraySafeLibraryDispatcher { + class_hash: core::serde::Serde::deserialize(ref serialized)?, + }) + } +} +impl StoreImodel_with_complex_arraySafeLibraryDispatcher of starknet::Store:: { + fn read(address_domain: u32, base: starknet::storage_access::StorageBaseAddress) -> starknet::SyscallResult { + let class_hash = starknet::Store::::read(address_domain, base)?; + starknet::SyscallResult::Ok( + Imodel_with_complex_arraySafeLibraryDispatcher { + class_hash, + } + ) + } + fn write(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, value: Imodel_with_complex_arraySafeLibraryDispatcher) -> starknet::SyscallResult<()> { + starknet::Store::::write(address_domain, base, value.class_hash)?; + starknet::SyscallResult::Ok(()) + } + fn read_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8) -> starknet::SyscallResult { + let class_hash = starknet::Store::::read_at_offset(address_domain, base, offset)?; + starknet::SyscallResult::Ok( + Imodel_with_complex_arraySafeLibraryDispatcher { + class_hash, + } + ) + } + #[inline(always)] + fn write_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8, value: Imodel_with_complex_arraySafeLibraryDispatcher) -> starknet::SyscallResult<()> { + starknet::Store::::write_at_offset(address_domain, base, offset, value.class_hash)?; + starknet::SyscallResult::Ok(()) + } + #[inline(always)] + fn size() -> u8 { + starknet::Store::::size() + } +} + +#[derive(Drop, Copy)] +pub struct Imodel_with_complex_arraySafeLibraryDispatcherSubPointers { + pub class_hash: starknet::storage::StoragePointer, +} +impl Imodel_with_complex_arraySafeLibraryDispatcherSubPointersImpl of starknet::storage::SubPointers { + type SubPointersType = Imodel_with_complex_arraySafeLibraryDispatcherSubPointers; + fn sub_pointers(self: starknet::storage::StoragePointer) -> Imodel_with_complex_arraySafeLibraryDispatcherSubPointers { + let base_address = self.__storage_pointer_address__; + let mut current_offset = self.__storage_pointer_offset__; + let class_hash_value = starknet::storage::StoragePointer { + __storage_pointer_address__: base_address, + __storage_pointer_offset__: current_offset, + }; + Imodel_with_complex_arraySafeLibraryDispatcherSubPointers { + class_hash: class_hash_value, + } + } +} +#[derive(Drop, Copy)] +pub struct Imodel_with_complex_arraySafeLibraryDispatcherSubPointersMut { + pub class_hash: starknet::storage::StoragePointer>, +} +impl Imodel_with_complex_arraySafeLibraryDispatcherSubPointersMutImpl of starknet::storage::SubPointersMut { + type SubPointersType = Imodel_with_complex_arraySafeLibraryDispatcherSubPointersMut; + fn sub_pointers_mut(self: starknet::storage::StoragePointer>) -> Imodel_with_complex_arraySafeLibraryDispatcherSubPointersMut { + let base_address = self.__storage_pointer_address__; + let mut current_offset = self.__storage_pointer_offset__; + let class_hash_value = starknet::storage::StoragePointer { + __storage_pointer_address__: base_address, + __storage_pointer_offset__: current_offset, + }; + Imodel_with_complex_arraySafeLibraryDispatcherSubPointersMut { + class_hash: class_hash_value, + } + } +} +impl Imodel_with_complex_arraySafeDispatcherCopy of core::traits::Copy::; +impl Imodel_with_complex_arraySafeDispatcherDrop of core::traits::Drop::; +impl Imodel_with_complex_arraySafeDispatcherSerde of core::serde::Serde:: { + fn serialize(self: @Imodel_with_complex_arraySafeDispatcher, ref output: core::array::Array) { + core::serde::Serde::serialize(self.contract_address, ref output) + } + fn deserialize(ref serialized: core::array::Span) -> core::option::Option { + core::option::Option::Some(Imodel_with_complex_arraySafeDispatcher { + contract_address: core::serde::Serde::deserialize(ref serialized)?, + }) + } +} +impl StoreImodel_with_complex_arraySafeDispatcher of starknet::Store:: { + fn read(address_domain: u32, base: starknet::storage_access::StorageBaseAddress) -> starknet::SyscallResult { + let contract_address = starknet::Store::::read(address_domain, base)?; + starknet::SyscallResult::Ok( + Imodel_with_complex_arraySafeDispatcher { + contract_address, + } + ) + } + fn write(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, value: Imodel_with_complex_arraySafeDispatcher) -> starknet::SyscallResult<()> { + starknet::Store::::write(address_domain, base, value.contract_address)?; + starknet::SyscallResult::Ok(()) + } + fn read_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8) -> starknet::SyscallResult { + let contract_address = starknet::Store::::read_at_offset(address_domain, base, offset)?; + starknet::SyscallResult::Ok( + Imodel_with_complex_arraySafeDispatcher { + contract_address, + } + ) + } + #[inline(always)] + fn write_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8, value: Imodel_with_complex_arraySafeDispatcher) -> starknet::SyscallResult<()> { + starknet::Store::::write_at_offset(address_domain, base, offset, value.contract_address)?; + starknet::SyscallResult::Ok(()) + } + #[inline(always)] + fn size() -> u8 { + starknet::Store::::size() + } +} + +#[derive(Drop, Copy)] +pub struct Imodel_with_complex_arraySafeDispatcherSubPointers { + pub contract_address: starknet::storage::StoragePointer, +} +impl Imodel_with_complex_arraySafeDispatcherSubPointersImpl of starknet::storage::SubPointers { + type SubPointersType = Imodel_with_complex_arraySafeDispatcherSubPointers; + fn sub_pointers(self: starknet::storage::StoragePointer) -> Imodel_with_complex_arraySafeDispatcherSubPointers { + let base_address = self.__storage_pointer_address__; + let mut current_offset = self.__storage_pointer_offset__; + let contract_address_value = starknet::storage::StoragePointer { + __storage_pointer_address__: base_address, + __storage_pointer_offset__: current_offset, + }; + Imodel_with_complex_arraySafeDispatcherSubPointers { + contract_address: contract_address_value, + } + } +} +#[derive(Drop, Copy)] +pub struct Imodel_with_complex_arraySafeDispatcherSubPointersMut { + pub contract_address: starknet::storage::StoragePointer>, +} +impl Imodel_with_complex_arraySafeDispatcherSubPointersMutImpl of starknet::storage::SubPointersMut { + type SubPointersType = Imodel_with_complex_arraySafeDispatcherSubPointersMut; + fn sub_pointers_mut(self: starknet::storage::StoragePointer>) -> Imodel_with_complex_arraySafeDispatcherSubPointersMut { + let base_address = self.__storage_pointer_address__; + let mut current_offset = self.__storage_pointer_offset__; + let contract_address_value = starknet::storage::StoragePointer { + __storage_pointer_address__: base_address, + __storage_pointer_offset__: current_offset, + }; + Imodel_with_complex_arraySafeDispatcherSubPointersMut { + contract_address: contract_address_value, + } + } +} +impl Imodel_with_tupleDispatcherCopy of core::traits::Copy::; +impl Imodel_with_tupleDispatcherDrop of core::traits::Drop::; +impl Imodel_with_tupleDispatcherSerde of core::serde::Serde:: { + fn serialize(self: @Imodel_with_tupleDispatcher, ref output: core::array::Array) { + core::serde::Serde::serialize(self.contract_address, ref output) + } + fn deserialize(ref serialized: core::array::Span) -> core::option::Option { + core::option::Option::Some(Imodel_with_tupleDispatcher { + contract_address: core::serde::Serde::deserialize(ref serialized)?, + }) + } +} +impl StoreImodel_with_tupleDispatcher of starknet::Store:: { + fn read(address_domain: u32, base: starknet::storage_access::StorageBaseAddress) -> starknet::SyscallResult { + let contract_address = starknet::Store::::read(address_domain, base)?; + starknet::SyscallResult::Ok( + Imodel_with_tupleDispatcher { + contract_address, + } + ) + } + fn write(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, value: Imodel_with_tupleDispatcher) -> starknet::SyscallResult<()> { + starknet::Store::::write(address_domain, base, value.contract_address)?; + starknet::SyscallResult::Ok(()) + } + fn read_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8) -> starknet::SyscallResult { + let contract_address = starknet::Store::::read_at_offset(address_domain, base, offset)?; + starknet::SyscallResult::Ok( + Imodel_with_tupleDispatcher { + contract_address, + } + ) + } + #[inline(always)] + fn write_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8, value: Imodel_with_tupleDispatcher) -> starknet::SyscallResult<()> { + starknet::Store::::write_at_offset(address_domain, base, offset, value.contract_address)?; + starknet::SyscallResult::Ok(()) + } + #[inline(always)] + fn size() -> u8 { + starknet::Store::::size() + } +} + +#[derive(Drop, Copy)] +pub struct Imodel_with_tupleDispatcherSubPointers { + pub contract_address: starknet::storage::StoragePointer, +} +impl Imodel_with_tupleDispatcherSubPointersImpl of starknet::storage::SubPointers { + type SubPointersType = Imodel_with_tupleDispatcherSubPointers; + fn sub_pointers(self: starknet::storage::StoragePointer) -> Imodel_with_tupleDispatcherSubPointers { + let base_address = self.__storage_pointer_address__; + let mut current_offset = self.__storage_pointer_offset__; + let contract_address_value = starknet::storage::StoragePointer { + __storage_pointer_address__: base_address, + __storage_pointer_offset__: current_offset, + }; + Imodel_with_tupleDispatcherSubPointers { + contract_address: contract_address_value, + } + } +} +#[derive(Drop, Copy)] +pub struct Imodel_with_tupleDispatcherSubPointersMut { + pub contract_address: starknet::storage::StoragePointer>, +} +impl Imodel_with_tupleDispatcherSubPointersMutImpl of starknet::storage::SubPointersMut { + type SubPointersType = Imodel_with_tupleDispatcherSubPointersMut; + fn sub_pointers_mut(self: starknet::storage::StoragePointer>) -> Imodel_with_tupleDispatcherSubPointersMut { + let base_address = self.__storage_pointer_address__; + let mut current_offset = self.__storage_pointer_offset__; + let contract_address_value = starknet::storage::StoragePointer { + __storage_pointer_address__: base_address, + __storage_pointer_offset__: current_offset, + }; + Imodel_with_tupleDispatcherSubPointersMut { + contract_address: contract_address_value, + } + } +} +impl Imodel_with_tupleLibraryDispatcherCopy of core::traits::Copy::; +impl Imodel_with_tupleLibraryDispatcherDrop of core::traits::Drop::; +impl Imodel_with_tupleLibraryDispatcherSerde of core::serde::Serde:: { + fn serialize(self: @Imodel_with_tupleLibraryDispatcher, ref output: core::array::Array) { + core::serde::Serde::serialize(self.class_hash, ref output) + } + fn deserialize(ref serialized: core::array::Span) -> core::option::Option { + core::option::Option::Some(Imodel_with_tupleLibraryDispatcher { + class_hash: core::serde::Serde::deserialize(ref serialized)?, + }) + } +} +impl StoreImodel_with_tupleLibraryDispatcher of starknet::Store:: { + fn read(address_domain: u32, base: starknet::storage_access::StorageBaseAddress) -> starknet::SyscallResult { + let class_hash = starknet::Store::::read(address_domain, base)?; + starknet::SyscallResult::Ok( + Imodel_with_tupleLibraryDispatcher { + class_hash, + } + ) + } + fn write(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, value: Imodel_with_tupleLibraryDispatcher) -> starknet::SyscallResult<()> { + starknet::Store::::write(address_domain, base, value.class_hash)?; + starknet::SyscallResult::Ok(()) + } + fn read_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8) -> starknet::SyscallResult { + let class_hash = starknet::Store::::read_at_offset(address_domain, base, offset)?; + starknet::SyscallResult::Ok( + Imodel_with_tupleLibraryDispatcher { + class_hash, + } + ) + } + #[inline(always)] + fn write_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8, value: Imodel_with_tupleLibraryDispatcher) -> starknet::SyscallResult<()> { + starknet::Store::::write_at_offset(address_domain, base, offset, value.class_hash)?; + starknet::SyscallResult::Ok(()) + } + #[inline(always)] + fn size() -> u8 { + starknet::Store::::size() + } +} + +#[derive(Drop, Copy)] +pub struct Imodel_with_tupleLibraryDispatcherSubPointers { + pub class_hash: starknet::storage::StoragePointer, +} +impl Imodel_with_tupleLibraryDispatcherSubPointersImpl of starknet::storage::SubPointers { + type SubPointersType = Imodel_with_tupleLibraryDispatcherSubPointers; + fn sub_pointers(self: starknet::storage::StoragePointer) -> Imodel_with_tupleLibraryDispatcherSubPointers { + let base_address = self.__storage_pointer_address__; + let mut current_offset = self.__storage_pointer_offset__; + let class_hash_value = starknet::storage::StoragePointer { + __storage_pointer_address__: base_address, + __storage_pointer_offset__: current_offset, + }; + Imodel_with_tupleLibraryDispatcherSubPointers { + class_hash: class_hash_value, + } + } +} +#[derive(Drop, Copy)] +pub struct Imodel_with_tupleLibraryDispatcherSubPointersMut { + pub class_hash: starknet::storage::StoragePointer>, +} +impl Imodel_with_tupleLibraryDispatcherSubPointersMutImpl of starknet::storage::SubPointersMut { + type SubPointersType = Imodel_with_tupleLibraryDispatcherSubPointersMut; + fn sub_pointers_mut(self: starknet::storage::StoragePointer>) -> Imodel_with_tupleLibraryDispatcherSubPointersMut { + let base_address = self.__storage_pointer_address__; + let mut current_offset = self.__storage_pointer_offset__; + let class_hash_value = starknet::storage::StoragePointer { + __storage_pointer_address__: base_address, + __storage_pointer_offset__: current_offset, + }; + Imodel_with_tupleLibraryDispatcherSubPointersMut { + class_hash: class_hash_value, + } + } +} +impl Imodel_with_tupleSafeLibraryDispatcherCopy of core::traits::Copy::; +impl Imodel_with_tupleSafeLibraryDispatcherDrop of core::traits::Drop::; +impl Imodel_with_tupleSafeLibraryDispatcherSerde of core::serde::Serde:: { + fn serialize(self: @Imodel_with_tupleSafeLibraryDispatcher, ref output: core::array::Array) { + core::serde::Serde::serialize(self.class_hash, ref output) + } + fn deserialize(ref serialized: core::array::Span) -> core::option::Option { + core::option::Option::Some(Imodel_with_tupleSafeLibraryDispatcher { + class_hash: core::serde::Serde::deserialize(ref serialized)?, + }) + } +} +impl StoreImodel_with_tupleSafeLibraryDispatcher of starknet::Store:: { + fn read(address_domain: u32, base: starknet::storage_access::StorageBaseAddress) -> starknet::SyscallResult { + let class_hash = starknet::Store::::read(address_domain, base)?; + starknet::SyscallResult::Ok( + Imodel_with_tupleSafeLibraryDispatcher { + class_hash, + } + ) + } + fn write(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, value: Imodel_with_tupleSafeLibraryDispatcher) -> starknet::SyscallResult<()> { + starknet::Store::::write(address_domain, base, value.class_hash)?; + starknet::SyscallResult::Ok(()) + } + fn read_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8) -> starknet::SyscallResult { + let class_hash = starknet::Store::::read_at_offset(address_domain, base, offset)?; + starknet::SyscallResult::Ok( + Imodel_with_tupleSafeLibraryDispatcher { + class_hash, + } + ) + } + #[inline(always)] + fn write_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8, value: Imodel_with_tupleSafeLibraryDispatcher) -> starknet::SyscallResult<()> { + starknet::Store::::write_at_offset(address_domain, base, offset, value.class_hash)?; + starknet::SyscallResult::Ok(()) + } + #[inline(always)] + fn size() -> u8 { + starknet::Store::::size() + } +} + +#[derive(Drop, Copy)] +pub struct Imodel_with_tupleSafeLibraryDispatcherSubPointers { + pub class_hash: starknet::storage::StoragePointer, +} +impl Imodel_with_tupleSafeLibraryDispatcherSubPointersImpl of starknet::storage::SubPointers { + type SubPointersType = Imodel_with_tupleSafeLibraryDispatcherSubPointers; + fn sub_pointers(self: starknet::storage::StoragePointer) -> Imodel_with_tupleSafeLibraryDispatcherSubPointers { + let base_address = self.__storage_pointer_address__; + let mut current_offset = self.__storage_pointer_offset__; + let class_hash_value = starknet::storage::StoragePointer { + __storage_pointer_address__: base_address, + __storage_pointer_offset__: current_offset, + }; + Imodel_with_tupleSafeLibraryDispatcherSubPointers { + class_hash: class_hash_value, + } + } +} +#[derive(Drop, Copy)] +pub struct Imodel_with_tupleSafeLibraryDispatcherSubPointersMut { + pub class_hash: starknet::storage::StoragePointer>, +} +impl Imodel_with_tupleSafeLibraryDispatcherSubPointersMutImpl of starknet::storage::SubPointersMut { + type SubPointersType = Imodel_with_tupleSafeLibraryDispatcherSubPointersMut; + fn sub_pointers_mut(self: starknet::storage::StoragePointer>) -> Imodel_with_tupleSafeLibraryDispatcherSubPointersMut { + let base_address = self.__storage_pointer_address__; + let mut current_offset = self.__storage_pointer_offset__; + let class_hash_value = starknet::storage::StoragePointer { + __storage_pointer_address__: base_address, + __storage_pointer_offset__: current_offset, + }; + Imodel_with_tupleSafeLibraryDispatcherSubPointersMut { + class_hash: class_hash_value, + } + } +} +impl Imodel_with_tupleSafeDispatcherCopy of core::traits::Copy::; +impl Imodel_with_tupleSafeDispatcherDrop of core::traits::Drop::; +impl Imodel_with_tupleSafeDispatcherSerde of core::serde::Serde:: { + fn serialize(self: @Imodel_with_tupleSafeDispatcher, ref output: core::array::Array) { + core::serde::Serde::serialize(self.contract_address, ref output) + } + fn deserialize(ref serialized: core::array::Span) -> core::option::Option { + core::option::Option::Some(Imodel_with_tupleSafeDispatcher { + contract_address: core::serde::Serde::deserialize(ref serialized)?, + }) + } +} +impl StoreImodel_with_tupleSafeDispatcher of starknet::Store:: { + fn read(address_domain: u32, base: starknet::storage_access::StorageBaseAddress) -> starknet::SyscallResult { + let contract_address = starknet::Store::::read(address_domain, base)?; + starknet::SyscallResult::Ok( + Imodel_with_tupleSafeDispatcher { + contract_address, + } + ) + } + fn write(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, value: Imodel_with_tupleSafeDispatcher) -> starknet::SyscallResult<()> { + starknet::Store::::write(address_domain, base, value.contract_address)?; + starknet::SyscallResult::Ok(()) + } + fn read_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8) -> starknet::SyscallResult { + let contract_address = starknet::Store::::read_at_offset(address_domain, base, offset)?; + starknet::SyscallResult::Ok( + Imodel_with_tupleSafeDispatcher { + contract_address, + } + ) + } + #[inline(always)] + fn write_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8, value: Imodel_with_tupleSafeDispatcher) -> starknet::SyscallResult<()> { + starknet::Store::::write_at_offset(address_domain, base, offset, value.contract_address)?; + starknet::SyscallResult::Ok(()) + } + #[inline(always)] + fn size() -> u8 { + starknet::Store::::size() + } +} + +#[derive(Drop, Copy)] +pub struct Imodel_with_tupleSafeDispatcherSubPointers { + pub contract_address: starknet::storage::StoragePointer, +} +impl Imodel_with_tupleSafeDispatcherSubPointersImpl of starknet::storage::SubPointers { + type SubPointersType = Imodel_with_tupleSafeDispatcherSubPointers; + fn sub_pointers(self: starknet::storage::StoragePointer) -> Imodel_with_tupleSafeDispatcherSubPointers { + let base_address = self.__storage_pointer_address__; + let mut current_offset = self.__storage_pointer_offset__; + let contract_address_value = starknet::storage::StoragePointer { + __storage_pointer_address__: base_address, + __storage_pointer_offset__: current_offset, + }; + Imodel_with_tupleSafeDispatcherSubPointers { + contract_address: contract_address_value, + } + } +} +#[derive(Drop, Copy)] +pub struct Imodel_with_tupleSafeDispatcherSubPointersMut { + pub contract_address: starknet::storage::StoragePointer>, +} +impl Imodel_with_tupleSafeDispatcherSubPointersMutImpl of starknet::storage::SubPointersMut { + type SubPointersType = Imodel_with_tupleSafeDispatcherSubPointersMut; + fn sub_pointers_mut(self: starknet::storage::StoragePointer>) -> Imodel_with_tupleSafeDispatcherSubPointersMut { + let base_address = self.__storage_pointer_address__; + let mut current_offset = self.__storage_pointer_offset__; + let contract_address_value = starknet::storage::StoragePointer { + __storage_pointer_address__: base_address, + __storage_pointer_offset__: current_offset, + }; + Imodel_with_tupleSafeDispatcherSubPointersMut { + contract_address: contract_address_value, + } + } +} +impl Imodel_with_tuple_no_primitivesDispatcherCopy of core::traits::Copy::; +impl Imodel_with_tuple_no_primitivesDispatcherDrop of core::traits::Drop::; +impl Imodel_with_tuple_no_primitivesDispatcherSerde of core::serde::Serde:: { + fn serialize(self: @Imodel_with_tuple_no_primitivesDispatcher, ref output: core::array::Array) { + core::serde::Serde::serialize(self.contract_address, ref output) + } + fn deserialize(ref serialized: core::array::Span) -> core::option::Option { + core::option::Option::Some(Imodel_with_tuple_no_primitivesDispatcher { + contract_address: core::serde::Serde::deserialize(ref serialized)?, + }) + } +} +impl StoreImodel_with_tuple_no_primitivesDispatcher of starknet::Store:: { + fn read(address_domain: u32, base: starknet::storage_access::StorageBaseAddress) -> starknet::SyscallResult { + let contract_address = starknet::Store::::read(address_domain, base)?; + starknet::SyscallResult::Ok( + Imodel_with_tuple_no_primitivesDispatcher { + contract_address, + } + ) + } + fn write(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, value: Imodel_with_tuple_no_primitivesDispatcher) -> starknet::SyscallResult<()> { + starknet::Store::::write(address_domain, base, value.contract_address)?; + starknet::SyscallResult::Ok(()) + } + fn read_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8) -> starknet::SyscallResult { + let contract_address = starknet::Store::::read_at_offset(address_domain, base, offset)?; + starknet::SyscallResult::Ok( + Imodel_with_tuple_no_primitivesDispatcher { + contract_address, + } + ) + } + #[inline(always)] + fn write_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8, value: Imodel_with_tuple_no_primitivesDispatcher) -> starknet::SyscallResult<()> { + starknet::Store::::write_at_offset(address_domain, base, offset, value.contract_address)?; + starknet::SyscallResult::Ok(()) + } + #[inline(always)] + fn size() -> u8 { + starknet::Store::::size() + } +} + +#[derive(Drop, Copy)] +pub struct Imodel_with_tuple_no_primitivesDispatcherSubPointers { + pub contract_address: starknet::storage::StoragePointer, +} +impl Imodel_with_tuple_no_primitivesDispatcherSubPointersImpl of starknet::storage::SubPointers { + type SubPointersType = Imodel_with_tuple_no_primitivesDispatcherSubPointers; + fn sub_pointers(self: starknet::storage::StoragePointer) -> Imodel_with_tuple_no_primitivesDispatcherSubPointers { + let base_address = self.__storage_pointer_address__; + let mut current_offset = self.__storage_pointer_offset__; + let contract_address_value = starknet::storage::StoragePointer { + __storage_pointer_address__: base_address, + __storage_pointer_offset__: current_offset, + }; + Imodel_with_tuple_no_primitivesDispatcherSubPointers { + contract_address: contract_address_value, + } + } +} +#[derive(Drop, Copy)] +pub struct Imodel_with_tuple_no_primitivesDispatcherSubPointersMut { + pub contract_address: starknet::storage::StoragePointer>, +} +impl Imodel_with_tuple_no_primitivesDispatcherSubPointersMutImpl of starknet::storage::SubPointersMut { + type SubPointersType = Imodel_with_tuple_no_primitivesDispatcherSubPointersMut; + fn sub_pointers_mut(self: starknet::storage::StoragePointer>) -> Imodel_with_tuple_no_primitivesDispatcherSubPointersMut { + let base_address = self.__storage_pointer_address__; + let mut current_offset = self.__storage_pointer_offset__; + let contract_address_value = starknet::storage::StoragePointer { + __storage_pointer_address__: base_address, + __storage_pointer_offset__: current_offset, + }; + Imodel_with_tuple_no_primitivesDispatcherSubPointersMut { + contract_address: contract_address_value, + } + } +} +impl Imodel_with_tuple_no_primitivesLibraryDispatcherCopy of core::traits::Copy::; +impl Imodel_with_tuple_no_primitivesLibraryDispatcherDrop of core::traits::Drop::; +impl Imodel_with_tuple_no_primitivesLibraryDispatcherSerde of core::serde::Serde:: { + fn serialize(self: @Imodel_with_tuple_no_primitivesLibraryDispatcher, ref output: core::array::Array) { + core::serde::Serde::serialize(self.class_hash, ref output) + } + fn deserialize(ref serialized: core::array::Span) -> core::option::Option { + core::option::Option::Some(Imodel_with_tuple_no_primitivesLibraryDispatcher { + class_hash: core::serde::Serde::deserialize(ref serialized)?, + }) + } +} +impl StoreImodel_with_tuple_no_primitivesLibraryDispatcher of starknet::Store:: { + fn read(address_domain: u32, base: starknet::storage_access::StorageBaseAddress) -> starknet::SyscallResult { + let class_hash = starknet::Store::::read(address_domain, base)?; + starknet::SyscallResult::Ok( + Imodel_with_tuple_no_primitivesLibraryDispatcher { + class_hash, + } + ) + } + fn write(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, value: Imodel_with_tuple_no_primitivesLibraryDispatcher) -> starknet::SyscallResult<()> { + starknet::Store::::write(address_domain, base, value.class_hash)?; + starknet::SyscallResult::Ok(()) + } + fn read_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8) -> starknet::SyscallResult { + let class_hash = starknet::Store::::read_at_offset(address_domain, base, offset)?; + starknet::SyscallResult::Ok( + Imodel_with_tuple_no_primitivesLibraryDispatcher { + class_hash, + } + ) + } + #[inline(always)] + fn write_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8, value: Imodel_with_tuple_no_primitivesLibraryDispatcher) -> starknet::SyscallResult<()> { + starknet::Store::::write_at_offset(address_domain, base, offset, value.class_hash)?; + starknet::SyscallResult::Ok(()) + } + #[inline(always)] + fn size() -> u8 { + starknet::Store::::size() + } +} + +#[derive(Drop, Copy)] +pub struct Imodel_with_tuple_no_primitivesLibraryDispatcherSubPointers { + pub class_hash: starknet::storage::StoragePointer, +} +impl Imodel_with_tuple_no_primitivesLibraryDispatcherSubPointersImpl of starknet::storage::SubPointers { + type SubPointersType = Imodel_with_tuple_no_primitivesLibraryDispatcherSubPointers; + fn sub_pointers(self: starknet::storage::StoragePointer) -> Imodel_with_tuple_no_primitivesLibraryDispatcherSubPointers { + let base_address = self.__storage_pointer_address__; + let mut current_offset = self.__storage_pointer_offset__; + let class_hash_value = starknet::storage::StoragePointer { + __storage_pointer_address__: base_address, + __storage_pointer_offset__: current_offset, + }; + Imodel_with_tuple_no_primitivesLibraryDispatcherSubPointers { + class_hash: class_hash_value, + } + } +} +#[derive(Drop, Copy)] +pub struct Imodel_with_tuple_no_primitivesLibraryDispatcherSubPointersMut { + pub class_hash: starknet::storage::StoragePointer>, +} +impl Imodel_with_tuple_no_primitivesLibraryDispatcherSubPointersMutImpl of starknet::storage::SubPointersMut { + type SubPointersType = Imodel_with_tuple_no_primitivesLibraryDispatcherSubPointersMut; + fn sub_pointers_mut(self: starknet::storage::StoragePointer>) -> Imodel_with_tuple_no_primitivesLibraryDispatcherSubPointersMut { + let base_address = self.__storage_pointer_address__; + let mut current_offset = self.__storage_pointer_offset__; + let class_hash_value = starknet::storage::StoragePointer { + __storage_pointer_address__: base_address, + __storage_pointer_offset__: current_offset, + }; + Imodel_with_tuple_no_primitivesLibraryDispatcherSubPointersMut { + class_hash: class_hash_value, + } + } +} +impl Imodel_with_tuple_no_primitivesSafeLibraryDispatcherCopy of core::traits::Copy::; +impl Imodel_with_tuple_no_primitivesSafeLibraryDispatcherDrop of core::traits::Drop::; +impl Imodel_with_tuple_no_primitivesSafeLibraryDispatcherSerde of core::serde::Serde:: { + fn serialize(self: @Imodel_with_tuple_no_primitivesSafeLibraryDispatcher, ref output: core::array::Array) { + core::serde::Serde::serialize(self.class_hash, ref output) + } + fn deserialize(ref serialized: core::array::Span) -> core::option::Option { + core::option::Option::Some(Imodel_with_tuple_no_primitivesSafeLibraryDispatcher { + class_hash: core::serde::Serde::deserialize(ref serialized)?, + }) + } +} +impl StoreImodel_with_tuple_no_primitivesSafeLibraryDispatcher of starknet::Store:: { + fn read(address_domain: u32, base: starknet::storage_access::StorageBaseAddress) -> starknet::SyscallResult { + let class_hash = starknet::Store::::read(address_domain, base)?; + starknet::SyscallResult::Ok( + Imodel_with_tuple_no_primitivesSafeLibraryDispatcher { + class_hash, + } + ) + } + fn write(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, value: Imodel_with_tuple_no_primitivesSafeLibraryDispatcher) -> starknet::SyscallResult<()> { + starknet::Store::::write(address_domain, base, value.class_hash)?; + starknet::SyscallResult::Ok(()) + } + fn read_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8) -> starknet::SyscallResult { + let class_hash = starknet::Store::::read_at_offset(address_domain, base, offset)?; + starknet::SyscallResult::Ok( + Imodel_with_tuple_no_primitivesSafeLibraryDispatcher { + class_hash, + } + ) + } + #[inline(always)] + fn write_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8, value: Imodel_with_tuple_no_primitivesSafeLibraryDispatcher) -> starknet::SyscallResult<()> { + starknet::Store::::write_at_offset(address_domain, base, offset, value.class_hash)?; + starknet::SyscallResult::Ok(()) + } + #[inline(always)] + fn size() -> u8 { + starknet::Store::::size() + } +} + +#[derive(Drop, Copy)] +pub struct Imodel_with_tuple_no_primitivesSafeLibraryDispatcherSubPointers { + pub class_hash: starknet::storage::StoragePointer, +} +impl Imodel_with_tuple_no_primitivesSafeLibraryDispatcherSubPointersImpl of starknet::storage::SubPointers { + type SubPointersType = Imodel_with_tuple_no_primitivesSafeLibraryDispatcherSubPointers; + fn sub_pointers(self: starknet::storage::StoragePointer) -> Imodel_with_tuple_no_primitivesSafeLibraryDispatcherSubPointers { + let base_address = self.__storage_pointer_address__; + let mut current_offset = self.__storage_pointer_offset__; + let class_hash_value = starknet::storage::StoragePointer { + __storage_pointer_address__: base_address, + __storage_pointer_offset__: current_offset, + }; + Imodel_with_tuple_no_primitivesSafeLibraryDispatcherSubPointers { + class_hash: class_hash_value, + } + } +} +#[derive(Drop, Copy)] +pub struct Imodel_with_tuple_no_primitivesSafeLibraryDispatcherSubPointersMut { + pub class_hash: starknet::storage::StoragePointer>, +} +impl Imodel_with_tuple_no_primitivesSafeLibraryDispatcherSubPointersMutImpl of starknet::storage::SubPointersMut { + type SubPointersType = Imodel_with_tuple_no_primitivesSafeLibraryDispatcherSubPointersMut; + fn sub_pointers_mut(self: starknet::storage::StoragePointer>) -> Imodel_with_tuple_no_primitivesSafeLibraryDispatcherSubPointersMut { + let base_address = self.__storage_pointer_address__; + let mut current_offset = self.__storage_pointer_offset__; + let class_hash_value = starknet::storage::StoragePointer { + __storage_pointer_address__: base_address, + __storage_pointer_offset__: current_offset, + }; + Imodel_with_tuple_no_primitivesSafeLibraryDispatcherSubPointersMut { + class_hash: class_hash_value, + } + } +} +impl Imodel_with_tuple_no_primitivesSafeDispatcherCopy of core::traits::Copy::; +impl Imodel_with_tuple_no_primitivesSafeDispatcherDrop of core::traits::Drop::; +impl Imodel_with_tuple_no_primitivesSafeDispatcherSerde of core::serde::Serde:: { + fn serialize(self: @Imodel_with_tuple_no_primitivesSafeDispatcher, ref output: core::array::Array) { + core::serde::Serde::serialize(self.contract_address, ref output) + } + fn deserialize(ref serialized: core::array::Span) -> core::option::Option { + core::option::Option::Some(Imodel_with_tuple_no_primitivesSafeDispatcher { + contract_address: core::serde::Serde::deserialize(ref serialized)?, + }) + } +} +impl StoreImodel_with_tuple_no_primitivesSafeDispatcher of starknet::Store:: { + fn read(address_domain: u32, base: starknet::storage_access::StorageBaseAddress) -> starknet::SyscallResult { + let contract_address = starknet::Store::::read(address_domain, base)?; + starknet::SyscallResult::Ok( + Imodel_with_tuple_no_primitivesSafeDispatcher { + contract_address, + } + ) + } + fn write(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, value: Imodel_with_tuple_no_primitivesSafeDispatcher) -> starknet::SyscallResult<()> { + starknet::Store::::write(address_domain, base, value.contract_address)?; + starknet::SyscallResult::Ok(()) + } + fn read_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8) -> starknet::SyscallResult { + let contract_address = starknet::Store::::read_at_offset(address_domain, base, offset)?; + starknet::SyscallResult::Ok( + Imodel_with_tuple_no_primitivesSafeDispatcher { + contract_address, + } + ) + } + #[inline(always)] + fn write_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8, value: Imodel_with_tuple_no_primitivesSafeDispatcher) -> starknet::SyscallResult<()> { + starknet::Store::::write_at_offset(address_domain, base, offset, value.contract_address)?; + starknet::SyscallResult::Ok(()) + } + #[inline(always)] + fn size() -> u8 { + starknet::Store::::size() + } +} + +#[derive(Drop, Copy)] +pub struct Imodel_with_tuple_no_primitivesSafeDispatcherSubPointers { + pub contract_address: starknet::storage::StoragePointer, +} +impl Imodel_with_tuple_no_primitivesSafeDispatcherSubPointersImpl of starknet::storage::SubPointers { + type SubPointersType = Imodel_with_tuple_no_primitivesSafeDispatcherSubPointers; + fn sub_pointers(self: starknet::storage::StoragePointer) -> Imodel_with_tuple_no_primitivesSafeDispatcherSubPointers { + let base_address = self.__storage_pointer_address__; + let mut current_offset = self.__storage_pointer_offset__; + let contract_address_value = starknet::storage::StoragePointer { + __storage_pointer_address__: base_address, + __storage_pointer_offset__: current_offset, + }; + Imodel_with_tuple_no_primitivesSafeDispatcherSubPointers { + contract_address: contract_address_value, + } + } +} +#[derive(Drop, Copy)] +pub struct Imodel_with_tuple_no_primitivesSafeDispatcherSubPointersMut { + pub contract_address: starknet::storage::StoragePointer>, +} +impl Imodel_with_tuple_no_primitivesSafeDispatcherSubPointersMutImpl of starknet::storage::SubPointersMut { + type SubPointersType = Imodel_with_tuple_no_primitivesSafeDispatcherSubPointersMut; + fn sub_pointers_mut(self: starknet::storage::StoragePointer>) -> Imodel_with_tuple_no_primitivesSafeDispatcherSubPointersMut { + let base_address = self.__storage_pointer_address__; + let mut current_offset = self.__storage_pointer_offset__; + let contract_address_value = starknet::storage::StoragePointer { + __storage_pointer_address__: base_address, + __storage_pointer_offset__: current_offset, + }; + Imodel_with_tuple_no_primitivesSafeDispatcherSubPointersMut { + contract_address: contract_address_value, + } + } +} +impl Ibad_model_multiple_versionsDispatcherSubPointersDrop of core::traits::Drop::; +impl Ibad_model_multiple_versionsDispatcherSubPointersCopy of core::traits::Copy::; +impl Ibad_model_multiple_versionsDispatcherSubPointersMutDrop of core::traits::Drop::; +impl Ibad_model_multiple_versionsDispatcherSubPointersMutCopy of core::traits::Copy::; +impl Ibad_model_multiple_versionsLibraryDispatcherSubPointersDrop of core::traits::Drop::; +impl Ibad_model_multiple_versionsLibraryDispatcherSubPointersCopy of core::traits::Copy::; +impl Ibad_model_multiple_versionsLibraryDispatcherSubPointersMutDrop of core::traits::Drop::; +impl Ibad_model_multiple_versionsLibraryDispatcherSubPointersMutCopy of core::traits::Copy::; +impl Ibad_model_multiple_versionsSafeLibraryDispatcherSubPointersDrop of core::traits::Drop::; +impl Ibad_model_multiple_versionsSafeLibraryDispatcherSubPointersCopy of core::traits::Copy::; +impl Ibad_model_multiple_versionsSafeLibraryDispatcherSubPointersMutDrop of core::traits::Drop::; +impl Ibad_model_multiple_versionsSafeLibraryDispatcherSubPointersMutCopy of core::traits::Copy::; +impl Ibad_model_multiple_versionsSafeDispatcherSubPointersDrop of core::traits::Drop::; +impl Ibad_model_multiple_versionsSafeDispatcherSubPointersCopy of core::traits::Copy::; +impl Ibad_model_multiple_versionsSafeDispatcherSubPointersMutDrop of core::traits::Drop::; +impl Ibad_model_multiple_versionsSafeDispatcherSubPointersMutCopy of core::traits::Copy::; +impl Ibad_model_bad_version_typeDispatcherSubPointersDrop of core::traits::Drop::; +impl Ibad_model_bad_version_typeDispatcherSubPointersCopy of core::traits::Copy::; +impl Ibad_model_bad_version_typeDispatcherSubPointersMutDrop of core::traits::Drop::; +impl Ibad_model_bad_version_typeDispatcherSubPointersMutCopy of core::traits::Copy::; +impl Ibad_model_bad_version_typeLibraryDispatcherSubPointersDrop of core::traits::Drop::; +impl Ibad_model_bad_version_typeLibraryDispatcherSubPointersCopy of core::traits::Copy::; +impl Ibad_model_bad_version_typeLibraryDispatcherSubPointersMutDrop of core::traits::Drop::; +impl Ibad_model_bad_version_typeLibraryDispatcherSubPointersMutCopy of core::traits::Copy::; +impl Ibad_model_bad_version_typeSafeLibraryDispatcherSubPointersDrop of core::traits::Drop::; +impl Ibad_model_bad_version_typeSafeLibraryDispatcherSubPointersCopy of core::traits::Copy::; +impl Ibad_model_bad_version_typeSafeLibraryDispatcherSubPointersMutDrop of core::traits::Drop::; +impl Ibad_model_bad_version_typeSafeLibraryDispatcherSubPointersMutCopy of core::traits::Copy::; +impl Ibad_model_bad_version_typeSafeDispatcherSubPointersDrop of core::traits::Drop::; +impl Ibad_model_bad_version_typeSafeDispatcherSubPointersCopy of core::traits::Copy::; +impl Ibad_model_bad_version_typeSafeDispatcherSubPointersMutDrop of core::traits::Drop::; +impl Ibad_model_bad_version_typeSafeDispatcherSubPointersMutCopy of core::traits::Copy::; +impl Ibad_model_no_version_valueDispatcherSubPointersDrop of core::traits::Drop::; +impl Ibad_model_no_version_valueDispatcherSubPointersCopy of core::traits::Copy::; +impl Ibad_model_no_version_valueDispatcherSubPointersMutDrop of core::traits::Drop::; +impl Ibad_model_no_version_valueDispatcherSubPointersMutCopy of core::traits::Copy::; +impl Ibad_model_no_version_valueLibraryDispatcherSubPointersDrop of core::traits::Drop::; +impl Ibad_model_no_version_valueLibraryDispatcherSubPointersCopy of core::traits::Copy::; +impl Ibad_model_no_version_valueLibraryDispatcherSubPointersMutDrop of core::traits::Drop::; +impl Ibad_model_no_version_valueLibraryDispatcherSubPointersMutCopy of core::traits::Copy::; +impl Ibad_model_no_version_valueSafeLibraryDispatcherSubPointersDrop of core::traits::Drop::; +impl Ibad_model_no_version_valueSafeLibraryDispatcherSubPointersCopy of core::traits::Copy::; +impl Ibad_model_no_version_valueSafeLibraryDispatcherSubPointersMutDrop of core::traits::Drop::; +impl Ibad_model_no_version_valueSafeLibraryDispatcherSubPointersMutCopy of core::traits::Copy::; +impl Ibad_model_no_version_valueSafeDispatcherSubPointersDrop of core::traits::Drop::; +impl Ibad_model_no_version_valueSafeDispatcherSubPointersCopy of core::traits::Copy::; +impl Ibad_model_no_version_valueSafeDispatcherSubPointersMutDrop of core::traits::Drop::; +impl Ibad_model_no_version_valueSafeDispatcherSubPointersMutCopy of core::traits::Copy::; +impl Ibad_model_unexpected_arg_with_valueDispatcherSubPointersDrop of core::traits::Drop::; +impl Ibad_model_unexpected_arg_with_valueDispatcherSubPointersCopy of core::traits::Copy::; +impl Ibad_model_unexpected_arg_with_valueDispatcherSubPointersMutDrop of core::traits::Drop::; +impl Ibad_model_unexpected_arg_with_valueDispatcherSubPointersMutCopy of core::traits::Copy::; +impl Ibad_model_unexpected_arg_with_valueLibraryDispatcherSubPointersDrop of core::traits::Drop::; +impl Ibad_model_unexpected_arg_with_valueLibraryDispatcherSubPointersCopy of core::traits::Copy::; +impl Ibad_model_unexpected_arg_with_valueLibraryDispatcherSubPointersMutDrop of core::traits::Drop::; +impl Ibad_model_unexpected_arg_with_valueLibraryDispatcherSubPointersMutCopy of core::traits::Copy::; +impl Ibad_model_unexpected_arg_with_valueSafeLibraryDispatcherSubPointersDrop of core::traits::Drop::; +impl Ibad_model_unexpected_arg_with_valueSafeLibraryDispatcherSubPointersCopy of core::traits::Copy::; +impl Ibad_model_unexpected_arg_with_valueSafeLibraryDispatcherSubPointersMutDrop of core::traits::Drop::; +impl Ibad_model_unexpected_arg_with_valueSafeLibraryDispatcherSubPointersMutCopy of core::traits::Copy::; +impl Ibad_model_unexpected_arg_with_valueSafeDispatcherSubPointersDrop of core::traits::Drop::; +impl Ibad_model_unexpected_arg_with_valueSafeDispatcherSubPointersCopy of core::traits::Copy::; +impl Ibad_model_unexpected_arg_with_valueSafeDispatcherSubPointersMutDrop of core::traits::Drop::; +impl Ibad_model_unexpected_arg_with_valueSafeDispatcherSubPointersMutCopy of core::traits::Copy::; +impl Ibad_model_unexpected_argDispatcherSubPointersDrop of core::traits::Drop::; +impl Ibad_model_unexpected_argDispatcherSubPointersCopy of core::traits::Copy::; +impl Ibad_model_unexpected_argDispatcherSubPointersMutDrop of core::traits::Drop::; +impl Ibad_model_unexpected_argDispatcherSubPointersMutCopy of core::traits::Copy::; +impl Ibad_model_unexpected_argLibraryDispatcherSubPointersDrop of core::traits::Drop::; +impl Ibad_model_unexpected_argLibraryDispatcherSubPointersCopy of core::traits::Copy::; +impl Ibad_model_unexpected_argLibraryDispatcherSubPointersMutDrop of core::traits::Drop::; +impl Ibad_model_unexpected_argLibraryDispatcherSubPointersMutCopy of core::traits::Copy::; +impl Ibad_model_unexpected_argSafeLibraryDispatcherSubPointersDrop of core::traits::Drop::; +impl Ibad_model_unexpected_argSafeLibraryDispatcherSubPointersCopy of core::traits::Copy::; +impl Ibad_model_unexpected_argSafeLibraryDispatcherSubPointersMutDrop of core::traits::Drop::; +impl Ibad_model_unexpected_argSafeLibraryDispatcherSubPointersMutCopy of core::traits::Copy::; +impl Ibad_model_unexpected_argSafeDispatcherSubPointersDrop of core::traits::Drop::; +impl Ibad_model_unexpected_argSafeDispatcherSubPointersCopy of core::traits::Copy::; +impl Ibad_model_unexpected_argSafeDispatcherSubPointersMutDrop of core::traits::Drop::; +impl Ibad_model_unexpected_argSafeDispatcherSubPointersMutCopy of core::traits::Copy::; +impl Ibad_model_not_supported_versionDispatcherSubPointersDrop of core::traits::Drop::; +impl Ibad_model_not_supported_versionDispatcherSubPointersCopy of core::traits::Copy::; +impl Ibad_model_not_supported_versionDispatcherSubPointersMutDrop of core::traits::Drop::; +impl Ibad_model_not_supported_versionDispatcherSubPointersMutCopy of core::traits::Copy::; +impl Ibad_model_not_supported_versionLibraryDispatcherSubPointersDrop of core::traits::Drop::; +impl Ibad_model_not_supported_versionLibraryDispatcherSubPointersCopy of core::traits::Copy::; +impl Ibad_model_not_supported_versionLibraryDispatcherSubPointersMutDrop of core::traits::Drop::; +impl Ibad_model_not_supported_versionLibraryDispatcherSubPointersMutCopy of core::traits::Copy::; +impl Ibad_model_not_supported_versionSafeLibraryDispatcherSubPointersDrop of core::traits::Drop::; +impl Ibad_model_not_supported_versionSafeLibraryDispatcherSubPointersCopy of core::traits::Copy::; +impl Ibad_model_not_supported_versionSafeLibraryDispatcherSubPointersMutDrop of core::traits::Drop::; +impl Ibad_model_not_supported_versionSafeLibraryDispatcherSubPointersMutCopy of core::traits::Copy::; +impl Ibad_model_not_supported_versionSafeDispatcherSubPointersDrop of core::traits::Drop::; +impl Ibad_model_not_supported_versionSafeDispatcherSubPointersCopy of core::traits::Copy::; +impl Ibad_model_not_supported_versionSafeDispatcherSubPointersMutDrop of core::traits::Drop::; +impl Ibad_model_not_supported_versionSafeDispatcherSubPointersMutCopy of core::traits::Copy::; +impl Imodelv_0DispatcherSubPointersDrop of core::traits::Drop::; +impl Imodelv_0DispatcherSubPointersCopy of core::traits::Copy::; +impl Imodelv_0DispatcherSubPointersMutDrop of core::traits::Drop::; +impl Imodelv_0DispatcherSubPointersMutCopy of core::traits::Copy::; +impl Imodelv_0LibraryDispatcherSubPointersDrop of core::traits::Drop::; +impl Imodelv_0LibraryDispatcherSubPointersCopy of core::traits::Copy::; +impl Imodelv_0LibraryDispatcherSubPointersMutDrop of core::traits::Drop::; +impl Imodelv_0LibraryDispatcherSubPointersMutCopy of core::traits::Copy::; +impl Imodelv_0SafeLibraryDispatcherSubPointersDrop of core::traits::Drop::; +impl Imodelv_0SafeLibraryDispatcherSubPointersCopy of core::traits::Copy::; +impl Imodelv_0SafeLibraryDispatcherSubPointersMutDrop of core::traits::Drop::; +impl Imodelv_0SafeLibraryDispatcherSubPointersMutCopy of core::traits::Copy::; +impl Imodelv_0SafeDispatcherSubPointersDrop of core::traits::Drop::; +impl Imodelv_0SafeDispatcherSubPointersCopy of core::traits::Copy::; +impl Imodelv_0SafeDispatcherSubPointersMutDrop of core::traits::Drop::; +impl Imodelv_0SafeDispatcherSubPointersMutCopy of core::traits::Copy::; +impl Imodel_with_bad_namespace_formatDispatcherSubPointersDrop of core::traits::Drop::; +impl Imodel_with_bad_namespace_formatDispatcherSubPointersCopy of core::traits::Copy::; +impl Imodel_with_bad_namespace_formatDispatcherSubPointersMutDrop of core::traits::Drop::; +impl Imodel_with_bad_namespace_formatDispatcherSubPointersMutCopy of core::traits::Copy::; +impl Imodel_with_bad_namespace_formatLibraryDispatcherSubPointersDrop of core::traits::Drop::; +impl Imodel_with_bad_namespace_formatLibraryDispatcherSubPointersCopy of core::traits::Copy::; +impl Imodel_with_bad_namespace_formatLibraryDispatcherSubPointersMutDrop of core::traits::Drop::; +impl Imodel_with_bad_namespace_formatLibraryDispatcherSubPointersMutCopy of core::traits::Copy::; +impl Imodel_with_bad_namespace_formatSafeLibraryDispatcherSubPointersDrop of core::traits::Drop::; +impl Imodel_with_bad_namespace_formatSafeLibraryDispatcherSubPointersCopy of core::traits::Copy::; +impl Imodel_with_bad_namespace_formatSafeLibraryDispatcherSubPointersMutDrop of core::traits::Drop::; +impl Imodel_with_bad_namespace_formatSafeLibraryDispatcherSubPointersMutCopy of core::traits::Copy::; +impl Imodel_with_bad_namespace_formatSafeDispatcherSubPointersDrop of core::traits::Drop::; +impl Imodel_with_bad_namespace_formatSafeDispatcherSubPointersCopy of core::traits::Copy::; +impl Imodel_with_bad_namespace_formatSafeDispatcherSubPointersMutDrop of core::traits::Drop::; +impl Imodel_with_bad_namespace_formatSafeDispatcherSubPointersMutCopy of core::traits::Copy::; +impl Imodel_with_short_string_namespaceDispatcherSubPointersDrop of core::traits::Drop::; +impl Imodel_with_short_string_namespaceDispatcherSubPointersCopy of core::traits::Copy::; +impl Imodel_with_short_string_namespaceDispatcherSubPointersMutDrop of core::traits::Drop::; +impl Imodel_with_short_string_namespaceDispatcherSubPointersMutCopy of core::traits::Copy::; +impl Imodel_with_short_string_namespaceLibraryDispatcherSubPointersDrop of core::traits::Drop::; +impl Imodel_with_short_string_namespaceLibraryDispatcherSubPointersCopy of core::traits::Copy::; +impl Imodel_with_short_string_namespaceLibraryDispatcherSubPointersMutDrop of core::traits::Drop::; +impl Imodel_with_short_string_namespaceLibraryDispatcherSubPointersMutCopy of core::traits::Copy::; +impl Imodel_with_short_string_namespaceSafeLibraryDispatcherSubPointersDrop of core::traits::Drop::; +impl Imodel_with_short_string_namespaceSafeLibraryDispatcherSubPointersCopy of core::traits::Copy::; +impl Imodel_with_short_string_namespaceSafeLibraryDispatcherSubPointersMutDrop of core::traits::Drop::; +impl Imodel_with_short_string_namespaceSafeLibraryDispatcherSubPointersMutCopy of core::traits::Copy::; +impl Imodel_with_short_string_namespaceSafeDispatcherSubPointersDrop of core::traits::Drop::; +impl Imodel_with_short_string_namespaceSafeDispatcherSubPointersCopy of core::traits::Copy::; +impl Imodel_with_short_string_namespaceSafeDispatcherSubPointersMutDrop of core::traits::Drop::; +impl Imodel_with_short_string_namespaceSafeDispatcherSubPointersMutCopy of core::traits::Copy::; +impl Imodel_with_string_namespaceDispatcherSubPointersDrop of core::traits::Drop::; +impl Imodel_with_string_namespaceDispatcherSubPointersCopy of core::traits::Copy::; +impl Imodel_with_string_namespaceDispatcherSubPointersMutDrop of core::traits::Drop::; +impl Imodel_with_string_namespaceDispatcherSubPointersMutCopy of core::traits::Copy::; +impl Imodel_with_string_namespaceLibraryDispatcherSubPointersDrop of core::traits::Drop::; +impl Imodel_with_string_namespaceLibraryDispatcherSubPointersCopy of core::traits::Copy::; +impl Imodel_with_string_namespaceLibraryDispatcherSubPointersMutDrop of core::traits::Drop::; +impl Imodel_with_string_namespaceLibraryDispatcherSubPointersMutCopy of core::traits::Copy::; +impl Imodel_with_string_namespaceSafeLibraryDispatcherSubPointersDrop of core::traits::Drop::; +impl Imodel_with_string_namespaceSafeLibraryDispatcherSubPointersCopy of core::traits::Copy::; +impl Imodel_with_string_namespaceSafeLibraryDispatcherSubPointersMutDrop of core::traits::Drop::; +impl Imodel_with_string_namespaceSafeLibraryDispatcherSubPointersMutCopy of core::traits::Copy::; +impl Imodel_with_string_namespaceSafeDispatcherSubPointersDrop of core::traits::Drop::; +impl Imodel_with_string_namespaceSafeDispatcherSubPointersCopy of core::traits::Copy::; +impl Imodel_with_string_namespaceSafeDispatcherSubPointersMutDrop of core::traits::Drop::; +impl Imodel_with_string_namespaceSafeDispatcherSubPointersMutCopy of core::traits::Copy::; +impl IpositionDispatcherSubPointersDrop of core::traits::Drop::; +impl IpositionDispatcherSubPointersCopy of core::traits::Copy::; +impl IpositionDispatcherSubPointersMutDrop of core::traits::Drop::; +impl IpositionDispatcherSubPointersMutCopy of core::traits::Copy::; +impl IpositionLibraryDispatcherSubPointersDrop of core::traits::Drop::; +impl IpositionLibraryDispatcherSubPointersCopy of core::traits::Copy::; +impl IpositionLibraryDispatcherSubPointersMutDrop of core::traits::Drop::; +impl IpositionLibraryDispatcherSubPointersMutCopy of core::traits::Copy::; +impl IpositionSafeLibraryDispatcherSubPointersDrop of core::traits::Drop::; +impl IpositionSafeLibraryDispatcherSubPointersCopy of core::traits::Copy::; +impl IpositionSafeLibraryDispatcherSubPointersMutDrop of core::traits::Drop::; +impl IpositionSafeLibraryDispatcherSubPointersMutCopy of core::traits::Copy::; +impl IpositionSafeDispatcherSubPointersDrop of core::traits::Drop::; +impl IpositionSafeDispatcherSubPointersCopy of core::traits::Copy::; +impl IpositionSafeDispatcherSubPointersMutDrop of core::traits::Drop::; +impl IpositionSafeDispatcherSubPointersMutCopy of core::traits::Copy::; +impl IrolesDispatcherSubPointersDrop of core::traits::Drop::; +impl IrolesDispatcherSubPointersCopy of core::traits::Copy::; +impl IrolesDispatcherSubPointersMutDrop of core::traits::Drop::; +impl IrolesDispatcherSubPointersMutCopy of core::traits::Copy::; +impl IrolesLibraryDispatcherSubPointersDrop of core::traits::Drop::; +impl IrolesLibraryDispatcherSubPointersCopy of core::traits::Copy::; +impl IrolesLibraryDispatcherSubPointersMutDrop of core::traits::Drop::; +impl IrolesLibraryDispatcherSubPointersMutCopy of core::traits::Copy::; +impl IrolesSafeLibraryDispatcherSubPointersDrop of core::traits::Drop::; +impl IrolesSafeLibraryDispatcherSubPointersCopy of core::traits::Copy::; +impl IrolesSafeLibraryDispatcherSubPointersMutDrop of core::traits::Drop::; +impl IrolesSafeLibraryDispatcherSubPointersMutCopy of core::traits::Copy::; +impl IrolesSafeDispatcherSubPointersDrop of core::traits::Drop::; +impl IrolesSafeDispatcherSubPointersCopy of core::traits::Copy::; +impl IrolesSafeDispatcherSubPointersMutDrop of core::traits::Drop::; +impl IrolesSafeDispatcherSubPointersMutCopy of core::traits::Copy::; +impl Ionly_key_modelDispatcherSubPointersDrop of core::traits::Drop::; +impl Ionly_key_modelDispatcherSubPointersCopy of core::traits::Copy::; +impl Ionly_key_modelDispatcherSubPointersMutDrop of core::traits::Drop::; +impl Ionly_key_modelDispatcherSubPointersMutCopy of core::traits::Copy::; +impl Ionly_key_modelLibraryDispatcherSubPointersDrop of core::traits::Drop::; +impl Ionly_key_modelLibraryDispatcherSubPointersCopy of core::traits::Copy::; +impl Ionly_key_modelLibraryDispatcherSubPointersMutDrop of core::traits::Drop::; +impl Ionly_key_modelLibraryDispatcherSubPointersMutCopy of core::traits::Copy::; +impl Ionly_key_modelSafeLibraryDispatcherSubPointersDrop of core::traits::Drop::; +impl Ionly_key_modelSafeLibraryDispatcherSubPointersCopy of core::traits::Copy::; +impl Ionly_key_modelSafeLibraryDispatcherSubPointersMutDrop of core::traits::Drop::; +impl Ionly_key_modelSafeLibraryDispatcherSubPointersMutCopy of core::traits::Copy::; +impl Ionly_key_modelSafeDispatcherSubPointersDrop of core::traits::Drop::; +impl Ionly_key_modelSafeDispatcherSubPointersCopy of core::traits::Copy::; +impl Ionly_key_modelSafeDispatcherSubPointersMutDrop of core::traits::Drop::; +impl Ionly_key_modelSafeDispatcherSubPointersMutCopy of core::traits::Copy::; +impl Iu_256_key_modelDispatcherSubPointersDrop of core::traits::Drop::; +impl Iu_256_key_modelDispatcherSubPointersCopy of core::traits::Copy::; +impl Iu_256_key_modelDispatcherSubPointersMutDrop of core::traits::Drop::; +impl Iu_256_key_modelDispatcherSubPointersMutCopy of core::traits::Copy::; +impl Iu_256_key_modelLibraryDispatcherSubPointersDrop of core::traits::Drop::; +impl Iu_256_key_modelLibraryDispatcherSubPointersCopy of core::traits::Copy::; +impl Iu_256_key_modelLibraryDispatcherSubPointersMutDrop of core::traits::Drop::; +impl Iu_256_key_modelLibraryDispatcherSubPointersMutCopy of core::traits::Copy::; +impl Iu_256_key_modelSafeLibraryDispatcherSubPointersDrop of core::traits::Drop::; +impl Iu_256_key_modelSafeLibraryDispatcherSubPointersCopy of core::traits::Copy::; +impl Iu_256_key_modelSafeLibraryDispatcherSubPointersMutDrop of core::traits::Drop::; +impl Iu_256_key_modelSafeLibraryDispatcherSubPointersMutCopy of core::traits::Copy::; +impl Iu_256_key_modelSafeDispatcherSubPointersDrop of core::traits::Drop::; +impl Iu_256_key_modelSafeDispatcherSubPointersCopy of core::traits::Copy::; +impl Iu_256_key_modelSafeDispatcherSubPointersMutDrop of core::traits::Drop::; +impl Iu_256_key_modelSafeDispatcherSubPointersMutCopy of core::traits::Copy::; +impl IplayerDispatcherSubPointersDrop of core::traits::Drop::; +impl IplayerDispatcherSubPointersCopy of core::traits::Copy::; +impl IplayerDispatcherSubPointersMutDrop of core::traits::Drop::; +impl IplayerDispatcherSubPointersMutCopy of core::traits::Copy::; +impl IplayerLibraryDispatcherSubPointersDrop of core::traits::Drop::; +impl IplayerLibraryDispatcherSubPointersCopy of core::traits::Copy::; +impl IplayerLibraryDispatcherSubPointersMutDrop of core::traits::Drop::; +impl IplayerLibraryDispatcherSubPointersMutCopy of core::traits::Copy::; +impl IplayerSafeLibraryDispatcherSubPointersDrop of core::traits::Drop::; +impl IplayerSafeLibraryDispatcherSubPointersCopy of core::traits::Copy::; +impl IplayerSafeLibraryDispatcherSubPointersMutDrop of core::traits::Drop::; +impl IplayerSafeLibraryDispatcherSubPointersMutCopy of core::traits::Copy::; +impl IplayerSafeDispatcherSubPointersDrop of core::traits::Drop::; +impl IplayerSafeDispatcherSubPointersCopy of core::traits::Copy::; +impl IplayerSafeDispatcherSubPointersMutDrop of core::traits::Drop::; +impl IplayerSafeDispatcherSubPointersMutCopy of core::traits::Copy::; +impl Imodel_with_simple_arrayDispatcherSubPointersDrop of core::traits::Drop::; +impl Imodel_with_simple_arrayDispatcherSubPointersCopy of core::traits::Copy::; +impl Imodel_with_simple_arrayDispatcherSubPointersMutDrop of core::traits::Drop::; +impl Imodel_with_simple_arrayDispatcherSubPointersMutCopy of core::traits::Copy::; +impl Imodel_with_simple_arrayLibraryDispatcherSubPointersDrop of core::traits::Drop::; +impl Imodel_with_simple_arrayLibraryDispatcherSubPointersCopy of core::traits::Copy::; +impl Imodel_with_simple_arrayLibraryDispatcherSubPointersMutDrop of core::traits::Drop::; +impl Imodel_with_simple_arrayLibraryDispatcherSubPointersMutCopy of core::traits::Copy::; +impl Imodel_with_simple_arraySafeLibraryDispatcherSubPointersDrop of core::traits::Drop::; +impl Imodel_with_simple_arraySafeLibraryDispatcherSubPointersCopy of core::traits::Copy::; +impl Imodel_with_simple_arraySafeLibraryDispatcherSubPointersMutDrop of core::traits::Drop::; +impl Imodel_with_simple_arraySafeLibraryDispatcherSubPointersMutCopy of core::traits::Copy::; +impl Imodel_with_simple_arraySafeDispatcherSubPointersDrop of core::traits::Drop::; +impl Imodel_with_simple_arraySafeDispatcherSubPointersCopy of core::traits::Copy::; +impl Imodel_with_simple_arraySafeDispatcherSubPointersMutDrop of core::traits::Drop::; +impl Imodel_with_simple_arraySafeDispatcherSubPointersMutCopy of core::traits::Copy::; +impl Imodel_with_byte_arrayDispatcherSubPointersDrop of core::traits::Drop::; +impl Imodel_with_byte_arrayDispatcherSubPointersCopy of core::traits::Copy::; +impl Imodel_with_byte_arrayDispatcherSubPointersMutDrop of core::traits::Drop::; +impl Imodel_with_byte_arrayDispatcherSubPointersMutCopy of core::traits::Copy::; +impl Imodel_with_byte_arrayLibraryDispatcherSubPointersDrop of core::traits::Drop::; +impl Imodel_with_byte_arrayLibraryDispatcherSubPointersCopy of core::traits::Copy::; +impl Imodel_with_byte_arrayLibraryDispatcherSubPointersMutDrop of core::traits::Drop::; +impl Imodel_with_byte_arrayLibraryDispatcherSubPointersMutCopy of core::traits::Copy::; +impl Imodel_with_byte_arraySafeLibraryDispatcherSubPointersDrop of core::traits::Drop::; +impl Imodel_with_byte_arraySafeLibraryDispatcherSubPointersCopy of core::traits::Copy::; +impl Imodel_with_byte_arraySafeLibraryDispatcherSubPointersMutDrop of core::traits::Drop::; +impl Imodel_with_byte_arraySafeLibraryDispatcherSubPointersMutCopy of core::traits::Copy::; +impl Imodel_with_byte_arraySafeDispatcherSubPointersDrop of core::traits::Drop::; +impl Imodel_with_byte_arraySafeDispatcherSubPointersCopy of core::traits::Copy::; +impl Imodel_with_byte_arraySafeDispatcherSubPointersMutDrop of core::traits::Drop::; +impl Imodel_with_byte_arraySafeDispatcherSubPointersMutCopy of core::traits::Copy::; +impl Imodel_with_complex_arrayDispatcherSubPointersDrop of core::traits::Drop::; +impl Imodel_with_complex_arrayDispatcherSubPointersCopy of core::traits::Copy::; +impl Imodel_with_complex_arrayDispatcherSubPointersMutDrop of core::traits::Drop::; +impl Imodel_with_complex_arrayDispatcherSubPointersMutCopy of core::traits::Copy::; +impl Imodel_with_complex_arrayLibraryDispatcherSubPointersDrop of core::traits::Drop::; +impl Imodel_with_complex_arrayLibraryDispatcherSubPointersCopy of core::traits::Copy::; +impl Imodel_with_complex_arrayLibraryDispatcherSubPointersMutDrop of core::traits::Drop::; +impl Imodel_with_complex_arrayLibraryDispatcherSubPointersMutCopy of core::traits::Copy::; +impl Imodel_with_complex_arraySafeLibraryDispatcherSubPointersDrop of core::traits::Drop::; +impl Imodel_with_complex_arraySafeLibraryDispatcherSubPointersCopy of core::traits::Copy::; +impl Imodel_with_complex_arraySafeLibraryDispatcherSubPointersMutDrop of core::traits::Drop::; +impl Imodel_with_complex_arraySafeLibraryDispatcherSubPointersMutCopy of core::traits::Copy::; +impl Imodel_with_complex_arraySafeDispatcherSubPointersDrop of core::traits::Drop::; +impl Imodel_with_complex_arraySafeDispatcherSubPointersCopy of core::traits::Copy::; +impl Imodel_with_complex_arraySafeDispatcherSubPointersMutDrop of core::traits::Drop::; +impl Imodel_with_complex_arraySafeDispatcherSubPointersMutCopy of core::traits::Copy::; +impl Imodel_with_tupleDispatcherSubPointersDrop of core::traits::Drop::; +impl Imodel_with_tupleDispatcherSubPointersCopy of core::traits::Copy::; +impl Imodel_with_tupleDispatcherSubPointersMutDrop of core::traits::Drop::; +impl Imodel_with_tupleDispatcherSubPointersMutCopy of core::traits::Copy::; +impl Imodel_with_tupleLibraryDispatcherSubPointersDrop of core::traits::Drop::; +impl Imodel_with_tupleLibraryDispatcherSubPointersCopy of core::traits::Copy::; +impl Imodel_with_tupleLibraryDispatcherSubPointersMutDrop of core::traits::Drop::; +impl Imodel_with_tupleLibraryDispatcherSubPointersMutCopy of core::traits::Copy::; +impl Imodel_with_tupleSafeLibraryDispatcherSubPointersDrop of core::traits::Drop::; +impl Imodel_with_tupleSafeLibraryDispatcherSubPointersCopy of core::traits::Copy::; +impl Imodel_with_tupleSafeLibraryDispatcherSubPointersMutDrop of core::traits::Drop::; +impl Imodel_with_tupleSafeLibraryDispatcherSubPointersMutCopy of core::traits::Copy::; +impl Imodel_with_tupleSafeDispatcherSubPointersDrop of core::traits::Drop::; +impl Imodel_with_tupleSafeDispatcherSubPointersCopy of core::traits::Copy::; +impl Imodel_with_tupleSafeDispatcherSubPointersMutDrop of core::traits::Drop::; +impl Imodel_with_tupleSafeDispatcherSubPointersMutCopy of core::traits::Copy::; +impl Imodel_with_tuple_no_primitivesDispatcherSubPointersDrop of core::traits::Drop::; +impl Imodel_with_tuple_no_primitivesDispatcherSubPointersCopy of core::traits::Copy::; +impl Imodel_with_tuple_no_primitivesDispatcherSubPointersMutDrop of core::traits::Drop::; +impl Imodel_with_tuple_no_primitivesDispatcherSubPointersMutCopy of core::traits::Copy::; +impl Imodel_with_tuple_no_primitivesLibraryDispatcherSubPointersDrop of core::traits::Drop::; +impl Imodel_with_tuple_no_primitivesLibraryDispatcherSubPointersCopy of core::traits::Copy::; +impl Imodel_with_tuple_no_primitivesLibraryDispatcherSubPointersMutDrop of core::traits::Drop::; +impl Imodel_with_tuple_no_primitivesLibraryDispatcherSubPointersMutCopy of core::traits::Copy::; +impl Imodel_with_tuple_no_primitivesSafeLibraryDispatcherSubPointersDrop of core::traits::Drop::; +impl Imodel_with_tuple_no_primitivesSafeLibraryDispatcherSubPointersCopy of core::traits::Copy::; +impl Imodel_with_tuple_no_primitivesSafeLibraryDispatcherSubPointersMutDrop of core::traits::Drop::; +impl Imodel_with_tuple_no_primitivesSafeLibraryDispatcherSubPointersMutCopy of core::traits::Copy::; +impl Imodel_with_tuple_no_primitivesSafeDispatcherSubPointersDrop of core::traits::Drop::; +impl Imodel_with_tuple_no_primitivesSafeDispatcherSubPointersCopy of core::traits::Copy::; +impl Imodel_with_tuple_no_primitivesSafeDispatcherSubPointersMutDrop of core::traits::Drop::; +impl Imodel_with_tuple_no_primitivesSafeDispatcherSubPointersMutCopy of core::traits::Copy::; + +//! > expected_diagnostics +error: A Dojo model must have zero or one dojo::model attribute. + --> /tmp/plugin_test/model/src/lib.cairo:1:1 +#[dojo::model(version: 0)] +^************************^ + +error: Too many 'version' attributes for dojo::model + --> /tmp/plugin_test/model/src/lib.cairo:9:1 +#[dojo::model(version: 0, version: 0)] +^************************************^ + +error: The argument 'version' of dojo::model must be an integer + --> /tmp/plugin_test/model/src/lib.cairo:16:24 +#[dojo::model(version: hello)] + ^***^ + +error: Unexpected argument 'version' for dojo::model + --> /tmp/plugin_test/model/src/lib.cairo:23:15 +#[dojo::model(version)] + ^*****^ + +error: Unexpected argument 'my_arg' for dojo::model + --> /tmp/plugin_test/model/src/lib.cairo:30:15 +#[dojo::model(my_arg: 1)] + ^*******^ + +error: Unexpected argument 'my_arg' for dojo::model + --> /tmp/plugin_test/model/src/lib.cairo:37:15 +#[dojo::model(my_arg)] + ^****^ + +error: dojo::model version 2 not supported + --> /tmp/plugin_test/model/src/lib.cairo:44:24 +#[dojo::model(version: 2)] + ^ + +error: Model must define at least one #[key] attribute + --> /tmp/plugin_test/model/src/lib.cairo:87:8 +struct Roles { + ^***^ + +error: Model must define at least one member that is not a key + --> /tmp/plugin_test/model/src/lib.cairo:92:8 +struct OnlyKeyModel { + ^**********^ + +error: Key is only supported for core types that are 1 felt long once serialized. `u256` is a struct of 2 u128, hence not supported. + --> /tmp/plugin_test/model/src/lib.cairo:100:5 + id: u256 + ^^ + +error: Model must define at least one member that is not a key + --> /tmp/plugin_test/model/src/lib.cairo:98:8 +struct U256KeyModel { + ^**********^ diff --git a/crates/compiler/src/plugin_test_data/print b/crates/compiler/src/plugin_test_data/print new file mode 100644 index 0000000..8481dd1 --- /dev/null +++ b/crates/compiler/src/plugin_test_data/print @@ -0,0 +1,136 @@ +//! > Test expansion of the derive(Print). + +//! > test_runner_name +test_expand_plugin + +//! > test_id +print + +//! > cfg +["test"] + +//! > cairo_code +use serde::Serde; +use debug::PrintTrait; + +#[derive(Print)] +struct Position { + #[key] + id: felt252, + x: felt252, + y: felt252 +} + +#[derive(Print)] +struct Roles { + role_ids: Array +} + +use starknet::ContractAddress; + +#[derive(Print)] +struct Player { + #[key] + game: felt252, + #[key] + player: ContractAddress, + name: felt252, +} + +#[derive(Print)] +enum Enemy { + Unknown, + Bot: felt252, + OtherPlayer: ContractAddress, +} + +//! > expanded_cairo_code +use serde::Serde; +use debug::PrintTrait; + +#[derive(Print)] +struct Position { + #[key] + id: felt252, + x: felt252, + y: felt252 +} + +#[derive(Print)] +struct Roles { + role_ids: Array +} + +use starknet::ContractAddress; + +#[derive(Print)] +struct Player { + #[key] + game: felt252, + #[key] + player: ContractAddress, + name: felt252, +} + +#[derive(Print)] +enum Enemy { + Unknown, + Bot: felt252, + OtherPlayer: ContractAddress, +} +#[cfg(test)] +impl PositionStructPrintImpl of core::debug::PrintTrait { + fn print(self: Position) { + core::debug::PrintTrait::print('id'); core::debug::PrintTrait::print(self.id); +core::debug::PrintTrait::print('x'); core::debug::PrintTrait::print(self.x); +core::debug::PrintTrait::print('y'); core::debug::PrintTrait::print(self.y); + } +} + +#[cfg(test)] +impl RolesStructPrintImpl of core::debug::PrintTrait { + fn print(self: Roles) { + core::debug::PrintTrait::print('role_ids'); core::debug::PrintTrait::print(self.role_ids); + } +} + +#[cfg(test)] +impl PlayerStructPrintImpl of core::debug::PrintTrait { + fn print(self: Player) { + core::debug::PrintTrait::print('game'); core::debug::PrintTrait::print(self.game); +core::debug::PrintTrait::print('player'); core::debug::PrintTrait::print(self.player); +core::debug::PrintTrait::print('name'); core::debug::PrintTrait::print(self.name); + } +} + +#[cfg(test)] +impl EnemyEnumPrintImpl of core::debug::PrintTrait { + fn print(self: Enemy) { + match self { + Enemy::Unknown => { core::debug::PrintTrait::print('Unknown'); }, +Enemy::Bot(v) => { core::debug::PrintTrait::print('Bot'); core::debug::PrintTrait::print(v); }, +Enemy::OtherPlayer(v) => { core::debug::PrintTrait::print('OtherPlayer'); core::debug::PrintTrait::print(v); } + } + } +} + +//! > expected_diagnostics +error: Unknown derive `Print` - a plugin might be missing. + --> /tmp/plugin_test/print/src/lib.cairo:4:10 +#[derive(Print)] + ^***^ + +error: Unknown derive `Print` - a plugin might be missing. + --> /tmp/plugin_test/print/src/lib.cairo:12:10 +#[derive(Print)] + ^***^ + +error: Unknown derive `Print` - a plugin might be missing. + --> /tmp/plugin_test/print/src/lib.cairo:19:10 +#[derive(Print)] + ^***^ + +error: Unknown derive `Print` - a plugin might be missing. + --> /tmp/plugin_test/print/src/lib.cairo:28:10 +#[derive(Print)] + ^***^ diff --git a/crates/compiler/src/plugin_test_data/system b/crates/compiler/src/plugin_test_data/system new file mode 100644 index 0000000..2d53e0f --- /dev/null +++ b/crates/compiler/src/plugin_test_data/system @@ -0,0 +1,11529 @@ +//! > Test expansion of the #[system]. + +//! > test_runner_name +test_expand_plugin + +//! > test_id +system + +//! > cairo_code +#[dojo::contract(namespace: "My@Namespace")] +mod bad_namespace_format { + use traits::Into; + use dojo::world::Context; + + fn execute(ctx: Context, name: felt252) { + return (); + } +} + +#[dojo::contract(namespace: 'my_namespace')] +mod spawn { + use traits::Into; + use dojo::world::Context; + + fn execute(ctx: Context, name: felt252) { + return (); + } +} + +#[dojo::contract(namespace: "my_namespace")] +mod proxy { + fn execute(value: felt252) -> felt252 { + value + } +} + +#[dojo::contract] +mod ctxnamed { + use traits::Into; + use dojo::world::Context; + + fn execute(ctx2: Context, name: felt252) { + return (); + } +} + +#[dojo::contract] +mod withevent { + #[event] + #[derive(Drop, starknet::Event)] + enum Event { + TestEvent: TestEvent, + } + + #[derive(Drop, starknet::Event)] + struct TestEvent { + address: ContractAddress, + } +} + +#[starknet::component] +mod testcomponent1 { + #[storage] + struct Storage {} +} + +#[starknet::component] +mod testcomponent2 { + #[storage] + struct Storage {} +} + +#[dojo::contract] +mod withcomponent { + component!(path: testcomponent1, storage: testcomponent1_storage, event: testcomponent1_event); + component!(path: testcomponent2, storage: testcomponent2_storage, event: testcomponent2_event); + + #[storage] + struct Storage { + #[substorage(v0)] + testcomponent1_storage: testcomponent1::Storage, + #[substorage(v0)] + testcomponent2_storage: testcomponent2::Storage, + } + + #[event] + #[derive(Drop, starknet::Event)] + enum Event { + #[flat] + testcomponent1_event: testcomponent1::Event, + testcomponent2_event: testcomponent2::Event, + } +} +#[dojo::interface] +trait IEmptyTrait; + +#[dojo::interface] +trait IFaultyTrait { + const ONE: u8; + + #[my_attr] + fn do_with_attrs(p1: u8) -> u16; +} + +#[dojo::interface] +trait INominalTrait { + fn do_no_param() -> felt252; + fn do_no_param_but_world(world: @IWorldDispatcher) -> felt252; + fn do_no_param_but_world_ref(ref world: IWorldDispatcher) -> felt252; + fn do_params_no_world(p1: felt252, p2: u8) -> felt252; + fn do_params_and_world(world: @IWorldDispatcher, p2: u8) -> felt252; + fn do_params_and_world_ref(ref world: IWorldDispatcher, p2: u8) -> felt252; + + fn do_with_self(self: @ContractState) -> felt252; + fn do_with_ref_self(ref self: ContractState) -> felt252; +} + +#[dojo::interface] +trait IFaultyTrait { + fn do_with_self_and_world(self: @ContractState, world: @IWorldDispatcher) -> felt252; + fn do_with_ref_self_and_world(ref self: ContractState, ref world: IWorldDispatcher) -> felt252; + fn do_with_self_and_world_inv(world: @IWorldDispatcher, self: @ContractState) -> felt252; + fn do_with_ref_self_and_world_inv( + ref world: IWorldDispatcher, ref self: ContractState + ) -> felt252; + fn do_with_several_world_dispatchers( + world: @IWorldDispatcher, vec: Vec2, ref another_world: IWorldDispatcher + ) -> felt252; + fn do_with_world_not_named_world(another_world: @IWorldDispatcher) -> felt252; + fn do_with_world_not_first(vec: Vec2, ref world: IWorldDispatcher) -> felt252; +} + +#[dojo::contract] +mod MyFaultyContract { + #[abi(embed_v0)] + impl TestFaultyImpl of IFaultyTrait { + fn do_with_self_and_world(self: @ContractState, world: @IWorldDispatcher) -> felt252 { + 'land' + } + + fn do_with_ref_self_and_world( + ref self: ContractState, ref world: IWorldDispatcher + ) -> felt252 { + 'land' + } + + fn do_with_self_and_world_inv(world: @IWorldDispatcher, self: @ContractState) -> felt252 { + 'land' + } + + fn do_with_ref_self_and_world_inv( + ref world: IWorldDispatcher, ref self: ContractState + ) -> felt252 { + 'land' + } + + fn do_with_several_world_dispatchers( + world: @IWorldDispatcher, vec: Vec2, ref another_world: IWorldDispatcher + ) -> felt252 { + 'land' + } + + fn do_with_world_not_named_world(another_world: @IWorldDispatcher) -> felt252 { + 'land' + } + + fn do_with_world_not_first(vec: Vec2, ref world: IWorldDispatcher) -> felt252 { + 'land' + } + } + + #[generate_trait] + impl InternalImplBad of InternalUtils { + fn bad_func_using_generate(world: @IWorldDispatcher) -> felt252 { + 'land' + } + } +} + +#[dojo::contract] +mod MyNominalContract { + #[derive(Drop)] + struct Action { + damage: u8 + } + + #[abi(embed_v0)] + impl TestNominalImpl of INominalTrait { + fn do_no_param() -> felt252 { + 'land' + } + + fn do_no_param_but_world(world: @IWorldDispatcher) -> felt252 { + 'land' + } + + fn do_no_param_but_world_ref(ref world: IWorldDispatcher) -> felt252 { + 'land' + } + + fn do_params_no_world(p1: felt252, p2: u8) -> felt252 { + 'land' + } + + fn do_params_and_world(world: @IWorldDispatcher, p2: u8) -> felt252 { + 'land' + } + + fn do_params_and_world_ref(ref world: IWorldDispatcher, p2: u8) -> felt252 { + 'land' + } + + fn do_with_self(self: @ContractState) -> felt252 { + 'land' + } + + fn do_with_ref_self(ref self: ContractState) -> felt252 { + 'land' + } + } + + #[generate_trait] + impl ImplInternalNoContractState of InternalNoContractState { + fn func1(world: IWorldDispatcher) -> felt252 { + let _w = world; + 42 + } + } +} + +#[dojo::contract] +mod init_test { + fn dojo_init( + world: IWorldDispatcher, + actions_address: ContractAddress, + actions_class: ClassHash, + value: u8 + ) { + emit!( + world, + ContractInitialized { + contract_address: actions_address, contract_class: actions_class, value + } + ); + } +} + +#[dojo::contract] +mod no_init_test {} + +//! > generated_cairo_code +#[starknet::contract] +mod spawn { + use dojo::world; + use dojo::world::IWorldDispatcher; + use dojo::world::IWorldDispatcherTrait; + + #[storage] + struct Storage { + world_dispatcher: IWorldDispatcher, + } + + #[abi(embed_v0)] + fn name(self: @ContractState) -> felt252 { + 'spawn' + } + + #[abi(embed_v0)] + impl Upgradeable of dojo::upgradable::IUpgradeable { + fn upgrade(ref self: ContractState, new_class_hash: starknet::ClassHash) { + let caller = starknet::get_caller_address(); + assert( + self.world_dispatcher.read().contract_address == caller, 'only World can upgrade' + ); + dojo::upgradable::UpgradeableTrait::upgrade(new_class_hash); + } + } + + use traits::Into; + use dojo::world::Context; + + #[abi(embed_v0)] + fn execute(self: @ContractState, ctx: Context, name: felt252) { + return (); + } +} + + +#[starknet::contract] +mod proxy { + use dojo::world; + use dojo::world::IWorldDispatcher; + use dojo::world::IWorldDispatcherTrait; + + #[storage] + struct Storage { + world_dispatcher: IWorldDispatcher, + } + + #[abi(embed_v0)] + fn name(self: @ContractState) -> felt252 { + 'proxy' + } + + #[abi(embed_v0)] + impl Upgradeable of dojo::upgradable::IUpgradeable { + fn upgrade(ref self: ContractState, new_class_hash: starknet::ClassHash) { + let caller = starknet::get_caller_address(); + assert( + self.world_dispatcher.read().contract_address == caller, 'only World can upgrade' + ); + dojo::upgradable::UpgradeableTrait::upgrade(new_class_hash); + } + } + + + #[abi(embed_v0)] + fn execute(self: @ContractState, value: felt252) -> felt252 { + value + } +} + + +#[starknet::contract] +mod ctxnamed { + use dojo::world; + use dojo::world::IWorldDispatcher; + use dojo::world::IWorldDispatcherTrait; + + #[storage] + struct Storage { + world_dispatcher: IWorldDispatcher, + } + + #[abi(embed_v0)] + fn name(self: @ContractState) -> felt252 { + 'ctxnamed' + } + + #[abi(embed_v0)] + impl Upgradeable of dojo::upgradable::IUpgradeable { + fn upgrade(ref self: ContractState, new_class_hash: starknet::ClassHash) { + let caller = starknet::get_caller_address(); + assert( + self.world_dispatcher.read().contract_address == caller, 'only World can upgrade' + ); + dojo::upgradable::UpgradeableTrait::upgrade(new_class_hash); + } + } + + use traits::Into; + use dojo::world::Context; + + #[abi(embed_v0)] + fn execute(self: @ContractState, ctx2: Context, name: felt252) { + return (); + } +} + +//! > expected_diagnostics +error: Anything other than functions is not supported in a dojo::interface + --> /tmp/plugin_test/system/src/lib.cairo:90:5 + const ONE: u8; + ^************^ + +error: World parameter must be the first parameter. + --> /tmp/plugin_test/system/src/lib.cairo:111:5 + fn do_with_self_and_world(self: @ContractState, world: @IWorldDispatcher) -> felt252; + ^***********************************************************************************^ + +error: World parameter must be the first parameter. + --> /tmp/plugin_test/system/src/lib.cairo:112:5 + fn do_with_ref_self_and_world(ref self: ContractState, ref world: IWorldDispatcher) -> felt252; + ^*********************************************************************************************^ + +error: You cannot use `self` and `world` parameters together. + --> /tmp/plugin_test/system/src/lib.cairo:113:5 + fn do_with_self_and_world_inv(world: @IWorldDispatcher, self: @ContractState) -> felt252; + ^***************************************************************************************^ + +error: You cannot use `self` and `world` parameters together. + --> /tmp/plugin_test/system/src/lib.cairo:114:5 + fn do_with_ref_self_and_world_inv( + ^********************************^ + +error: World parameter must be the first parameter. + --> /tmp/plugin_test/system/src/lib.cairo:121:5 + fn do_with_world_not_first(vec: Vec2, ref world: IWorldDispatcher) -> felt252; + ^****************************************************************************^ + +error: World parameter must be the first parameter. + --> /tmp/plugin_test/system/src/lib.cairo:128:9 + fn do_with_self_and_world(self: @ContractState, world: @IWorldDispatcher) -> felt252 { + ^************************************************************************************^ + +error: World parameter must be the first parameter. + --> /tmp/plugin_test/system/src/lib.cairo:132:9 + fn do_with_ref_self_and_world( + ^****************************^ + +error: You cannot use `self` and `world` parameters together. + --> /tmp/plugin_test/system/src/lib.cairo:138:9 + fn do_with_self_and_world_inv(world: @IWorldDispatcher, self: @ContractState) -> felt252 { + ^****************************************************************************************^ + +error: You cannot use `self` and `world` parameters together. + --> /tmp/plugin_test/system/src/lib.cairo:142:9 + fn do_with_ref_self_and_world_inv( + ^********************************^ + +error: World parameter must be the first parameter. + --> /tmp/plugin_test/system/src/lib.cairo:158:9 + fn do_with_world_not_first(vec: Vec2, ref world: IWorldDispatcher) -> felt252 { + ^*****************************************************************************^ + +error: You cannot use `world` and `#[generate_trait]` together. Use `self` instead. + --> /tmp/plugin_test/system/src/lib.cairo:165:9 + fn bad_func_using_generate(world: @IWorldDispatcher) -> felt252 { + ^***************************************************************^ + +error: World parameter must be a snapshot if `ref` is not used. + --> /tmp/plugin_test/system/src/lib.cairo:224:5 + fn dojo_init( + ^***********^ + +error: `starknet::interface` function first parameter must be a reference to the trait's generic parameter or a snapshot of it. + --> /tmp/plugin_test/system/src/lib.cairo:105:5 + fn do_with_self(self: @ContractState) -> felt252; + ^**********************************************^ + +error: `starknet::interface` function first parameter must be a reference to the trait's generic parameter or a snapshot of it. + --> /tmp/plugin_test/system/src/lib.cairo:106:5 + fn do_with_ref_self(ref self: ContractState) -> felt252; + ^*****************************************************^ + +error: `starknet::interface` function first parameter must be a reference to the trait's generic parameter or a snapshot of it. + --> /tmp/plugin_test/system/src/lib.cairo:111:5 + fn do_with_self_and_world(self: @ContractState, world: @IWorldDispatcher) -> felt252; + ^**********************************************************************************^ + +error: `starknet::interface` function first parameter must be a reference to the trait's generic parameter or a snapshot of it. + --> /tmp/plugin_test/system/src/lib.cairo:112:5 + fn do_with_ref_self_and_world(ref self: ContractState, ref world: IWorldDispatcher) -> felt252; + ^********************************************************************************************^ + +error: `starknet::interface` functions don't support `ref` parameters other than the first one. + --> /tmp/plugin_test/system/src/lib.cairo:112:5 + fn do_with_ref_self_and_world(ref self: ContractState, ref world: IWorldDispatcher) -> felt252; + ^********************************************************************************************^ + +error: `starknet::interface` functions don't support `ref` parameters other than the first one. + --> /tmp/plugin_test/system/src/lib.cairo:114:5 + fn do_with_ref_self_and_world_inv( + ^********************************^ + +error: `starknet::interface` functions don't support `ref` parameters other than the first one. + --> /tmp/plugin_test/system/src/lib.cairo:117:5 + fn do_with_several_world_dispatchers( + ^***********************************^ + +error: `starknet::interface` functions don't support `ref` parameters other than the first one. + --> /tmp/plugin_test/system/src/lib.cairo:121:5 + fn do_with_world_not_first(vec: Vec2, ref world: IWorldDispatcher) -> felt252; + ^***************************************************************************^ + +error: Generated trait must have generic args matching the impl's generic params. + --> /tmp/plugin_test/system/src/lib.cairo:163:5 + #[generate_trait] + ^***************^ + +//! > expanded_cairo_code + +#[starknet::component] +mod testcomponent1 { +#[event] +#[derive(Drop, starknet::Event)] +pub enum Event {} + + +#[phantom] +pub struct Storage { +} + +#[derive(Drop, Copy)] +pub struct StorageStorageBase { +} +impl StorageStorageImpl of starknet::storage::StorageTrait { + type BaseType = StorageStorageBase; + fn storage(self: starknet::storage::FlattenedStorage) -> StorageStorageBase { + StorageStorageBase { + } + } +} +#[derive(Drop, Copy)] +pub struct StorageStorageBaseMut { +} +impl StorageStorageMutImpl of starknet::storage::StorageTraitMut { + type BaseType = StorageStorageBaseMut; + fn storage_mut(self: starknet::storage::FlattenedStorage>) -> StorageStorageBaseMut { + StorageStorageBaseMut { + } + } +} + +pub struct ComponentState { +} + +impl ComponentStateDrop of Drop> {} + +impl ComponentStateDeref of core::ops::SnapshotDeref> { + type Target = starknet::storage::FlattenedStorage; + fn snapshot_deref(self: @ComponentState) -> starknet::storage::FlattenedStorage { + starknet::storage::FlattenedStorage {} + } +} +impl ComponentStateDerefMut of core::ops::DerefMut> { + type Target = starknet::storage::FlattenedStorage> ; + fn deref_mut(ref self: ComponentState) -> starknet::storage::FlattenedStorage> { + starknet::storage::FlattenedStorage {} + } +} +pub fn unsafe_new_component_state() -> ComponentState { + ComponentState:: { + } +} + + +// TODO(Gil): This generates duplicate diagnostics because of the plugin system, squash the duplicates into one. +#[deprecated( + feature: "deprecated_legacy_map", + note: "Use `starknet::storage::Map` instead." +)] +use starknet::storage::Map as LegacyMap; +pub trait HasComponent { + fn get_component(self: @TContractState) -> @ComponentState; + fn get_component_mut(ref self: TContractState) -> ComponentState; + fn get_contract(self: @ComponentState) -> @TContractState; + fn get_contract_mut(ref self: ComponentState) -> TContractState; + fn emit>(ref self: ComponentState, event: S); +} +impl EventDrop of core::traits::Drop::; +impl EventIsEvent of starknet::Event { + fn append_keys_and_data( + self: @Event, ref keys: Array, ref data: Array + ) { + match self { + } + } + fn deserialize( + ref keys: Span, ref data: Span, + ) -> Option { + let __selector__ = *core::array::SpanTrait::pop_front(ref keys)?; + Option::None + } +} +impl StorageStorageBaseDrop of core::traits::Drop::; +impl StorageStorageBaseCopy of core::traits::Copy::; +impl StorageStorageBaseMutDrop of core::traits::Drop::; +impl StorageStorageBaseMutCopy of core::traits::Copy::; +} + +#[starknet::component] +mod testcomponent2 { +#[event] +#[derive(Drop, starknet::Event)] +pub enum Event {} + + +#[phantom] +pub struct Storage { +} + +#[derive(Drop, Copy)] +pub struct StorageStorageBase { +} +impl StorageStorageImpl of starknet::storage::StorageTrait { + type BaseType = StorageStorageBase; + fn storage(self: starknet::storage::FlattenedStorage) -> StorageStorageBase { + StorageStorageBase { + } + } +} +#[derive(Drop, Copy)] +pub struct StorageStorageBaseMut { +} +impl StorageStorageMutImpl of starknet::storage::StorageTraitMut { + type BaseType = StorageStorageBaseMut; + fn storage_mut(self: starknet::storage::FlattenedStorage>) -> StorageStorageBaseMut { + StorageStorageBaseMut { + } + } +} + +pub struct ComponentState { +} + +impl ComponentStateDrop of Drop> {} + +impl ComponentStateDeref of core::ops::SnapshotDeref> { + type Target = starknet::storage::FlattenedStorage; + fn snapshot_deref(self: @ComponentState) -> starknet::storage::FlattenedStorage { + starknet::storage::FlattenedStorage {} + } +} +impl ComponentStateDerefMut of core::ops::DerefMut> { + type Target = starknet::storage::FlattenedStorage> ; + fn deref_mut(ref self: ComponentState) -> starknet::storage::FlattenedStorage> { + starknet::storage::FlattenedStorage {} + } +} +pub fn unsafe_new_component_state() -> ComponentState { + ComponentState:: { + } +} + + +// TODO(Gil): This generates duplicate diagnostics because of the plugin system, squash the duplicates into one. +#[deprecated( + feature: "deprecated_legacy_map", + note: "Use `starknet::storage::Map` instead." +)] +use starknet::storage::Map as LegacyMap; +pub trait HasComponent { + fn get_component(self: @TContractState) -> @ComponentState; + fn get_component_mut(ref self: TContractState) -> ComponentState; + fn get_contract(self: @ComponentState) -> @TContractState; + fn get_contract_mut(ref self: ComponentState) -> TContractState; + fn emit>(ref self: ComponentState, event: S); +} +impl EventDrop of core::traits::Drop::; +impl EventIsEvent of starknet::Event { + fn append_keys_and_data( + self: @Event, ref keys: Array, ref data: Array + ) { + match self { + } + } + fn deserialize( + ref keys: Span, ref data: Span, + ) -> Option { + let __selector__ = *core::array::SpanTrait::pop_front(ref keys)?; + Option::None + } +} +impl StorageStorageBaseDrop of core::traits::Drop::; +impl StorageStorageBaseCopy of core::traits::Copy::; +impl StorageStorageBaseMutDrop of core::traits::Drop::; +impl StorageStorageBaseMutCopy of core::traits::Copy::; +} + + #[starknet::contract] + pub mod bad_namespace_format { + use dojo::world; + use dojo::world::IWorldDispatcher; + use dojo::world::IWorldDispatcherTrait; + use dojo::world::IWorldProvider; + use dojo::contract::IContract; + use starknet::storage::{ + StorageMapReadAccess, StorageMapWriteAccess, StoragePointerReadAccess, StoragePointerWriteAccess + }; + + #[abi(embed_v0)] + pub impl ContractImpl of IContract { + fn name(self: @ContractState) -> ByteArray { + "bad_namespace_format" + } + + fn namespace(self: @ContractState) -> ByteArray { + "dojo_test" + } + + fn tag(self: @ContractState) -> ByteArray { + "dojo_test-bad_namespace_format" + } + + fn name_hash(self: @ContractState) -> felt252 { + 2014299465256018364248618312205774234949844604916563661777686628154176783488 + } + + fn namespace_hash(self: @ContractState) -> felt252 { + 1452123528942907587532668415362544424816022573043154497385993678618948064048 + } + + fn selector(self: @ContractState) -> felt252 { + 1674441257224597091124008266787844860104091058063661385750024717220711878589 + } + } + + #[abi(embed_v0)] + impl WorldProviderImpl of IWorldProvider { + fn world(self: @ContractState) -> IWorldDispatcher { + self.world_dispatcher.read() + } + } + + #[abi(embed_v0)] + impl UpgradableImpl = dojo::contract::upgradeable::upgradeable::UpgradableImpl; + + use traits::Into; + use dojo::world::Context; + + fn execute(ctx: Context, name: felt252) { + return (); + } + + #[starknet::interface] + pub trait IDojoInit { + fn dojo_init(self: @ContractState); + } + + #[abi(embed_v0)] + pub impl IDojoInitImpl of IDojoInit { + fn dojo_init(self: @ContractState) { + if starknet::get_caller_address() != self.world().contract_address { + core::panics::panic_with_byte_array( + @format!("Only the world can init contract `{}`, but caller is `{:?}`", + self.tag(), + starknet::get_caller_address(), + )); + } + } + } + + #[event] + #[derive(Drop, starknet::Event)] + enum Event { + UpgradeableEvent: dojo::contract::upgradeable::upgradeable::Event, + } + pub trait IDojoInitDispatcherTrait { + fn dojo_init(self: T); +} + +#[derive(Copy, Drop, starknet::Store, Serde)] + pub struct IDojoInitDispatcher { + pub contract_address: starknet::ContractAddress, +} + +impl IDojoInitDispatcherImpl of IDojoInitDispatcherTrait { + fn dojo_init(self: IDojoInitDispatcher) { + let mut __calldata__ = core::traits::Default::default(); + + let mut __dispatcher_return_data__ = starknet::syscalls::call_contract_syscall( + self.contract_address, + selector!("dojo_init"), + core::array::ArrayTrait::span(@__calldata__), + ); + let mut __dispatcher_return_data__ = starknet::SyscallResultTrait::unwrap_syscall(__dispatcher_return_data__); + () + } + +} + +#[derive(Copy, Drop, starknet::Store, Serde)] + pub struct IDojoInitLibraryDispatcher { + pub class_hash: starknet::ClassHash, +} + +impl IDojoInitLibraryDispatcherImpl of IDojoInitDispatcherTrait { + fn dojo_init(self: IDojoInitLibraryDispatcher) { + let mut __calldata__ = core::traits::Default::default(); + + let mut __dispatcher_return_data__ = starknet::syscalls::library_call_syscall( + self.class_hash, + selector!("dojo_init"), + core::array::ArrayTrait::span(@__calldata__), + ); + let mut __dispatcher_return_data__ = starknet::SyscallResultTrait::unwrap_syscall(__dispatcher_return_data__); + () + } + +} + + pub trait IDojoInitSafeDispatcherTrait { + #[unstable(feature: "safe_dispatcher")] + fn dojo_init(self: T) -> starknet::SyscallResult<()>; +} + +#[derive(Copy, Drop, starknet::Store, Serde)] + pub struct IDojoInitSafeLibraryDispatcher { + pub class_hash: starknet::ClassHash, +} + +impl IDojoInitSafeLibraryDispatcherImpl of IDojoInitSafeDispatcherTrait { + fn dojo_init(self: IDojoInitSafeLibraryDispatcher) -> starknet::SyscallResult<()> { + let mut __calldata__ = core::traits::Default::default(); + + let mut __dispatcher_return_data__ = starknet::syscalls::library_call_syscall( + self.class_hash, + selector!("dojo_init"), + core::array::ArrayTrait::span(@__calldata__), + ); + let mut __dispatcher_return_data__ = __dispatcher_return_data__?; + Result::Ok(()) + } + +} + + +#[derive(Copy, Drop, starknet::Store, Serde)] + pub struct IDojoInitSafeDispatcher { + pub contract_address: starknet::ContractAddress, +} + +impl IDojoInitSafeDispatcherImpl of IDojoInitSafeDispatcherTrait { + fn dojo_init(self: IDojoInitSafeDispatcher) -> starknet::SyscallResult<()> { + let mut __calldata__ = core::traits::Default::default(); + + let mut __dispatcher_return_data__ = starknet::syscalls::call_contract_syscall( + self.contract_address, + selector!("dojo_init"), + core::array::ArrayTrait::span(@__calldata__), + ); + let mut __dispatcher_return_data__ = __dispatcher_return_data__?; + Result::Ok(()) + } + +} +impl EventDrop of core::traits::Drop::; +impl EventIsEvent of starknet::Event { + fn append_keys_and_data( + self: @Event, ref keys: Array, ref data: Array + ) { + match self { + Event::UpgradeableEvent(val) => { + core::array::ArrayTrait::append(ref keys, selector!("UpgradeableEvent")); + starknet::Event::append_keys_and_data( + val, ref keys, ref data + ); + }, + } + } + fn deserialize( + ref keys: Span, ref data: Span, + ) -> Option { + let __selector__ = *core::array::SpanTrait::pop_front(ref keys)?; + if __selector__ == selector!("UpgradeableEvent") { + let val = starknet::Event::deserialize( + ref keys, ref data + )?; + return Option::Some(Event::UpgradeableEvent(val)); + } + Option::None + } +} +impl EventUpgradeableEventIntoEvent of Into { + fn into(self: dojo::contract::upgradeable::upgradeable::Event) -> Event { + Event::UpgradeableEvent(self) + } +} + + +#[phantom] +pub struct Storage { + pub world_dispatcher: IWorldDispatcher, + #[substorage(v0)] + pub upgradeable: dojo::contract::upgradeable::upgradeable::Storage, +} + +#[derive(Drop, Copy)] +pub struct StorageStorageBase { + pub world_dispatcher: starknet::storage::StorageBase, + pub upgradeable: starknet::storage::FlattenedStorage, +} +impl StorageStorageImpl of starknet::storage::StorageTrait { + type BaseType = StorageStorageBase; + fn storage(self: starknet::storage::FlattenedStorage) -> StorageStorageBase { + let world_dispatcher_value = starknet::storage::StorageBase {__base_address__: selector!("world_dispatcher")}; + let upgradeable_value = starknet::storage::FlattenedStorage {}; + StorageStorageBase { + world_dispatcher: world_dispatcher_value, + upgradeable: upgradeable_value, + } + } +} +#[derive(Drop, Copy)] +pub struct StorageStorageBaseMut { + pub world_dispatcher: starknet::storage::StorageBase>, + pub upgradeable: starknet::storage::FlattenedStorage>, +} +impl StorageStorageMutImpl of starknet::storage::StorageTraitMut { + type BaseType = StorageStorageBaseMut; + fn storage_mut(self: starknet::storage::FlattenedStorage>) -> StorageStorageBaseMut { + let world_dispatcher_value = starknet::storage::StorageBase {__base_address__: selector!("world_dispatcher")}; + let upgradeable_value = starknet::storage::FlattenedStorage {}; + StorageStorageBaseMut { + world_dispatcher: world_dispatcher_value, + upgradeable: upgradeable_value, + } + } +} + +pub struct ContractState { + pub upgradeable: dojo::contract::upgradeable::upgradeable::ComponentState, +} + +impl ContractStateDrop of Drop {} + +impl ContractStateDeref of core::ops::SnapshotDeref { + type Target = starknet::storage::FlattenedStorage; + fn snapshot_deref(self: @ContractState) -> starknet::storage::FlattenedStorage { + starknet::storage::FlattenedStorage {} + } +} +impl ContractStateDerefMut of core::ops::DerefMut { + type Target = starknet::storage::FlattenedStorage> ; + fn deref_mut(ref self: ContractState) -> starknet::storage::FlattenedStorage> { + starknet::storage::FlattenedStorage {} + } +} +pub fn unsafe_new_contract_state() -> ContractState { + ContractState { + upgradeable: dojo::contract::upgradeable::upgradeable::unsafe_new_component_state::(), + } +} + +// TODO(Gil): This generates duplicate diagnostics because of the plugin system, squash the duplicates into one. +#[deprecated( + feature: "deprecated_legacy_map", + note: "Use `starknet::storage::Map` instead." +)] +use starknet::storage::Map as LegacyMap; + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__ContractImpl__name(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = ContractImpl::name(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__ContractImpl__namespace(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = ContractImpl::namespace(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__ContractImpl__tag(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = ContractImpl::tag(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__ContractImpl__name_hash(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = ContractImpl::name_hash(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__ContractImpl__namespace_hash(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = ContractImpl::namespace_hash(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__ContractImpl__selector(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = ContractImpl::selector(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__WorldProviderImpl__world(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = WorldProviderImpl::world(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +impl ContractStateUpgradableImpl of + dojo::contract::upgradeable::upgradeable::UnsafeNewContractStateTraitForUpgradableImpl { + fn unsafe_new_contract_state() -> ContractState { + unsafe_new_contract_state() + } +} +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__IDojoInitImpl__dojo_init(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + IDojoInitImpl::dojo_init(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::array::ArrayTrait::span(@arr) +} + + +pub mod __external { + pub use super::__wrapper__ContractImpl__name as name; + pub use super::__wrapper__ContractImpl__namespace as namespace; + pub use super::__wrapper__ContractImpl__tag as tag; + pub use super::__wrapper__ContractImpl__name_hash as name_hash; + pub use super::__wrapper__ContractImpl__namespace_hash as namespace_hash; + pub use super::__wrapper__ContractImpl__selector as selector; + pub use super::__wrapper__WorldProviderImpl__world as world; + pub use super::__wrapper__IDojoInitImpl__dojo_init as dojo_init; +} +pub mod __l1_handler { +} +pub mod __constructor { +} + impl ContractStateEventEmitter of starknet::event::EventEmitter< + ContractState, Event + > { + fn emit>( + ref self: ContractState, event: S + ) { + let event: Event = core::traits::Into::into(event); + let mut keys = Default::::default(); + let mut data = Default::::default(); + starknet::Event::append_keys_and_data(@event, ref keys, ref data); + starknet::SyscallResultTrait::unwrap_syscall( + starknet::syscalls::emit_event_syscall( + core::array::ArrayTrait::span(@keys), + core::array::ArrayTrait::span(@data), + ) + ) + } + } + +impl HasComponentImpl_upgradeable of dojo::contract::upgradeable::upgradeable::HasComponent { + fn get_component(self: @ContractState) -> @dojo::contract::upgradeable::upgradeable::ComponentState { + @dojo::contract::upgradeable::upgradeable::unsafe_new_component_state::() + } + fn get_component_mut(ref self: ContractState) -> dojo::contract::upgradeable::upgradeable::ComponentState { + dojo::contract::upgradeable::upgradeable::unsafe_new_component_state::() + } + fn get_contract(self: @dojo::contract::upgradeable::upgradeable::ComponentState) -> @ContractState { + @unsafe_new_contract_state() + } + fn get_contract_mut(ref self: dojo::contract::upgradeable::upgradeable::ComponentState) -> ContractState { + unsafe_new_contract_state() + } + fn emit>(ref self: dojo::contract::upgradeable::upgradeable::ComponentState, event: S) { + let event: dojo::contract::upgradeable::upgradeable::Event = core::traits::Into::into(event); + let mut contract = dojo::contract::upgradeable::upgradeable::HasComponent::get_contract_mut(ref self); + ContractStateEventEmitter::emit(ref contract, Event::UpgradeableEvent(event)); + } +} +impl IDojoInitDispatcherCopy of core::traits::Copy::; +impl IDojoInitDispatcherDrop of core::traits::Drop::; +impl IDojoInitDispatcherSerde of core::serde::Serde:: { + fn serialize(self: @IDojoInitDispatcher, ref output: core::array::Array) { + core::serde::Serde::serialize(self.contract_address, ref output) + } + fn deserialize(ref serialized: core::array::Span) -> core::option::Option { + core::option::Option::Some(IDojoInitDispatcher { + contract_address: core::serde::Serde::deserialize(ref serialized)?, + }) + } +} +impl StoreIDojoInitDispatcher of starknet::Store:: { + fn read(address_domain: u32, base: starknet::storage_access::StorageBaseAddress) -> starknet::SyscallResult { + let contract_address = starknet::Store::::read(address_domain, base)?; + starknet::SyscallResult::Ok( + IDojoInitDispatcher { + contract_address, + } + ) + } + fn write(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, value: IDojoInitDispatcher) -> starknet::SyscallResult<()> { + starknet::Store::::write(address_domain, base, value.contract_address)?; + starknet::SyscallResult::Ok(()) + } + fn read_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8) -> starknet::SyscallResult { + let contract_address = starknet::Store::::read_at_offset(address_domain, base, offset)?; + starknet::SyscallResult::Ok( + IDojoInitDispatcher { + contract_address, + } + ) + } + #[inline(always)] + fn write_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8, value: IDojoInitDispatcher) -> starknet::SyscallResult<()> { + starknet::Store::::write_at_offset(address_domain, base, offset, value.contract_address)?; + starknet::SyscallResult::Ok(()) + } + #[inline(always)] + fn size() -> u8 { + starknet::Store::::size() + } +} + +#[derive(Drop, Copy)] +pub struct IDojoInitDispatcherSubPointers { + pub contract_address: starknet::storage::StoragePointer, +} +impl IDojoInitDispatcherSubPointersImpl of starknet::storage::SubPointers { + type SubPointersType = IDojoInitDispatcherSubPointers; + fn sub_pointers(self: starknet::storage::StoragePointer) -> IDojoInitDispatcherSubPointers { + let base_address = self.__storage_pointer_address__; + let mut current_offset = self.__storage_pointer_offset__; + let contract_address_value = starknet::storage::StoragePointer { + __storage_pointer_address__: base_address, + __storage_pointer_offset__: current_offset, + }; + IDojoInitDispatcherSubPointers { + contract_address: contract_address_value, + } + } +} +#[derive(Drop, Copy)] +pub struct IDojoInitDispatcherSubPointersMut { + pub contract_address: starknet::storage::StoragePointer>, +} +impl IDojoInitDispatcherSubPointersMutImpl of starknet::storage::SubPointersMut { + type SubPointersType = IDojoInitDispatcherSubPointersMut; + fn sub_pointers_mut(self: starknet::storage::StoragePointer>) -> IDojoInitDispatcherSubPointersMut { + let base_address = self.__storage_pointer_address__; + let mut current_offset = self.__storage_pointer_offset__; + let contract_address_value = starknet::storage::StoragePointer { + __storage_pointer_address__: base_address, + __storage_pointer_offset__: current_offset, + }; + IDojoInitDispatcherSubPointersMut { + contract_address: contract_address_value, + } + } +} +impl IDojoInitLibraryDispatcherCopy of core::traits::Copy::; +impl IDojoInitLibraryDispatcherDrop of core::traits::Drop::; +impl IDojoInitLibraryDispatcherSerde of core::serde::Serde:: { + fn serialize(self: @IDojoInitLibraryDispatcher, ref output: core::array::Array) { + core::serde::Serde::serialize(self.class_hash, ref output) + } + fn deserialize(ref serialized: core::array::Span) -> core::option::Option { + core::option::Option::Some(IDojoInitLibraryDispatcher { + class_hash: core::serde::Serde::deserialize(ref serialized)?, + }) + } +} +impl StoreIDojoInitLibraryDispatcher of starknet::Store:: { + fn read(address_domain: u32, base: starknet::storage_access::StorageBaseAddress) -> starknet::SyscallResult { + let class_hash = starknet::Store::::read(address_domain, base)?; + starknet::SyscallResult::Ok( + IDojoInitLibraryDispatcher { + class_hash, + } + ) + } + fn write(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, value: IDojoInitLibraryDispatcher) -> starknet::SyscallResult<()> { + starknet::Store::::write(address_domain, base, value.class_hash)?; + starknet::SyscallResult::Ok(()) + } + fn read_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8) -> starknet::SyscallResult { + let class_hash = starknet::Store::::read_at_offset(address_domain, base, offset)?; + starknet::SyscallResult::Ok( + IDojoInitLibraryDispatcher { + class_hash, + } + ) + } + #[inline(always)] + fn write_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8, value: IDojoInitLibraryDispatcher) -> starknet::SyscallResult<()> { + starknet::Store::::write_at_offset(address_domain, base, offset, value.class_hash)?; + starknet::SyscallResult::Ok(()) + } + #[inline(always)] + fn size() -> u8 { + starknet::Store::::size() + } +} + +#[derive(Drop, Copy)] +pub struct IDojoInitLibraryDispatcherSubPointers { + pub class_hash: starknet::storage::StoragePointer, +} +impl IDojoInitLibraryDispatcherSubPointersImpl of starknet::storage::SubPointers { + type SubPointersType = IDojoInitLibraryDispatcherSubPointers; + fn sub_pointers(self: starknet::storage::StoragePointer) -> IDojoInitLibraryDispatcherSubPointers { + let base_address = self.__storage_pointer_address__; + let mut current_offset = self.__storage_pointer_offset__; + let class_hash_value = starknet::storage::StoragePointer { + __storage_pointer_address__: base_address, + __storage_pointer_offset__: current_offset, + }; + IDojoInitLibraryDispatcherSubPointers { + class_hash: class_hash_value, + } + } +} +#[derive(Drop, Copy)] +pub struct IDojoInitLibraryDispatcherSubPointersMut { + pub class_hash: starknet::storage::StoragePointer>, +} +impl IDojoInitLibraryDispatcherSubPointersMutImpl of starknet::storage::SubPointersMut { + type SubPointersType = IDojoInitLibraryDispatcherSubPointersMut; + fn sub_pointers_mut(self: starknet::storage::StoragePointer>) -> IDojoInitLibraryDispatcherSubPointersMut { + let base_address = self.__storage_pointer_address__; + let mut current_offset = self.__storage_pointer_offset__; + let class_hash_value = starknet::storage::StoragePointer { + __storage_pointer_address__: base_address, + __storage_pointer_offset__: current_offset, + }; + IDojoInitLibraryDispatcherSubPointersMut { + class_hash: class_hash_value, + } + } +} +impl IDojoInitSafeLibraryDispatcherCopy of core::traits::Copy::; +impl IDojoInitSafeLibraryDispatcherDrop of core::traits::Drop::; +impl IDojoInitSafeLibraryDispatcherSerde of core::serde::Serde:: { + fn serialize(self: @IDojoInitSafeLibraryDispatcher, ref output: core::array::Array) { + core::serde::Serde::serialize(self.class_hash, ref output) + } + fn deserialize(ref serialized: core::array::Span) -> core::option::Option { + core::option::Option::Some(IDojoInitSafeLibraryDispatcher { + class_hash: core::serde::Serde::deserialize(ref serialized)?, + }) + } +} +impl StoreIDojoInitSafeLibraryDispatcher of starknet::Store:: { + fn read(address_domain: u32, base: starknet::storage_access::StorageBaseAddress) -> starknet::SyscallResult { + let class_hash = starknet::Store::::read(address_domain, base)?; + starknet::SyscallResult::Ok( + IDojoInitSafeLibraryDispatcher { + class_hash, + } + ) + } + fn write(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, value: IDojoInitSafeLibraryDispatcher) -> starknet::SyscallResult<()> { + starknet::Store::::write(address_domain, base, value.class_hash)?; + starknet::SyscallResult::Ok(()) + } + fn read_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8) -> starknet::SyscallResult { + let class_hash = starknet::Store::::read_at_offset(address_domain, base, offset)?; + starknet::SyscallResult::Ok( + IDojoInitSafeLibraryDispatcher { + class_hash, + } + ) + } + #[inline(always)] + fn write_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8, value: IDojoInitSafeLibraryDispatcher) -> starknet::SyscallResult<()> { + starknet::Store::::write_at_offset(address_domain, base, offset, value.class_hash)?; + starknet::SyscallResult::Ok(()) + } + #[inline(always)] + fn size() -> u8 { + starknet::Store::::size() + } +} + +#[derive(Drop, Copy)] +pub struct IDojoInitSafeLibraryDispatcherSubPointers { + pub class_hash: starknet::storage::StoragePointer, +} +impl IDojoInitSafeLibraryDispatcherSubPointersImpl of starknet::storage::SubPointers { + type SubPointersType = IDojoInitSafeLibraryDispatcherSubPointers; + fn sub_pointers(self: starknet::storage::StoragePointer) -> IDojoInitSafeLibraryDispatcherSubPointers { + let base_address = self.__storage_pointer_address__; + let mut current_offset = self.__storage_pointer_offset__; + let class_hash_value = starknet::storage::StoragePointer { + __storage_pointer_address__: base_address, + __storage_pointer_offset__: current_offset, + }; + IDojoInitSafeLibraryDispatcherSubPointers { + class_hash: class_hash_value, + } + } +} +#[derive(Drop, Copy)] +pub struct IDojoInitSafeLibraryDispatcherSubPointersMut { + pub class_hash: starknet::storage::StoragePointer>, +} +impl IDojoInitSafeLibraryDispatcherSubPointersMutImpl of starknet::storage::SubPointersMut { + type SubPointersType = IDojoInitSafeLibraryDispatcherSubPointersMut; + fn sub_pointers_mut(self: starknet::storage::StoragePointer>) -> IDojoInitSafeLibraryDispatcherSubPointersMut { + let base_address = self.__storage_pointer_address__; + let mut current_offset = self.__storage_pointer_offset__; + let class_hash_value = starknet::storage::StoragePointer { + __storage_pointer_address__: base_address, + __storage_pointer_offset__: current_offset, + }; + IDojoInitSafeLibraryDispatcherSubPointersMut { + class_hash: class_hash_value, + } + } +} +impl IDojoInitSafeDispatcherCopy of core::traits::Copy::; +impl IDojoInitSafeDispatcherDrop of core::traits::Drop::; +impl IDojoInitSafeDispatcherSerde of core::serde::Serde:: { + fn serialize(self: @IDojoInitSafeDispatcher, ref output: core::array::Array) { + core::serde::Serde::serialize(self.contract_address, ref output) + } + fn deserialize(ref serialized: core::array::Span) -> core::option::Option { + core::option::Option::Some(IDojoInitSafeDispatcher { + contract_address: core::serde::Serde::deserialize(ref serialized)?, + }) + } +} +impl StoreIDojoInitSafeDispatcher of starknet::Store:: { + fn read(address_domain: u32, base: starknet::storage_access::StorageBaseAddress) -> starknet::SyscallResult { + let contract_address = starknet::Store::::read(address_domain, base)?; + starknet::SyscallResult::Ok( + IDojoInitSafeDispatcher { + contract_address, + } + ) + } + fn write(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, value: IDojoInitSafeDispatcher) -> starknet::SyscallResult<()> { + starknet::Store::::write(address_domain, base, value.contract_address)?; + starknet::SyscallResult::Ok(()) + } + fn read_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8) -> starknet::SyscallResult { + let contract_address = starknet::Store::::read_at_offset(address_domain, base, offset)?; + starknet::SyscallResult::Ok( + IDojoInitSafeDispatcher { + contract_address, + } + ) + } + #[inline(always)] + fn write_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8, value: IDojoInitSafeDispatcher) -> starknet::SyscallResult<()> { + starknet::Store::::write_at_offset(address_domain, base, offset, value.contract_address)?; + starknet::SyscallResult::Ok(()) + } + #[inline(always)] + fn size() -> u8 { + starknet::Store::::size() + } +} + +#[derive(Drop, Copy)] +pub struct IDojoInitSafeDispatcherSubPointers { + pub contract_address: starknet::storage::StoragePointer, +} +impl IDojoInitSafeDispatcherSubPointersImpl of starknet::storage::SubPointers { + type SubPointersType = IDojoInitSafeDispatcherSubPointers; + fn sub_pointers(self: starknet::storage::StoragePointer) -> IDojoInitSafeDispatcherSubPointers { + let base_address = self.__storage_pointer_address__; + let mut current_offset = self.__storage_pointer_offset__; + let contract_address_value = starknet::storage::StoragePointer { + __storage_pointer_address__: base_address, + __storage_pointer_offset__: current_offset, + }; + IDojoInitSafeDispatcherSubPointers { + contract_address: contract_address_value, + } + } +} +#[derive(Drop, Copy)] +pub struct IDojoInitSafeDispatcherSubPointersMut { + pub contract_address: starknet::storage::StoragePointer>, +} +impl IDojoInitSafeDispatcherSubPointersMutImpl of starknet::storage::SubPointersMut { + type SubPointersType = IDojoInitSafeDispatcherSubPointersMut; + fn sub_pointers_mut(self: starknet::storage::StoragePointer>) -> IDojoInitSafeDispatcherSubPointersMut { + let base_address = self.__storage_pointer_address__; + let mut current_offset = self.__storage_pointer_offset__; + let contract_address_value = starknet::storage::StoragePointer { + __storage_pointer_address__: base_address, + __storage_pointer_offset__: current_offset, + }; + IDojoInitSafeDispatcherSubPointersMut { + contract_address: contract_address_value, + } + } +} +impl StorageStorageBaseDrop of core::traits::Drop::; +impl StorageStorageBaseCopy of core::traits::Copy::; +impl StorageStorageBaseMutDrop of core::traits::Drop::; +impl StorageStorageBaseMutCopy of core::traits::Copy::; +impl IDojoInitDispatcherSubPointersDrop of core::traits::Drop::; +impl IDojoInitDispatcherSubPointersCopy of core::traits::Copy::; +impl IDojoInitDispatcherSubPointersMutDrop of core::traits::Drop::; +impl IDojoInitDispatcherSubPointersMutCopy of core::traits::Copy::; +impl IDojoInitLibraryDispatcherSubPointersDrop of core::traits::Drop::; +impl IDojoInitLibraryDispatcherSubPointersCopy of core::traits::Copy::; +impl IDojoInitLibraryDispatcherSubPointersMutDrop of core::traits::Drop::; +impl IDojoInitLibraryDispatcherSubPointersMutCopy of core::traits::Copy::; +impl IDojoInitSafeLibraryDispatcherSubPointersDrop of core::traits::Drop::; +impl IDojoInitSafeLibraryDispatcherSubPointersCopy of core::traits::Copy::; +impl IDojoInitSafeLibraryDispatcherSubPointersMutDrop of core::traits::Drop::; +impl IDojoInitSafeLibraryDispatcherSubPointersMutCopy of core::traits::Copy::; +impl IDojoInitSafeDispatcherSubPointersDrop of core::traits::Drop::; +impl IDojoInitSafeDispatcherSubPointersCopy of core::traits::Copy::; +impl IDojoInitSafeDispatcherSubPointersMutDrop of core::traits::Drop::; +impl IDojoInitSafeDispatcherSubPointersMutCopy of core::traits::Copy::; + + } + + #[starknet::contract] + pub mod spawn { + use dojo::world; + use dojo::world::IWorldDispatcher; + use dojo::world::IWorldDispatcherTrait; + use dojo::world::IWorldProvider; + use dojo::contract::IContract; + use starknet::storage::{ + StorageMapReadAccess, StorageMapWriteAccess, StoragePointerReadAccess, StoragePointerWriteAccess + }; + + #[abi(embed_v0)] + pub impl ContractImpl of IContract { + fn name(self: @ContractState) -> ByteArray { + "spawn" + } + + fn namespace(self: @ContractState) -> ByteArray { + "dojo_test" + } + + fn tag(self: @ContractState) -> ByteArray { + "dojo_test-spawn" + } + + fn name_hash(self: @ContractState) -> felt252 { + 2776321589048333240377325502911505147617911439383944762363370901236132332849 + } + + fn namespace_hash(self: @ContractState) -> felt252 { + 1452123528942907587532668415362544424816022573043154497385993678618948064048 + } + + fn selector(self: @ContractState) -> felt252 { + 68455752117050128185302950891816466897876546944174376812212671562113328733 + } + } + + #[abi(embed_v0)] + impl WorldProviderImpl of IWorldProvider { + fn world(self: @ContractState) -> IWorldDispatcher { + self.world_dispatcher.read() + } + } + + #[abi(embed_v0)] + impl UpgradableImpl = dojo::contract::upgradeable::upgradeable::UpgradableImpl; + + use traits::Into; + use dojo::world::Context; + + fn execute(ctx: Context, name: felt252) { + return (); + } + + #[starknet::interface] + pub trait IDojoInit { + fn dojo_init(self: @ContractState); + } + + #[abi(embed_v0)] + pub impl IDojoInitImpl of IDojoInit { + fn dojo_init(self: @ContractState) { + if starknet::get_caller_address() != self.world().contract_address { + core::panics::panic_with_byte_array( + @format!("Only the world can init contract `{}`, but caller is `{:?}`", + self.tag(), + starknet::get_caller_address(), + )); + } + } + } + + #[event] + #[derive(Drop, starknet::Event)] + enum Event { + UpgradeableEvent: dojo::contract::upgradeable::upgradeable::Event, + } + pub trait IDojoInitDispatcherTrait { + fn dojo_init(self: T); +} + +#[derive(Copy, Drop, starknet::Store, Serde)] + pub struct IDojoInitDispatcher { + pub contract_address: starknet::ContractAddress, +} + +impl IDojoInitDispatcherImpl of IDojoInitDispatcherTrait { + fn dojo_init(self: IDojoInitDispatcher) { + let mut __calldata__ = core::traits::Default::default(); + + let mut __dispatcher_return_data__ = starknet::syscalls::call_contract_syscall( + self.contract_address, + selector!("dojo_init"), + core::array::ArrayTrait::span(@__calldata__), + ); + let mut __dispatcher_return_data__ = starknet::SyscallResultTrait::unwrap_syscall(__dispatcher_return_data__); + () + } + +} + +#[derive(Copy, Drop, starknet::Store, Serde)] + pub struct IDojoInitLibraryDispatcher { + pub class_hash: starknet::ClassHash, +} + +impl IDojoInitLibraryDispatcherImpl of IDojoInitDispatcherTrait { + fn dojo_init(self: IDojoInitLibraryDispatcher) { + let mut __calldata__ = core::traits::Default::default(); + + let mut __dispatcher_return_data__ = starknet::syscalls::library_call_syscall( + self.class_hash, + selector!("dojo_init"), + core::array::ArrayTrait::span(@__calldata__), + ); + let mut __dispatcher_return_data__ = starknet::SyscallResultTrait::unwrap_syscall(__dispatcher_return_data__); + () + } + +} + + pub trait IDojoInitSafeDispatcherTrait { + #[unstable(feature: "safe_dispatcher")] + fn dojo_init(self: T) -> starknet::SyscallResult<()>; +} + +#[derive(Copy, Drop, starknet::Store, Serde)] + pub struct IDojoInitSafeLibraryDispatcher { + pub class_hash: starknet::ClassHash, +} + +impl IDojoInitSafeLibraryDispatcherImpl of IDojoInitSafeDispatcherTrait { + fn dojo_init(self: IDojoInitSafeLibraryDispatcher) -> starknet::SyscallResult<()> { + let mut __calldata__ = core::traits::Default::default(); + + let mut __dispatcher_return_data__ = starknet::syscalls::library_call_syscall( + self.class_hash, + selector!("dojo_init"), + core::array::ArrayTrait::span(@__calldata__), + ); + let mut __dispatcher_return_data__ = __dispatcher_return_data__?; + Result::Ok(()) + } + +} + + +#[derive(Copy, Drop, starknet::Store, Serde)] + pub struct IDojoInitSafeDispatcher { + pub contract_address: starknet::ContractAddress, +} + +impl IDojoInitSafeDispatcherImpl of IDojoInitSafeDispatcherTrait { + fn dojo_init(self: IDojoInitSafeDispatcher) -> starknet::SyscallResult<()> { + let mut __calldata__ = core::traits::Default::default(); + + let mut __dispatcher_return_data__ = starknet::syscalls::call_contract_syscall( + self.contract_address, + selector!("dojo_init"), + core::array::ArrayTrait::span(@__calldata__), + ); + let mut __dispatcher_return_data__ = __dispatcher_return_data__?; + Result::Ok(()) + } + +} +impl EventDrop of core::traits::Drop::; +impl EventIsEvent of starknet::Event { + fn append_keys_and_data( + self: @Event, ref keys: Array, ref data: Array + ) { + match self { + Event::UpgradeableEvent(val) => { + core::array::ArrayTrait::append(ref keys, selector!("UpgradeableEvent")); + starknet::Event::append_keys_and_data( + val, ref keys, ref data + ); + }, + } + } + fn deserialize( + ref keys: Span, ref data: Span, + ) -> Option { + let __selector__ = *core::array::SpanTrait::pop_front(ref keys)?; + if __selector__ == selector!("UpgradeableEvent") { + let val = starknet::Event::deserialize( + ref keys, ref data + )?; + return Option::Some(Event::UpgradeableEvent(val)); + } + Option::None + } +} +impl EventUpgradeableEventIntoEvent of Into { + fn into(self: dojo::contract::upgradeable::upgradeable::Event) -> Event { + Event::UpgradeableEvent(self) + } +} + + +#[phantom] +pub struct Storage { + pub world_dispatcher: IWorldDispatcher, + #[substorage(v0)] + pub upgradeable: dojo::contract::upgradeable::upgradeable::Storage, +} + +#[derive(Drop, Copy)] +pub struct StorageStorageBase { + pub world_dispatcher: starknet::storage::StorageBase, + pub upgradeable: starknet::storage::FlattenedStorage, +} +impl StorageStorageImpl of starknet::storage::StorageTrait { + type BaseType = StorageStorageBase; + fn storage(self: starknet::storage::FlattenedStorage) -> StorageStorageBase { + let world_dispatcher_value = starknet::storage::StorageBase {__base_address__: selector!("world_dispatcher")}; + let upgradeable_value = starknet::storage::FlattenedStorage {}; + StorageStorageBase { + world_dispatcher: world_dispatcher_value, + upgradeable: upgradeable_value, + } + } +} +#[derive(Drop, Copy)] +pub struct StorageStorageBaseMut { + pub world_dispatcher: starknet::storage::StorageBase>, + pub upgradeable: starknet::storage::FlattenedStorage>, +} +impl StorageStorageMutImpl of starknet::storage::StorageTraitMut { + type BaseType = StorageStorageBaseMut; + fn storage_mut(self: starknet::storage::FlattenedStorage>) -> StorageStorageBaseMut { + let world_dispatcher_value = starknet::storage::StorageBase {__base_address__: selector!("world_dispatcher")}; + let upgradeable_value = starknet::storage::FlattenedStorage {}; + StorageStorageBaseMut { + world_dispatcher: world_dispatcher_value, + upgradeable: upgradeable_value, + } + } +} + +pub struct ContractState { + pub upgradeable: dojo::contract::upgradeable::upgradeable::ComponentState, +} + +impl ContractStateDrop of Drop {} + +impl ContractStateDeref of core::ops::SnapshotDeref { + type Target = starknet::storage::FlattenedStorage; + fn snapshot_deref(self: @ContractState) -> starknet::storage::FlattenedStorage { + starknet::storage::FlattenedStorage {} + } +} +impl ContractStateDerefMut of core::ops::DerefMut { + type Target = starknet::storage::FlattenedStorage> ; + fn deref_mut(ref self: ContractState) -> starknet::storage::FlattenedStorage> { + starknet::storage::FlattenedStorage {} + } +} +pub fn unsafe_new_contract_state() -> ContractState { + ContractState { + upgradeable: dojo::contract::upgradeable::upgradeable::unsafe_new_component_state::(), + } +} + +// TODO(Gil): This generates duplicate diagnostics because of the plugin system, squash the duplicates into one. +#[deprecated( + feature: "deprecated_legacy_map", + note: "Use `starknet::storage::Map` instead." +)] +use starknet::storage::Map as LegacyMap; + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__ContractImpl__name(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = ContractImpl::name(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__ContractImpl__namespace(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = ContractImpl::namespace(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__ContractImpl__tag(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = ContractImpl::tag(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__ContractImpl__name_hash(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = ContractImpl::name_hash(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__ContractImpl__namespace_hash(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = ContractImpl::namespace_hash(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__ContractImpl__selector(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = ContractImpl::selector(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__WorldProviderImpl__world(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = WorldProviderImpl::world(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +impl ContractStateUpgradableImpl of + dojo::contract::upgradeable::upgradeable::UnsafeNewContractStateTraitForUpgradableImpl { + fn unsafe_new_contract_state() -> ContractState { + unsafe_new_contract_state() + } +} +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__IDojoInitImpl__dojo_init(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + IDojoInitImpl::dojo_init(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::array::ArrayTrait::span(@arr) +} + + +pub mod __external { + pub use super::__wrapper__ContractImpl__name as name; + pub use super::__wrapper__ContractImpl__namespace as namespace; + pub use super::__wrapper__ContractImpl__tag as tag; + pub use super::__wrapper__ContractImpl__name_hash as name_hash; + pub use super::__wrapper__ContractImpl__namespace_hash as namespace_hash; + pub use super::__wrapper__ContractImpl__selector as selector; + pub use super::__wrapper__WorldProviderImpl__world as world; + pub use super::__wrapper__IDojoInitImpl__dojo_init as dojo_init; +} +pub mod __l1_handler { +} +pub mod __constructor { +} + impl ContractStateEventEmitter of starknet::event::EventEmitter< + ContractState, Event + > { + fn emit>( + ref self: ContractState, event: S + ) { + let event: Event = core::traits::Into::into(event); + let mut keys = Default::::default(); + let mut data = Default::::default(); + starknet::Event::append_keys_and_data(@event, ref keys, ref data); + starknet::SyscallResultTrait::unwrap_syscall( + starknet::syscalls::emit_event_syscall( + core::array::ArrayTrait::span(@keys), + core::array::ArrayTrait::span(@data), + ) + ) + } + } + +impl HasComponentImpl_upgradeable of dojo::contract::upgradeable::upgradeable::HasComponent { + fn get_component(self: @ContractState) -> @dojo::contract::upgradeable::upgradeable::ComponentState { + @dojo::contract::upgradeable::upgradeable::unsafe_new_component_state::() + } + fn get_component_mut(ref self: ContractState) -> dojo::contract::upgradeable::upgradeable::ComponentState { + dojo::contract::upgradeable::upgradeable::unsafe_new_component_state::() + } + fn get_contract(self: @dojo::contract::upgradeable::upgradeable::ComponentState) -> @ContractState { + @unsafe_new_contract_state() + } + fn get_contract_mut(ref self: dojo::contract::upgradeable::upgradeable::ComponentState) -> ContractState { + unsafe_new_contract_state() + } + fn emit>(ref self: dojo::contract::upgradeable::upgradeable::ComponentState, event: S) { + let event: dojo::contract::upgradeable::upgradeable::Event = core::traits::Into::into(event); + let mut contract = dojo::contract::upgradeable::upgradeable::HasComponent::get_contract_mut(ref self); + ContractStateEventEmitter::emit(ref contract, Event::UpgradeableEvent(event)); + } +} +impl IDojoInitDispatcherCopy of core::traits::Copy::; +impl IDojoInitDispatcherDrop of core::traits::Drop::; +impl IDojoInitDispatcherSerde of core::serde::Serde:: { + fn serialize(self: @IDojoInitDispatcher, ref output: core::array::Array) { + core::serde::Serde::serialize(self.contract_address, ref output) + } + fn deserialize(ref serialized: core::array::Span) -> core::option::Option { + core::option::Option::Some(IDojoInitDispatcher { + contract_address: core::serde::Serde::deserialize(ref serialized)?, + }) + } +} +impl StoreIDojoInitDispatcher of starknet::Store:: { + fn read(address_domain: u32, base: starknet::storage_access::StorageBaseAddress) -> starknet::SyscallResult { + let contract_address = starknet::Store::::read(address_domain, base)?; + starknet::SyscallResult::Ok( + IDojoInitDispatcher { + contract_address, + } + ) + } + fn write(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, value: IDojoInitDispatcher) -> starknet::SyscallResult<()> { + starknet::Store::::write(address_domain, base, value.contract_address)?; + starknet::SyscallResult::Ok(()) + } + fn read_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8) -> starknet::SyscallResult { + let contract_address = starknet::Store::::read_at_offset(address_domain, base, offset)?; + starknet::SyscallResult::Ok( + IDojoInitDispatcher { + contract_address, + } + ) + } + #[inline(always)] + fn write_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8, value: IDojoInitDispatcher) -> starknet::SyscallResult<()> { + starknet::Store::::write_at_offset(address_domain, base, offset, value.contract_address)?; + starknet::SyscallResult::Ok(()) + } + #[inline(always)] + fn size() -> u8 { + starknet::Store::::size() + } +} + +#[derive(Drop, Copy)] +pub struct IDojoInitDispatcherSubPointers { + pub contract_address: starknet::storage::StoragePointer, +} +impl IDojoInitDispatcherSubPointersImpl of starknet::storage::SubPointers { + type SubPointersType = IDojoInitDispatcherSubPointers; + fn sub_pointers(self: starknet::storage::StoragePointer) -> IDojoInitDispatcherSubPointers { + let base_address = self.__storage_pointer_address__; + let mut current_offset = self.__storage_pointer_offset__; + let contract_address_value = starknet::storage::StoragePointer { + __storage_pointer_address__: base_address, + __storage_pointer_offset__: current_offset, + }; + IDojoInitDispatcherSubPointers { + contract_address: contract_address_value, + } + } +} +#[derive(Drop, Copy)] +pub struct IDojoInitDispatcherSubPointersMut { + pub contract_address: starknet::storage::StoragePointer>, +} +impl IDojoInitDispatcherSubPointersMutImpl of starknet::storage::SubPointersMut { + type SubPointersType = IDojoInitDispatcherSubPointersMut; + fn sub_pointers_mut(self: starknet::storage::StoragePointer>) -> IDojoInitDispatcherSubPointersMut { + let base_address = self.__storage_pointer_address__; + let mut current_offset = self.__storage_pointer_offset__; + let contract_address_value = starknet::storage::StoragePointer { + __storage_pointer_address__: base_address, + __storage_pointer_offset__: current_offset, + }; + IDojoInitDispatcherSubPointersMut { + contract_address: contract_address_value, + } + } +} +impl IDojoInitLibraryDispatcherCopy of core::traits::Copy::; +impl IDojoInitLibraryDispatcherDrop of core::traits::Drop::; +impl IDojoInitLibraryDispatcherSerde of core::serde::Serde:: { + fn serialize(self: @IDojoInitLibraryDispatcher, ref output: core::array::Array) { + core::serde::Serde::serialize(self.class_hash, ref output) + } + fn deserialize(ref serialized: core::array::Span) -> core::option::Option { + core::option::Option::Some(IDojoInitLibraryDispatcher { + class_hash: core::serde::Serde::deserialize(ref serialized)?, + }) + } +} +impl StoreIDojoInitLibraryDispatcher of starknet::Store:: { + fn read(address_domain: u32, base: starknet::storage_access::StorageBaseAddress) -> starknet::SyscallResult { + let class_hash = starknet::Store::::read(address_domain, base)?; + starknet::SyscallResult::Ok( + IDojoInitLibraryDispatcher { + class_hash, + } + ) + } + fn write(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, value: IDojoInitLibraryDispatcher) -> starknet::SyscallResult<()> { + starknet::Store::::write(address_domain, base, value.class_hash)?; + starknet::SyscallResult::Ok(()) + } + fn read_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8) -> starknet::SyscallResult { + let class_hash = starknet::Store::::read_at_offset(address_domain, base, offset)?; + starknet::SyscallResult::Ok( + IDojoInitLibraryDispatcher { + class_hash, + } + ) + } + #[inline(always)] + fn write_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8, value: IDojoInitLibraryDispatcher) -> starknet::SyscallResult<()> { + starknet::Store::::write_at_offset(address_domain, base, offset, value.class_hash)?; + starknet::SyscallResult::Ok(()) + } + #[inline(always)] + fn size() -> u8 { + starknet::Store::::size() + } +} + +#[derive(Drop, Copy)] +pub struct IDojoInitLibraryDispatcherSubPointers { + pub class_hash: starknet::storage::StoragePointer, +} +impl IDojoInitLibraryDispatcherSubPointersImpl of starknet::storage::SubPointers { + type SubPointersType = IDojoInitLibraryDispatcherSubPointers; + fn sub_pointers(self: starknet::storage::StoragePointer) -> IDojoInitLibraryDispatcherSubPointers { + let base_address = self.__storage_pointer_address__; + let mut current_offset = self.__storage_pointer_offset__; + let class_hash_value = starknet::storage::StoragePointer { + __storage_pointer_address__: base_address, + __storage_pointer_offset__: current_offset, + }; + IDojoInitLibraryDispatcherSubPointers { + class_hash: class_hash_value, + } + } +} +#[derive(Drop, Copy)] +pub struct IDojoInitLibraryDispatcherSubPointersMut { + pub class_hash: starknet::storage::StoragePointer>, +} +impl IDojoInitLibraryDispatcherSubPointersMutImpl of starknet::storage::SubPointersMut { + type SubPointersType = IDojoInitLibraryDispatcherSubPointersMut; + fn sub_pointers_mut(self: starknet::storage::StoragePointer>) -> IDojoInitLibraryDispatcherSubPointersMut { + let base_address = self.__storage_pointer_address__; + let mut current_offset = self.__storage_pointer_offset__; + let class_hash_value = starknet::storage::StoragePointer { + __storage_pointer_address__: base_address, + __storage_pointer_offset__: current_offset, + }; + IDojoInitLibraryDispatcherSubPointersMut { + class_hash: class_hash_value, + } + } +} +impl IDojoInitSafeLibraryDispatcherCopy of core::traits::Copy::; +impl IDojoInitSafeLibraryDispatcherDrop of core::traits::Drop::; +impl IDojoInitSafeLibraryDispatcherSerde of core::serde::Serde:: { + fn serialize(self: @IDojoInitSafeLibraryDispatcher, ref output: core::array::Array) { + core::serde::Serde::serialize(self.class_hash, ref output) + } + fn deserialize(ref serialized: core::array::Span) -> core::option::Option { + core::option::Option::Some(IDojoInitSafeLibraryDispatcher { + class_hash: core::serde::Serde::deserialize(ref serialized)?, + }) + } +} +impl StoreIDojoInitSafeLibraryDispatcher of starknet::Store:: { + fn read(address_domain: u32, base: starknet::storage_access::StorageBaseAddress) -> starknet::SyscallResult { + let class_hash = starknet::Store::::read(address_domain, base)?; + starknet::SyscallResult::Ok( + IDojoInitSafeLibraryDispatcher { + class_hash, + } + ) + } + fn write(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, value: IDojoInitSafeLibraryDispatcher) -> starknet::SyscallResult<()> { + starknet::Store::::write(address_domain, base, value.class_hash)?; + starknet::SyscallResult::Ok(()) + } + fn read_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8) -> starknet::SyscallResult { + let class_hash = starknet::Store::::read_at_offset(address_domain, base, offset)?; + starknet::SyscallResult::Ok( + IDojoInitSafeLibraryDispatcher { + class_hash, + } + ) + } + #[inline(always)] + fn write_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8, value: IDojoInitSafeLibraryDispatcher) -> starknet::SyscallResult<()> { + starknet::Store::::write_at_offset(address_domain, base, offset, value.class_hash)?; + starknet::SyscallResult::Ok(()) + } + #[inline(always)] + fn size() -> u8 { + starknet::Store::::size() + } +} + +#[derive(Drop, Copy)] +pub struct IDojoInitSafeLibraryDispatcherSubPointers { + pub class_hash: starknet::storage::StoragePointer, +} +impl IDojoInitSafeLibraryDispatcherSubPointersImpl of starknet::storage::SubPointers { + type SubPointersType = IDojoInitSafeLibraryDispatcherSubPointers; + fn sub_pointers(self: starknet::storage::StoragePointer) -> IDojoInitSafeLibraryDispatcherSubPointers { + let base_address = self.__storage_pointer_address__; + let mut current_offset = self.__storage_pointer_offset__; + let class_hash_value = starknet::storage::StoragePointer { + __storage_pointer_address__: base_address, + __storage_pointer_offset__: current_offset, + }; + IDojoInitSafeLibraryDispatcherSubPointers { + class_hash: class_hash_value, + } + } +} +#[derive(Drop, Copy)] +pub struct IDojoInitSafeLibraryDispatcherSubPointersMut { + pub class_hash: starknet::storage::StoragePointer>, +} +impl IDojoInitSafeLibraryDispatcherSubPointersMutImpl of starknet::storage::SubPointersMut { + type SubPointersType = IDojoInitSafeLibraryDispatcherSubPointersMut; + fn sub_pointers_mut(self: starknet::storage::StoragePointer>) -> IDojoInitSafeLibraryDispatcherSubPointersMut { + let base_address = self.__storage_pointer_address__; + let mut current_offset = self.__storage_pointer_offset__; + let class_hash_value = starknet::storage::StoragePointer { + __storage_pointer_address__: base_address, + __storage_pointer_offset__: current_offset, + }; + IDojoInitSafeLibraryDispatcherSubPointersMut { + class_hash: class_hash_value, + } + } +} +impl IDojoInitSafeDispatcherCopy of core::traits::Copy::; +impl IDojoInitSafeDispatcherDrop of core::traits::Drop::; +impl IDojoInitSafeDispatcherSerde of core::serde::Serde:: { + fn serialize(self: @IDojoInitSafeDispatcher, ref output: core::array::Array) { + core::serde::Serde::serialize(self.contract_address, ref output) + } + fn deserialize(ref serialized: core::array::Span) -> core::option::Option { + core::option::Option::Some(IDojoInitSafeDispatcher { + contract_address: core::serde::Serde::deserialize(ref serialized)?, + }) + } +} +impl StoreIDojoInitSafeDispatcher of starknet::Store:: { + fn read(address_domain: u32, base: starknet::storage_access::StorageBaseAddress) -> starknet::SyscallResult { + let contract_address = starknet::Store::::read(address_domain, base)?; + starknet::SyscallResult::Ok( + IDojoInitSafeDispatcher { + contract_address, + } + ) + } + fn write(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, value: IDojoInitSafeDispatcher) -> starknet::SyscallResult<()> { + starknet::Store::::write(address_domain, base, value.contract_address)?; + starknet::SyscallResult::Ok(()) + } + fn read_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8) -> starknet::SyscallResult { + let contract_address = starknet::Store::::read_at_offset(address_domain, base, offset)?; + starknet::SyscallResult::Ok( + IDojoInitSafeDispatcher { + contract_address, + } + ) + } + #[inline(always)] + fn write_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8, value: IDojoInitSafeDispatcher) -> starknet::SyscallResult<()> { + starknet::Store::::write_at_offset(address_domain, base, offset, value.contract_address)?; + starknet::SyscallResult::Ok(()) + } + #[inline(always)] + fn size() -> u8 { + starknet::Store::::size() + } +} + +#[derive(Drop, Copy)] +pub struct IDojoInitSafeDispatcherSubPointers { + pub contract_address: starknet::storage::StoragePointer, +} +impl IDojoInitSafeDispatcherSubPointersImpl of starknet::storage::SubPointers { + type SubPointersType = IDojoInitSafeDispatcherSubPointers; + fn sub_pointers(self: starknet::storage::StoragePointer) -> IDojoInitSafeDispatcherSubPointers { + let base_address = self.__storage_pointer_address__; + let mut current_offset = self.__storage_pointer_offset__; + let contract_address_value = starknet::storage::StoragePointer { + __storage_pointer_address__: base_address, + __storage_pointer_offset__: current_offset, + }; + IDojoInitSafeDispatcherSubPointers { + contract_address: contract_address_value, + } + } +} +#[derive(Drop, Copy)] +pub struct IDojoInitSafeDispatcherSubPointersMut { + pub contract_address: starknet::storage::StoragePointer>, +} +impl IDojoInitSafeDispatcherSubPointersMutImpl of starknet::storage::SubPointersMut { + type SubPointersType = IDojoInitSafeDispatcherSubPointersMut; + fn sub_pointers_mut(self: starknet::storage::StoragePointer>) -> IDojoInitSafeDispatcherSubPointersMut { + let base_address = self.__storage_pointer_address__; + let mut current_offset = self.__storage_pointer_offset__; + let contract_address_value = starknet::storage::StoragePointer { + __storage_pointer_address__: base_address, + __storage_pointer_offset__: current_offset, + }; + IDojoInitSafeDispatcherSubPointersMut { + contract_address: contract_address_value, + } + } +} +impl StorageStorageBaseDrop of core::traits::Drop::; +impl StorageStorageBaseCopy of core::traits::Copy::; +impl StorageStorageBaseMutDrop of core::traits::Drop::; +impl StorageStorageBaseMutCopy of core::traits::Copy::; +impl IDojoInitDispatcherSubPointersDrop of core::traits::Drop::; +impl IDojoInitDispatcherSubPointersCopy of core::traits::Copy::; +impl IDojoInitDispatcherSubPointersMutDrop of core::traits::Drop::; +impl IDojoInitDispatcherSubPointersMutCopy of core::traits::Copy::; +impl IDojoInitLibraryDispatcherSubPointersDrop of core::traits::Drop::; +impl IDojoInitLibraryDispatcherSubPointersCopy of core::traits::Copy::; +impl IDojoInitLibraryDispatcherSubPointersMutDrop of core::traits::Drop::; +impl IDojoInitLibraryDispatcherSubPointersMutCopy of core::traits::Copy::; +impl IDojoInitSafeLibraryDispatcherSubPointersDrop of core::traits::Drop::; +impl IDojoInitSafeLibraryDispatcherSubPointersCopy of core::traits::Copy::; +impl IDojoInitSafeLibraryDispatcherSubPointersMutDrop of core::traits::Drop::; +impl IDojoInitSafeLibraryDispatcherSubPointersMutCopy of core::traits::Copy::; +impl IDojoInitSafeDispatcherSubPointersDrop of core::traits::Drop::; +impl IDojoInitSafeDispatcherSubPointersCopy of core::traits::Copy::; +impl IDojoInitSafeDispatcherSubPointersMutDrop of core::traits::Drop::; +impl IDojoInitSafeDispatcherSubPointersMutCopy of core::traits::Copy::; + + } + + #[starknet::contract] + pub mod proxy { + use dojo::world; + use dojo::world::IWorldDispatcher; + use dojo::world::IWorldDispatcherTrait; + use dojo::world::IWorldProvider; + use dojo::contract::IContract; + use starknet::storage::{ + StorageMapReadAccess, StorageMapWriteAccess, StoragePointerReadAccess, StoragePointerWriteAccess + }; + + #[abi(embed_v0)] + pub impl ContractImpl of IContract { + fn name(self: @ContractState) -> ByteArray { + "proxy" + } + + fn namespace(self: @ContractState) -> ByteArray { + "dojo_test" + } + + fn tag(self: @ContractState) -> ByteArray { + "dojo_test-proxy" + } + + fn name_hash(self: @ContractState) -> felt252 { + 379211399603323842291430789821178524592027629543381998047225121027704003915 + } + + fn namespace_hash(self: @ContractState) -> felt252 { + 1452123528942907587532668415362544424816022573043154497385993678618948064048 + } + + fn selector(self: @ContractState) -> felt252 { + 1940415311068338004979133415474511940700681073349244306389458906719593210527 + } + } + + #[abi(embed_v0)] + impl WorldProviderImpl of IWorldProvider { + fn world(self: @ContractState) -> IWorldDispatcher { + self.world_dispatcher.read() + } + } + + #[abi(embed_v0)] + impl UpgradableImpl = dojo::contract::upgradeable::upgradeable::UpgradableImpl; + + fn execute(value: felt252) -> felt252 { + value + } + + #[starknet::interface] + pub trait IDojoInit { + fn dojo_init(self: @ContractState); + } + + #[abi(embed_v0)] + pub impl IDojoInitImpl of IDojoInit { + fn dojo_init(self: @ContractState) { + if starknet::get_caller_address() != self.world().contract_address { + core::panics::panic_with_byte_array( + @format!("Only the world can init contract `{}`, but caller is `{:?}`", + self.tag(), + starknet::get_caller_address(), + )); + } + } + } + + #[event] + #[derive(Drop, starknet::Event)] + enum Event { + UpgradeableEvent: dojo::contract::upgradeable::upgradeable::Event, + } + pub trait IDojoInitDispatcherTrait { + fn dojo_init(self: T); +} + +#[derive(Copy, Drop, starknet::Store, Serde)] + pub struct IDojoInitDispatcher { + pub contract_address: starknet::ContractAddress, +} + +impl IDojoInitDispatcherImpl of IDojoInitDispatcherTrait { + fn dojo_init(self: IDojoInitDispatcher) { + let mut __calldata__ = core::traits::Default::default(); + + let mut __dispatcher_return_data__ = starknet::syscalls::call_contract_syscall( + self.contract_address, + selector!("dojo_init"), + core::array::ArrayTrait::span(@__calldata__), + ); + let mut __dispatcher_return_data__ = starknet::SyscallResultTrait::unwrap_syscall(__dispatcher_return_data__); + () + } + +} + +#[derive(Copy, Drop, starknet::Store, Serde)] + pub struct IDojoInitLibraryDispatcher { + pub class_hash: starknet::ClassHash, +} + +impl IDojoInitLibraryDispatcherImpl of IDojoInitDispatcherTrait { + fn dojo_init(self: IDojoInitLibraryDispatcher) { + let mut __calldata__ = core::traits::Default::default(); + + let mut __dispatcher_return_data__ = starknet::syscalls::library_call_syscall( + self.class_hash, + selector!("dojo_init"), + core::array::ArrayTrait::span(@__calldata__), + ); + let mut __dispatcher_return_data__ = starknet::SyscallResultTrait::unwrap_syscall(__dispatcher_return_data__); + () + } + +} + + pub trait IDojoInitSafeDispatcherTrait { + #[unstable(feature: "safe_dispatcher")] + fn dojo_init(self: T) -> starknet::SyscallResult<()>; +} + +#[derive(Copy, Drop, starknet::Store, Serde)] + pub struct IDojoInitSafeLibraryDispatcher { + pub class_hash: starknet::ClassHash, +} + +impl IDojoInitSafeLibraryDispatcherImpl of IDojoInitSafeDispatcherTrait { + fn dojo_init(self: IDojoInitSafeLibraryDispatcher) -> starknet::SyscallResult<()> { + let mut __calldata__ = core::traits::Default::default(); + + let mut __dispatcher_return_data__ = starknet::syscalls::library_call_syscall( + self.class_hash, + selector!("dojo_init"), + core::array::ArrayTrait::span(@__calldata__), + ); + let mut __dispatcher_return_data__ = __dispatcher_return_data__?; + Result::Ok(()) + } + +} + + +#[derive(Copy, Drop, starknet::Store, Serde)] + pub struct IDojoInitSafeDispatcher { + pub contract_address: starknet::ContractAddress, +} + +impl IDojoInitSafeDispatcherImpl of IDojoInitSafeDispatcherTrait { + fn dojo_init(self: IDojoInitSafeDispatcher) -> starknet::SyscallResult<()> { + let mut __calldata__ = core::traits::Default::default(); + + let mut __dispatcher_return_data__ = starknet::syscalls::call_contract_syscall( + self.contract_address, + selector!("dojo_init"), + core::array::ArrayTrait::span(@__calldata__), + ); + let mut __dispatcher_return_data__ = __dispatcher_return_data__?; + Result::Ok(()) + } + +} +impl EventDrop of core::traits::Drop::; +impl EventIsEvent of starknet::Event { + fn append_keys_and_data( + self: @Event, ref keys: Array, ref data: Array + ) { + match self { + Event::UpgradeableEvent(val) => { + core::array::ArrayTrait::append(ref keys, selector!("UpgradeableEvent")); + starknet::Event::append_keys_and_data( + val, ref keys, ref data + ); + }, + } + } + fn deserialize( + ref keys: Span, ref data: Span, + ) -> Option { + let __selector__ = *core::array::SpanTrait::pop_front(ref keys)?; + if __selector__ == selector!("UpgradeableEvent") { + let val = starknet::Event::deserialize( + ref keys, ref data + )?; + return Option::Some(Event::UpgradeableEvent(val)); + } + Option::None + } +} +impl EventUpgradeableEventIntoEvent of Into { + fn into(self: dojo::contract::upgradeable::upgradeable::Event) -> Event { + Event::UpgradeableEvent(self) + } +} + + +#[phantom] +pub struct Storage { + pub world_dispatcher: IWorldDispatcher, + #[substorage(v0)] + pub upgradeable: dojo::contract::upgradeable::upgradeable::Storage, +} + +#[derive(Drop, Copy)] +pub struct StorageStorageBase { + pub world_dispatcher: starknet::storage::StorageBase, + pub upgradeable: starknet::storage::FlattenedStorage, +} +impl StorageStorageImpl of starknet::storage::StorageTrait { + type BaseType = StorageStorageBase; + fn storage(self: starknet::storage::FlattenedStorage) -> StorageStorageBase { + let world_dispatcher_value = starknet::storage::StorageBase {__base_address__: selector!("world_dispatcher")}; + let upgradeable_value = starknet::storage::FlattenedStorage {}; + StorageStorageBase { + world_dispatcher: world_dispatcher_value, + upgradeable: upgradeable_value, + } + } +} +#[derive(Drop, Copy)] +pub struct StorageStorageBaseMut { + pub world_dispatcher: starknet::storage::StorageBase>, + pub upgradeable: starknet::storage::FlattenedStorage>, +} +impl StorageStorageMutImpl of starknet::storage::StorageTraitMut { + type BaseType = StorageStorageBaseMut; + fn storage_mut(self: starknet::storage::FlattenedStorage>) -> StorageStorageBaseMut { + let world_dispatcher_value = starknet::storage::StorageBase {__base_address__: selector!("world_dispatcher")}; + let upgradeable_value = starknet::storage::FlattenedStorage {}; + StorageStorageBaseMut { + world_dispatcher: world_dispatcher_value, + upgradeable: upgradeable_value, + } + } +} + +pub struct ContractState { + pub upgradeable: dojo::contract::upgradeable::upgradeable::ComponentState, +} + +impl ContractStateDrop of Drop {} + +impl ContractStateDeref of core::ops::SnapshotDeref { + type Target = starknet::storage::FlattenedStorage; + fn snapshot_deref(self: @ContractState) -> starknet::storage::FlattenedStorage { + starknet::storage::FlattenedStorage {} + } +} +impl ContractStateDerefMut of core::ops::DerefMut { + type Target = starknet::storage::FlattenedStorage> ; + fn deref_mut(ref self: ContractState) -> starknet::storage::FlattenedStorage> { + starknet::storage::FlattenedStorage {} + } +} +pub fn unsafe_new_contract_state() -> ContractState { + ContractState { + upgradeable: dojo::contract::upgradeable::upgradeable::unsafe_new_component_state::(), + } +} + +// TODO(Gil): This generates duplicate diagnostics because of the plugin system, squash the duplicates into one. +#[deprecated( + feature: "deprecated_legacy_map", + note: "Use `starknet::storage::Map` instead." +)] +use starknet::storage::Map as LegacyMap; + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__ContractImpl__name(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = ContractImpl::name(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__ContractImpl__namespace(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = ContractImpl::namespace(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__ContractImpl__tag(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = ContractImpl::tag(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__ContractImpl__name_hash(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = ContractImpl::name_hash(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__ContractImpl__namespace_hash(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = ContractImpl::namespace_hash(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__ContractImpl__selector(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = ContractImpl::selector(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__WorldProviderImpl__world(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = WorldProviderImpl::world(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +impl ContractStateUpgradableImpl of + dojo::contract::upgradeable::upgradeable::UnsafeNewContractStateTraitForUpgradableImpl { + fn unsafe_new_contract_state() -> ContractState { + unsafe_new_contract_state() + } +} +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__IDojoInitImpl__dojo_init(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + IDojoInitImpl::dojo_init(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::array::ArrayTrait::span(@arr) +} + + +pub mod __external { + pub use super::__wrapper__ContractImpl__name as name; + pub use super::__wrapper__ContractImpl__namespace as namespace; + pub use super::__wrapper__ContractImpl__tag as tag; + pub use super::__wrapper__ContractImpl__name_hash as name_hash; + pub use super::__wrapper__ContractImpl__namespace_hash as namespace_hash; + pub use super::__wrapper__ContractImpl__selector as selector; + pub use super::__wrapper__WorldProviderImpl__world as world; + pub use super::__wrapper__IDojoInitImpl__dojo_init as dojo_init; +} +pub mod __l1_handler { +} +pub mod __constructor { +} + impl ContractStateEventEmitter of starknet::event::EventEmitter< + ContractState, Event + > { + fn emit>( + ref self: ContractState, event: S + ) { + let event: Event = core::traits::Into::into(event); + let mut keys = Default::::default(); + let mut data = Default::::default(); + starknet::Event::append_keys_and_data(@event, ref keys, ref data); + starknet::SyscallResultTrait::unwrap_syscall( + starknet::syscalls::emit_event_syscall( + core::array::ArrayTrait::span(@keys), + core::array::ArrayTrait::span(@data), + ) + ) + } + } + +impl HasComponentImpl_upgradeable of dojo::contract::upgradeable::upgradeable::HasComponent { + fn get_component(self: @ContractState) -> @dojo::contract::upgradeable::upgradeable::ComponentState { + @dojo::contract::upgradeable::upgradeable::unsafe_new_component_state::() + } + fn get_component_mut(ref self: ContractState) -> dojo::contract::upgradeable::upgradeable::ComponentState { + dojo::contract::upgradeable::upgradeable::unsafe_new_component_state::() + } + fn get_contract(self: @dojo::contract::upgradeable::upgradeable::ComponentState) -> @ContractState { + @unsafe_new_contract_state() + } + fn get_contract_mut(ref self: dojo::contract::upgradeable::upgradeable::ComponentState) -> ContractState { + unsafe_new_contract_state() + } + fn emit>(ref self: dojo::contract::upgradeable::upgradeable::ComponentState, event: S) { + let event: dojo::contract::upgradeable::upgradeable::Event = core::traits::Into::into(event); + let mut contract = dojo::contract::upgradeable::upgradeable::HasComponent::get_contract_mut(ref self); + ContractStateEventEmitter::emit(ref contract, Event::UpgradeableEvent(event)); + } +} +impl IDojoInitDispatcherCopy of core::traits::Copy::; +impl IDojoInitDispatcherDrop of core::traits::Drop::; +impl IDojoInitDispatcherSerde of core::serde::Serde:: { + fn serialize(self: @IDojoInitDispatcher, ref output: core::array::Array) { + core::serde::Serde::serialize(self.contract_address, ref output) + } + fn deserialize(ref serialized: core::array::Span) -> core::option::Option { + core::option::Option::Some(IDojoInitDispatcher { + contract_address: core::serde::Serde::deserialize(ref serialized)?, + }) + } +} +impl StoreIDojoInitDispatcher of starknet::Store:: { + fn read(address_domain: u32, base: starknet::storage_access::StorageBaseAddress) -> starknet::SyscallResult { + let contract_address = starknet::Store::::read(address_domain, base)?; + starknet::SyscallResult::Ok( + IDojoInitDispatcher { + contract_address, + } + ) + } + fn write(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, value: IDojoInitDispatcher) -> starknet::SyscallResult<()> { + starknet::Store::::write(address_domain, base, value.contract_address)?; + starknet::SyscallResult::Ok(()) + } + fn read_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8) -> starknet::SyscallResult { + let contract_address = starknet::Store::::read_at_offset(address_domain, base, offset)?; + starknet::SyscallResult::Ok( + IDojoInitDispatcher { + contract_address, + } + ) + } + #[inline(always)] + fn write_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8, value: IDojoInitDispatcher) -> starknet::SyscallResult<()> { + starknet::Store::::write_at_offset(address_domain, base, offset, value.contract_address)?; + starknet::SyscallResult::Ok(()) + } + #[inline(always)] + fn size() -> u8 { + starknet::Store::::size() + } +} + +#[derive(Drop, Copy)] +pub struct IDojoInitDispatcherSubPointers { + pub contract_address: starknet::storage::StoragePointer, +} +impl IDojoInitDispatcherSubPointersImpl of starknet::storage::SubPointers { + type SubPointersType = IDojoInitDispatcherSubPointers; + fn sub_pointers(self: starknet::storage::StoragePointer) -> IDojoInitDispatcherSubPointers { + let base_address = self.__storage_pointer_address__; + let mut current_offset = self.__storage_pointer_offset__; + let contract_address_value = starknet::storage::StoragePointer { + __storage_pointer_address__: base_address, + __storage_pointer_offset__: current_offset, + }; + IDojoInitDispatcherSubPointers { + contract_address: contract_address_value, + } + } +} +#[derive(Drop, Copy)] +pub struct IDojoInitDispatcherSubPointersMut { + pub contract_address: starknet::storage::StoragePointer>, +} +impl IDojoInitDispatcherSubPointersMutImpl of starknet::storage::SubPointersMut { + type SubPointersType = IDojoInitDispatcherSubPointersMut; + fn sub_pointers_mut(self: starknet::storage::StoragePointer>) -> IDojoInitDispatcherSubPointersMut { + let base_address = self.__storage_pointer_address__; + let mut current_offset = self.__storage_pointer_offset__; + let contract_address_value = starknet::storage::StoragePointer { + __storage_pointer_address__: base_address, + __storage_pointer_offset__: current_offset, + }; + IDojoInitDispatcherSubPointersMut { + contract_address: contract_address_value, + } + } +} +impl IDojoInitLibraryDispatcherCopy of core::traits::Copy::; +impl IDojoInitLibraryDispatcherDrop of core::traits::Drop::; +impl IDojoInitLibraryDispatcherSerde of core::serde::Serde:: { + fn serialize(self: @IDojoInitLibraryDispatcher, ref output: core::array::Array) { + core::serde::Serde::serialize(self.class_hash, ref output) + } + fn deserialize(ref serialized: core::array::Span) -> core::option::Option { + core::option::Option::Some(IDojoInitLibraryDispatcher { + class_hash: core::serde::Serde::deserialize(ref serialized)?, + }) + } +} +impl StoreIDojoInitLibraryDispatcher of starknet::Store:: { + fn read(address_domain: u32, base: starknet::storage_access::StorageBaseAddress) -> starknet::SyscallResult { + let class_hash = starknet::Store::::read(address_domain, base)?; + starknet::SyscallResult::Ok( + IDojoInitLibraryDispatcher { + class_hash, + } + ) + } + fn write(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, value: IDojoInitLibraryDispatcher) -> starknet::SyscallResult<()> { + starknet::Store::::write(address_domain, base, value.class_hash)?; + starknet::SyscallResult::Ok(()) + } + fn read_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8) -> starknet::SyscallResult { + let class_hash = starknet::Store::::read_at_offset(address_domain, base, offset)?; + starknet::SyscallResult::Ok( + IDojoInitLibraryDispatcher { + class_hash, + } + ) + } + #[inline(always)] + fn write_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8, value: IDojoInitLibraryDispatcher) -> starknet::SyscallResult<()> { + starknet::Store::::write_at_offset(address_domain, base, offset, value.class_hash)?; + starknet::SyscallResult::Ok(()) + } + #[inline(always)] + fn size() -> u8 { + starknet::Store::::size() + } +} + +#[derive(Drop, Copy)] +pub struct IDojoInitLibraryDispatcherSubPointers { + pub class_hash: starknet::storage::StoragePointer, +} +impl IDojoInitLibraryDispatcherSubPointersImpl of starknet::storage::SubPointers { + type SubPointersType = IDojoInitLibraryDispatcherSubPointers; + fn sub_pointers(self: starknet::storage::StoragePointer) -> IDojoInitLibraryDispatcherSubPointers { + let base_address = self.__storage_pointer_address__; + let mut current_offset = self.__storage_pointer_offset__; + let class_hash_value = starknet::storage::StoragePointer { + __storage_pointer_address__: base_address, + __storage_pointer_offset__: current_offset, + }; + IDojoInitLibraryDispatcherSubPointers { + class_hash: class_hash_value, + } + } +} +#[derive(Drop, Copy)] +pub struct IDojoInitLibraryDispatcherSubPointersMut { + pub class_hash: starknet::storage::StoragePointer>, +} +impl IDojoInitLibraryDispatcherSubPointersMutImpl of starknet::storage::SubPointersMut { + type SubPointersType = IDojoInitLibraryDispatcherSubPointersMut; + fn sub_pointers_mut(self: starknet::storage::StoragePointer>) -> IDojoInitLibraryDispatcherSubPointersMut { + let base_address = self.__storage_pointer_address__; + let mut current_offset = self.__storage_pointer_offset__; + let class_hash_value = starknet::storage::StoragePointer { + __storage_pointer_address__: base_address, + __storage_pointer_offset__: current_offset, + }; + IDojoInitLibraryDispatcherSubPointersMut { + class_hash: class_hash_value, + } + } +} +impl IDojoInitSafeLibraryDispatcherCopy of core::traits::Copy::; +impl IDojoInitSafeLibraryDispatcherDrop of core::traits::Drop::; +impl IDojoInitSafeLibraryDispatcherSerde of core::serde::Serde:: { + fn serialize(self: @IDojoInitSafeLibraryDispatcher, ref output: core::array::Array) { + core::serde::Serde::serialize(self.class_hash, ref output) + } + fn deserialize(ref serialized: core::array::Span) -> core::option::Option { + core::option::Option::Some(IDojoInitSafeLibraryDispatcher { + class_hash: core::serde::Serde::deserialize(ref serialized)?, + }) + } +} +impl StoreIDojoInitSafeLibraryDispatcher of starknet::Store:: { + fn read(address_domain: u32, base: starknet::storage_access::StorageBaseAddress) -> starknet::SyscallResult { + let class_hash = starknet::Store::::read(address_domain, base)?; + starknet::SyscallResult::Ok( + IDojoInitSafeLibraryDispatcher { + class_hash, + } + ) + } + fn write(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, value: IDojoInitSafeLibraryDispatcher) -> starknet::SyscallResult<()> { + starknet::Store::::write(address_domain, base, value.class_hash)?; + starknet::SyscallResult::Ok(()) + } + fn read_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8) -> starknet::SyscallResult { + let class_hash = starknet::Store::::read_at_offset(address_domain, base, offset)?; + starknet::SyscallResult::Ok( + IDojoInitSafeLibraryDispatcher { + class_hash, + } + ) + } + #[inline(always)] + fn write_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8, value: IDojoInitSafeLibraryDispatcher) -> starknet::SyscallResult<()> { + starknet::Store::::write_at_offset(address_domain, base, offset, value.class_hash)?; + starknet::SyscallResult::Ok(()) + } + #[inline(always)] + fn size() -> u8 { + starknet::Store::::size() + } +} + +#[derive(Drop, Copy)] +pub struct IDojoInitSafeLibraryDispatcherSubPointers { + pub class_hash: starknet::storage::StoragePointer, +} +impl IDojoInitSafeLibraryDispatcherSubPointersImpl of starknet::storage::SubPointers { + type SubPointersType = IDojoInitSafeLibraryDispatcherSubPointers; + fn sub_pointers(self: starknet::storage::StoragePointer) -> IDojoInitSafeLibraryDispatcherSubPointers { + let base_address = self.__storage_pointer_address__; + let mut current_offset = self.__storage_pointer_offset__; + let class_hash_value = starknet::storage::StoragePointer { + __storage_pointer_address__: base_address, + __storage_pointer_offset__: current_offset, + }; + IDojoInitSafeLibraryDispatcherSubPointers { + class_hash: class_hash_value, + } + } +} +#[derive(Drop, Copy)] +pub struct IDojoInitSafeLibraryDispatcherSubPointersMut { + pub class_hash: starknet::storage::StoragePointer>, +} +impl IDojoInitSafeLibraryDispatcherSubPointersMutImpl of starknet::storage::SubPointersMut { + type SubPointersType = IDojoInitSafeLibraryDispatcherSubPointersMut; + fn sub_pointers_mut(self: starknet::storage::StoragePointer>) -> IDojoInitSafeLibraryDispatcherSubPointersMut { + let base_address = self.__storage_pointer_address__; + let mut current_offset = self.__storage_pointer_offset__; + let class_hash_value = starknet::storage::StoragePointer { + __storage_pointer_address__: base_address, + __storage_pointer_offset__: current_offset, + }; + IDojoInitSafeLibraryDispatcherSubPointersMut { + class_hash: class_hash_value, + } + } +} +impl IDojoInitSafeDispatcherCopy of core::traits::Copy::; +impl IDojoInitSafeDispatcherDrop of core::traits::Drop::; +impl IDojoInitSafeDispatcherSerde of core::serde::Serde:: { + fn serialize(self: @IDojoInitSafeDispatcher, ref output: core::array::Array) { + core::serde::Serde::serialize(self.contract_address, ref output) + } + fn deserialize(ref serialized: core::array::Span) -> core::option::Option { + core::option::Option::Some(IDojoInitSafeDispatcher { + contract_address: core::serde::Serde::deserialize(ref serialized)?, + }) + } +} +impl StoreIDojoInitSafeDispatcher of starknet::Store:: { + fn read(address_domain: u32, base: starknet::storage_access::StorageBaseAddress) -> starknet::SyscallResult { + let contract_address = starknet::Store::::read(address_domain, base)?; + starknet::SyscallResult::Ok( + IDojoInitSafeDispatcher { + contract_address, + } + ) + } + fn write(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, value: IDojoInitSafeDispatcher) -> starknet::SyscallResult<()> { + starknet::Store::::write(address_domain, base, value.contract_address)?; + starknet::SyscallResult::Ok(()) + } + fn read_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8) -> starknet::SyscallResult { + let contract_address = starknet::Store::::read_at_offset(address_domain, base, offset)?; + starknet::SyscallResult::Ok( + IDojoInitSafeDispatcher { + contract_address, + } + ) + } + #[inline(always)] + fn write_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8, value: IDojoInitSafeDispatcher) -> starknet::SyscallResult<()> { + starknet::Store::::write_at_offset(address_domain, base, offset, value.contract_address)?; + starknet::SyscallResult::Ok(()) + } + #[inline(always)] + fn size() -> u8 { + starknet::Store::::size() + } +} + +#[derive(Drop, Copy)] +pub struct IDojoInitSafeDispatcherSubPointers { + pub contract_address: starknet::storage::StoragePointer, +} +impl IDojoInitSafeDispatcherSubPointersImpl of starknet::storage::SubPointers { + type SubPointersType = IDojoInitSafeDispatcherSubPointers; + fn sub_pointers(self: starknet::storage::StoragePointer) -> IDojoInitSafeDispatcherSubPointers { + let base_address = self.__storage_pointer_address__; + let mut current_offset = self.__storage_pointer_offset__; + let contract_address_value = starknet::storage::StoragePointer { + __storage_pointer_address__: base_address, + __storage_pointer_offset__: current_offset, + }; + IDojoInitSafeDispatcherSubPointers { + contract_address: contract_address_value, + } + } +} +#[derive(Drop, Copy)] +pub struct IDojoInitSafeDispatcherSubPointersMut { + pub contract_address: starknet::storage::StoragePointer>, +} +impl IDojoInitSafeDispatcherSubPointersMutImpl of starknet::storage::SubPointersMut { + type SubPointersType = IDojoInitSafeDispatcherSubPointersMut; + fn sub_pointers_mut(self: starknet::storage::StoragePointer>) -> IDojoInitSafeDispatcherSubPointersMut { + let base_address = self.__storage_pointer_address__; + let mut current_offset = self.__storage_pointer_offset__; + let contract_address_value = starknet::storage::StoragePointer { + __storage_pointer_address__: base_address, + __storage_pointer_offset__: current_offset, + }; + IDojoInitSafeDispatcherSubPointersMut { + contract_address: contract_address_value, + } + } +} +impl StorageStorageBaseDrop of core::traits::Drop::; +impl StorageStorageBaseCopy of core::traits::Copy::; +impl StorageStorageBaseMutDrop of core::traits::Drop::; +impl StorageStorageBaseMutCopy of core::traits::Copy::; +impl IDojoInitDispatcherSubPointersDrop of core::traits::Drop::; +impl IDojoInitDispatcherSubPointersCopy of core::traits::Copy::; +impl IDojoInitDispatcherSubPointersMutDrop of core::traits::Drop::; +impl IDojoInitDispatcherSubPointersMutCopy of core::traits::Copy::; +impl IDojoInitLibraryDispatcherSubPointersDrop of core::traits::Drop::; +impl IDojoInitLibraryDispatcherSubPointersCopy of core::traits::Copy::; +impl IDojoInitLibraryDispatcherSubPointersMutDrop of core::traits::Drop::; +impl IDojoInitLibraryDispatcherSubPointersMutCopy of core::traits::Copy::; +impl IDojoInitSafeLibraryDispatcherSubPointersDrop of core::traits::Drop::; +impl IDojoInitSafeLibraryDispatcherSubPointersCopy of core::traits::Copy::; +impl IDojoInitSafeLibraryDispatcherSubPointersMutDrop of core::traits::Drop::; +impl IDojoInitSafeLibraryDispatcherSubPointersMutCopy of core::traits::Copy::; +impl IDojoInitSafeDispatcherSubPointersDrop of core::traits::Drop::; +impl IDojoInitSafeDispatcherSubPointersCopy of core::traits::Copy::; +impl IDojoInitSafeDispatcherSubPointersMutDrop of core::traits::Drop::; +impl IDojoInitSafeDispatcherSubPointersMutCopy of core::traits::Copy::; + + } + + #[starknet::contract] + pub mod ctxnamed { + use dojo::world; + use dojo::world::IWorldDispatcher; + use dojo::world::IWorldDispatcherTrait; + use dojo::world::IWorldProvider; + use dojo::contract::IContract; + use starknet::storage::{ + StorageMapReadAccess, StorageMapWriteAccess, StoragePointerReadAccess, StoragePointerWriteAccess + }; + + #[abi(embed_v0)] + pub impl ContractImpl of IContract { + fn name(self: @ContractState) -> ByteArray { + "ctxnamed" + } + + fn namespace(self: @ContractState) -> ByteArray { + "dojo_test" + } + + fn tag(self: @ContractState) -> ByteArray { + "dojo_test-ctxnamed" + } + + fn name_hash(self: @ContractState) -> felt252 { + 1120614286815912604239420768209466007446460277061516527925636408561239543041 + } + + fn namespace_hash(self: @ContractState) -> felt252 { + 1452123528942907587532668415362544424816022573043154497385993678618948064048 + } + + fn selector(self: @ContractState) -> felt252 { + 1088922133313711214547564678240399488767278073212336739350382494993498982824 + } + } + + #[abi(embed_v0)] + impl WorldProviderImpl of IWorldProvider { + fn world(self: @ContractState) -> IWorldDispatcher { + self.world_dispatcher.read() + } + } + + #[abi(embed_v0)] + impl UpgradableImpl = dojo::contract::upgradeable::upgradeable::UpgradableImpl; + + use traits::Into; + use dojo::world::Context; + + fn execute(ctx2: Context, name: felt252) { + return (); + } + + #[starknet::interface] + pub trait IDojoInit { + fn dojo_init(self: @ContractState); + } + + #[abi(embed_v0)] + pub impl IDojoInitImpl of IDojoInit { + fn dojo_init(self: @ContractState) { + if starknet::get_caller_address() != self.world().contract_address { + core::panics::panic_with_byte_array( + @format!("Only the world can init contract `{}`, but caller is `{:?}`", + self.tag(), + starknet::get_caller_address(), + )); + } + } + } + + #[event] + #[derive(Drop, starknet::Event)] + enum Event { + UpgradeableEvent: dojo::contract::upgradeable::upgradeable::Event, + } + pub trait IDojoInitDispatcherTrait { + fn dojo_init(self: T); +} + +#[derive(Copy, Drop, starknet::Store, Serde)] + pub struct IDojoInitDispatcher { + pub contract_address: starknet::ContractAddress, +} + +impl IDojoInitDispatcherImpl of IDojoInitDispatcherTrait { + fn dojo_init(self: IDojoInitDispatcher) { + let mut __calldata__ = core::traits::Default::default(); + + let mut __dispatcher_return_data__ = starknet::syscalls::call_contract_syscall( + self.contract_address, + selector!("dojo_init"), + core::array::ArrayTrait::span(@__calldata__), + ); + let mut __dispatcher_return_data__ = starknet::SyscallResultTrait::unwrap_syscall(__dispatcher_return_data__); + () + } + +} + +#[derive(Copy, Drop, starknet::Store, Serde)] + pub struct IDojoInitLibraryDispatcher { + pub class_hash: starknet::ClassHash, +} + +impl IDojoInitLibraryDispatcherImpl of IDojoInitDispatcherTrait { + fn dojo_init(self: IDojoInitLibraryDispatcher) { + let mut __calldata__ = core::traits::Default::default(); + + let mut __dispatcher_return_data__ = starknet::syscalls::library_call_syscall( + self.class_hash, + selector!("dojo_init"), + core::array::ArrayTrait::span(@__calldata__), + ); + let mut __dispatcher_return_data__ = starknet::SyscallResultTrait::unwrap_syscall(__dispatcher_return_data__); + () + } + +} + + pub trait IDojoInitSafeDispatcherTrait { + #[unstable(feature: "safe_dispatcher")] + fn dojo_init(self: T) -> starknet::SyscallResult<()>; +} + +#[derive(Copy, Drop, starknet::Store, Serde)] + pub struct IDojoInitSafeLibraryDispatcher { + pub class_hash: starknet::ClassHash, +} + +impl IDojoInitSafeLibraryDispatcherImpl of IDojoInitSafeDispatcherTrait { + fn dojo_init(self: IDojoInitSafeLibraryDispatcher) -> starknet::SyscallResult<()> { + let mut __calldata__ = core::traits::Default::default(); + + let mut __dispatcher_return_data__ = starknet::syscalls::library_call_syscall( + self.class_hash, + selector!("dojo_init"), + core::array::ArrayTrait::span(@__calldata__), + ); + let mut __dispatcher_return_data__ = __dispatcher_return_data__?; + Result::Ok(()) + } + +} + + +#[derive(Copy, Drop, starknet::Store, Serde)] + pub struct IDojoInitSafeDispatcher { + pub contract_address: starknet::ContractAddress, +} + +impl IDojoInitSafeDispatcherImpl of IDojoInitSafeDispatcherTrait { + fn dojo_init(self: IDojoInitSafeDispatcher) -> starknet::SyscallResult<()> { + let mut __calldata__ = core::traits::Default::default(); + + let mut __dispatcher_return_data__ = starknet::syscalls::call_contract_syscall( + self.contract_address, + selector!("dojo_init"), + core::array::ArrayTrait::span(@__calldata__), + ); + let mut __dispatcher_return_data__ = __dispatcher_return_data__?; + Result::Ok(()) + } + +} +impl EventDrop of core::traits::Drop::; +impl EventIsEvent of starknet::Event { + fn append_keys_and_data( + self: @Event, ref keys: Array, ref data: Array + ) { + match self { + Event::UpgradeableEvent(val) => { + core::array::ArrayTrait::append(ref keys, selector!("UpgradeableEvent")); + starknet::Event::append_keys_and_data( + val, ref keys, ref data + ); + }, + } + } + fn deserialize( + ref keys: Span, ref data: Span, + ) -> Option { + let __selector__ = *core::array::SpanTrait::pop_front(ref keys)?; + if __selector__ == selector!("UpgradeableEvent") { + let val = starknet::Event::deserialize( + ref keys, ref data + )?; + return Option::Some(Event::UpgradeableEvent(val)); + } + Option::None + } +} +impl EventUpgradeableEventIntoEvent of Into { + fn into(self: dojo::contract::upgradeable::upgradeable::Event) -> Event { + Event::UpgradeableEvent(self) + } +} + + +#[phantom] +pub struct Storage { + pub world_dispatcher: IWorldDispatcher, + #[substorage(v0)] + pub upgradeable: dojo::contract::upgradeable::upgradeable::Storage, +} + +#[derive(Drop, Copy)] +pub struct StorageStorageBase { + pub world_dispatcher: starknet::storage::StorageBase, + pub upgradeable: starknet::storage::FlattenedStorage, +} +impl StorageStorageImpl of starknet::storage::StorageTrait { + type BaseType = StorageStorageBase; + fn storage(self: starknet::storage::FlattenedStorage) -> StorageStorageBase { + let world_dispatcher_value = starknet::storage::StorageBase {__base_address__: selector!("world_dispatcher")}; + let upgradeable_value = starknet::storage::FlattenedStorage {}; + StorageStorageBase { + world_dispatcher: world_dispatcher_value, + upgradeable: upgradeable_value, + } + } +} +#[derive(Drop, Copy)] +pub struct StorageStorageBaseMut { + pub world_dispatcher: starknet::storage::StorageBase>, + pub upgradeable: starknet::storage::FlattenedStorage>, +} +impl StorageStorageMutImpl of starknet::storage::StorageTraitMut { + type BaseType = StorageStorageBaseMut; + fn storage_mut(self: starknet::storage::FlattenedStorage>) -> StorageStorageBaseMut { + let world_dispatcher_value = starknet::storage::StorageBase {__base_address__: selector!("world_dispatcher")}; + let upgradeable_value = starknet::storage::FlattenedStorage {}; + StorageStorageBaseMut { + world_dispatcher: world_dispatcher_value, + upgradeable: upgradeable_value, + } + } +} + +pub struct ContractState { + pub upgradeable: dojo::contract::upgradeable::upgradeable::ComponentState, +} + +impl ContractStateDrop of Drop {} + +impl ContractStateDeref of core::ops::SnapshotDeref { + type Target = starknet::storage::FlattenedStorage; + fn snapshot_deref(self: @ContractState) -> starknet::storage::FlattenedStorage { + starknet::storage::FlattenedStorage {} + } +} +impl ContractStateDerefMut of core::ops::DerefMut { + type Target = starknet::storage::FlattenedStorage> ; + fn deref_mut(ref self: ContractState) -> starknet::storage::FlattenedStorage> { + starknet::storage::FlattenedStorage {} + } +} +pub fn unsafe_new_contract_state() -> ContractState { + ContractState { + upgradeable: dojo::contract::upgradeable::upgradeable::unsafe_new_component_state::(), + } +} + +// TODO(Gil): This generates duplicate diagnostics because of the plugin system, squash the duplicates into one. +#[deprecated( + feature: "deprecated_legacy_map", + note: "Use `starknet::storage::Map` instead." +)] +use starknet::storage::Map as LegacyMap; + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__ContractImpl__name(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = ContractImpl::name(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__ContractImpl__namespace(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = ContractImpl::namespace(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__ContractImpl__tag(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = ContractImpl::tag(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__ContractImpl__name_hash(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = ContractImpl::name_hash(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__ContractImpl__namespace_hash(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = ContractImpl::namespace_hash(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__ContractImpl__selector(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = ContractImpl::selector(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__WorldProviderImpl__world(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = WorldProviderImpl::world(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +impl ContractStateUpgradableImpl of + dojo::contract::upgradeable::upgradeable::UnsafeNewContractStateTraitForUpgradableImpl { + fn unsafe_new_contract_state() -> ContractState { + unsafe_new_contract_state() + } +} +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__IDojoInitImpl__dojo_init(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + IDojoInitImpl::dojo_init(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::array::ArrayTrait::span(@arr) +} + + +pub mod __external { + pub use super::__wrapper__ContractImpl__name as name; + pub use super::__wrapper__ContractImpl__namespace as namespace; + pub use super::__wrapper__ContractImpl__tag as tag; + pub use super::__wrapper__ContractImpl__name_hash as name_hash; + pub use super::__wrapper__ContractImpl__namespace_hash as namespace_hash; + pub use super::__wrapper__ContractImpl__selector as selector; + pub use super::__wrapper__WorldProviderImpl__world as world; + pub use super::__wrapper__IDojoInitImpl__dojo_init as dojo_init; +} +pub mod __l1_handler { +} +pub mod __constructor { +} + impl ContractStateEventEmitter of starknet::event::EventEmitter< + ContractState, Event + > { + fn emit>( + ref self: ContractState, event: S + ) { + let event: Event = core::traits::Into::into(event); + let mut keys = Default::::default(); + let mut data = Default::::default(); + starknet::Event::append_keys_and_data(@event, ref keys, ref data); + starknet::SyscallResultTrait::unwrap_syscall( + starknet::syscalls::emit_event_syscall( + core::array::ArrayTrait::span(@keys), + core::array::ArrayTrait::span(@data), + ) + ) + } + } + +impl HasComponentImpl_upgradeable of dojo::contract::upgradeable::upgradeable::HasComponent { + fn get_component(self: @ContractState) -> @dojo::contract::upgradeable::upgradeable::ComponentState { + @dojo::contract::upgradeable::upgradeable::unsafe_new_component_state::() + } + fn get_component_mut(ref self: ContractState) -> dojo::contract::upgradeable::upgradeable::ComponentState { + dojo::contract::upgradeable::upgradeable::unsafe_new_component_state::() + } + fn get_contract(self: @dojo::contract::upgradeable::upgradeable::ComponentState) -> @ContractState { + @unsafe_new_contract_state() + } + fn get_contract_mut(ref self: dojo::contract::upgradeable::upgradeable::ComponentState) -> ContractState { + unsafe_new_contract_state() + } + fn emit>(ref self: dojo::contract::upgradeable::upgradeable::ComponentState, event: S) { + let event: dojo::contract::upgradeable::upgradeable::Event = core::traits::Into::into(event); + let mut contract = dojo::contract::upgradeable::upgradeable::HasComponent::get_contract_mut(ref self); + ContractStateEventEmitter::emit(ref contract, Event::UpgradeableEvent(event)); + } +} +impl IDojoInitDispatcherCopy of core::traits::Copy::; +impl IDojoInitDispatcherDrop of core::traits::Drop::; +impl IDojoInitDispatcherSerde of core::serde::Serde:: { + fn serialize(self: @IDojoInitDispatcher, ref output: core::array::Array) { + core::serde::Serde::serialize(self.contract_address, ref output) + } + fn deserialize(ref serialized: core::array::Span) -> core::option::Option { + core::option::Option::Some(IDojoInitDispatcher { + contract_address: core::serde::Serde::deserialize(ref serialized)?, + }) + } +} +impl StoreIDojoInitDispatcher of starknet::Store:: { + fn read(address_domain: u32, base: starknet::storage_access::StorageBaseAddress) -> starknet::SyscallResult { + let contract_address = starknet::Store::::read(address_domain, base)?; + starknet::SyscallResult::Ok( + IDojoInitDispatcher { + contract_address, + } + ) + } + fn write(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, value: IDojoInitDispatcher) -> starknet::SyscallResult<()> { + starknet::Store::::write(address_domain, base, value.contract_address)?; + starknet::SyscallResult::Ok(()) + } + fn read_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8) -> starknet::SyscallResult { + let contract_address = starknet::Store::::read_at_offset(address_domain, base, offset)?; + starknet::SyscallResult::Ok( + IDojoInitDispatcher { + contract_address, + } + ) + } + #[inline(always)] + fn write_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8, value: IDojoInitDispatcher) -> starknet::SyscallResult<()> { + starknet::Store::::write_at_offset(address_domain, base, offset, value.contract_address)?; + starknet::SyscallResult::Ok(()) + } + #[inline(always)] + fn size() -> u8 { + starknet::Store::::size() + } +} + +#[derive(Drop, Copy)] +pub struct IDojoInitDispatcherSubPointers { + pub contract_address: starknet::storage::StoragePointer, +} +impl IDojoInitDispatcherSubPointersImpl of starknet::storage::SubPointers { + type SubPointersType = IDojoInitDispatcherSubPointers; + fn sub_pointers(self: starknet::storage::StoragePointer) -> IDojoInitDispatcherSubPointers { + let base_address = self.__storage_pointer_address__; + let mut current_offset = self.__storage_pointer_offset__; + let contract_address_value = starknet::storage::StoragePointer { + __storage_pointer_address__: base_address, + __storage_pointer_offset__: current_offset, + }; + IDojoInitDispatcherSubPointers { + contract_address: contract_address_value, + } + } +} +#[derive(Drop, Copy)] +pub struct IDojoInitDispatcherSubPointersMut { + pub contract_address: starknet::storage::StoragePointer>, +} +impl IDojoInitDispatcherSubPointersMutImpl of starknet::storage::SubPointersMut { + type SubPointersType = IDojoInitDispatcherSubPointersMut; + fn sub_pointers_mut(self: starknet::storage::StoragePointer>) -> IDojoInitDispatcherSubPointersMut { + let base_address = self.__storage_pointer_address__; + let mut current_offset = self.__storage_pointer_offset__; + let contract_address_value = starknet::storage::StoragePointer { + __storage_pointer_address__: base_address, + __storage_pointer_offset__: current_offset, + }; + IDojoInitDispatcherSubPointersMut { + contract_address: contract_address_value, + } + } +} +impl IDojoInitLibraryDispatcherCopy of core::traits::Copy::; +impl IDojoInitLibraryDispatcherDrop of core::traits::Drop::; +impl IDojoInitLibraryDispatcherSerde of core::serde::Serde:: { + fn serialize(self: @IDojoInitLibraryDispatcher, ref output: core::array::Array) { + core::serde::Serde::serialize(self.class_hash, ref output) + } + fn deserialize(ref serialized: core::array::Span) -> core::option::Option { + core::option::Option::Some(IDojoInitLibraryDispatcher { + class_hash: core::serde::Serde::deserialize(ref serialized)?, + }) + } +} +impl StoreIDojoInitLibraryDispatcher of starknet::Store:: { + fn read(address_domain: u32, base: starknet::storage_access::StorageBaseAddress) -> starknet::SyscallResult { + let class_hash = starknet::Store::::read(address_domain, base)?; + starknet::SyscallResult::Ok( + IDojoInitLibraryDispatcher { + class_hash, + } + ) + } + fn write(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, value: IDojoInitLibraryDispatcher) -> starknet::SyscallResult<()> { + starknet::Store::::write(address_domain, base, value.class_hash)?; + starknet::SyscallResult::Ok(()) + } + fn read_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8) -> starknet::SyscallResult { + let class_hash = starknet::Store::::read_at_offset(address_domain, base, offset)?; + starknet::SyscallResult::Ok( + IDojoInitLibraryDispatcher { + class_hash, + } + ) + } + #[inline(always)] + fn write_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8, value: IDojoInitLibraryDispatcher) -> starknet::SyscallResult<()> { + starknet::Store::::write_at_offset(address_domain, base, offset, value.class_hash)?; + starknet::SyscallResult::Ok(()) + } + #[inline(always)] + fn size() -> u8 { + starknet::Store::::size() + } +} + +#[derive(Drop, Copy)] +pub struct IDojoInitLibraryDispatcherSubPointers { + pub class_hash: starknet::storage::StoragePointer, +} +impl IDojoInitLibraryDispatcherSubPointersImpl of starknet::storage::SubPointers { + type SubPointersType = IDojoInitLibraryDispatcherSubPointers; + fn sub_pointers(self: starknet::storage::StoragePointer) -> IDojoInitLibraryDispatcherSubPointers { + let base_address = self.__storage_pointer_address__; + let mut current_offset = self.__storage_pointer_offset__; + let class_hash_value = starknet::storage::StoragePointer { + __storage_pointer_address__: base_address, + __storage_pointer_offset__: current_offset, + }; + IDojoInitLibraryDispatcherSubPointers { + class_hash: class_hash_value, + } + } +} +#[derive(Drop, Copy)] +pub struct IDojoInitLibraryDispatcherSubPointersMut { + pub class_hash: starknet::storage::StoragePointer>, +} +impl IDojoInitLibraryDispatcherSubPointersMutImpl of starknet::storage::SubPointersMut { + type SubPointersType = IDojoInitLibraryDispatcherSubPointersMut; + fn sub_pointers_mut(self: starknet::storage::StoragePointer>) -> IDojoInitLibraryDispatcherSubPointersMut { + let base_address = self.__storage_pointer_address__; + let mut current_offset = self.__storage_pointer_offset__; + let class_hash_value = starknet::storage::StoragePointer { + __storage_pointer_address__: base_address, + __storage_pointer_offset__: current_offset, + }; + IDojoInitLibraryDispatcherSubPointersMut { + class_hash: class_hash_value, + } + } +} +impl IDojoInitSafeLibraryDispatcherCopy of core::traits::Copy::; +impl IDojoInitSafeLibraryDispatcherDrop of core::traits::Drop::; +impl IDojoInitSafeLibraryDispatcherSerde of core::serde::Serde:: { + fn serialize(self: @IDojoInitSafeLibraryDispatcher, ref output: core::array::Array) { + core::serde::Serde::serialize(self.class_hash, ref output) + } + fn deserialize(ref serialized: core::array::Span) -> core::option::Option { + core::option::Option::Some(IDojoInitSafeLibraryDispatcher { + class_hash: core::serde::Serde::deserialize(ref serialized)?, + }) + } +} +impl StoreIDojoInitSafeLibraryDispatcher of starknet::Store:: { + fn read(address_domain: u32, base: starknet::storage_access::StorageBaseAddress) -> starknet::SyscallResult { + let class_hash = starknet::Store::::read(address_domain, base)?; + starknet::SyscallResult::Ok( + IDojoInitSafeLibraryDispatcher { + class_hash, + } + ) + } + fn write(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, value: IDojoInitSafeLibraryDispatcher) -> starknet::SyscallResult<()> { + starknet::Store::::write(address_domain, base, value.class_hash)?; + starknet::SyscallResult::Ok(()) + } + fn read_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8) -> starknet::SyscallResult { + let class_hash = starknet::Store::::read_at_offset(address_domain, base, offset)?; + starknet::SyscallResult::Ok( + IDojoInitSafeLibraryDispatcher { + class_hash, + } + ) + } + #[inline(always)] + fn write_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8, value: IDojoInitSafeLibraryDispatcher) -> starknet::SyscallResult<()> { + starknet::Store::::write_at_offset(address_domain, base, offset, value.class_hash)?; + starknet::SyscallResult::Ok(()) + } + #[inline(always)] + fn size() -> u8 { + starknet::Store::::size() + } +} + +#[derive(Drop, Copy)] +pub struct IDojoInitSafeLibraryDispatcherSubPointers { + pub class_hash: starknet::storage::StoragePointer, +} +impl IDojoInitSafeLibraryDispatcherSubPointersImpl of starknet::storage::SubPointers { + type SubPointersType = IDojoInitSafeLibraryDispatcherSubPointers; + fn sub_pointers(self: starknet::storage::StoragePointer) -> IDojoInitSafeLibraryDispatcherSubPointers { + let base_address = self.__storage_pointer_address__; + let mut current_offset = self.__storage_pointer_offset__; + let class_hash_value = starknet::storage::StoragePointer { + __storage_pointer_address__: base_address, + __storage_pointer_offset__: current_offset, + }; + IDojoInitSafeLibraryDispatcherSubPointers { + class_hash: class_hash_value, + } + } +} +#[derive(Drop, Copy)] +pub struct IDojoInitSafeLibraryDispatcherSubPointersMut { + pub class_hash: starknet::storage::StoragePointer>, +} +impl IDojoInitSafeLibraryDispatcherSubPointersMutImpl of starknet::storage::SubPointersMut { + type SubPointersType = IDojoInitSafeLibraryDispatcherSubPointersMut; + fn sub_pointers_mut(self: starknet::storage::StoragePointer>) -> IDojoInitSafeLibraryDispatcherSubPointersMut { + let base_address = self.__storage_pointer_address__; + let mut current_offset = self.__storage_pointer_offset__; + let class_hash_value = starknet::storage::StoragePointer { + __storage_pointer_address__: base_address, + __storage_pointer_offset__: current_offset, + }; + IDojoInitSafeLibraryDispatcherSubPointersMut { + class_hash: class_hash_value, + } + } +} +impl IDojoInitSafeDispatcherCopy of core::traits::Copy::; +impl IDojoInitSafeDispatcherDrop of core::traits::Drop::; +impl IDojoInitSafeDispatcherSerde of core::serde::Serde:: { + fn serialize(self: @IDojoInitSafeDispatcher, ref output: core::array::Array) { + core::serde::Serde::serialize(self.contract_address, ref output) + } + fn deserialize(ref serialized: core::array::Span) -> core::option::Option { + core::option::Option::Some(IDojoInitSafeDispatcher { + contract_address: core::serde::Serde::deserialize(ref serialized)?, + }) + } +} +impl StoreIDojoInitSafeDispatcher of starknet::Store:: { + fn read(address_domain: u32, base: starknet::storage_access::StorageBaseAddress) -> starknet::SyscallResult { + let contract_address = starknet::Store::::read(address_domain, base)?; + starknet::SyscallResult::Ok( + IDojoInitSafeDispatcher { + contract_address, + } + ) + } + fn write(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, value: IDojoInitSafeDispatcher) -> starknet::SyscallResult<()> { + starknet::Store::::write(address_domain, base, value.contract_address)?; + starknet::SyscallResult::Ok(()) + } + fn read_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8) -> starknet::SyscallResult { + let contract_address = starknet::Store::::read_at_offset(address_domain, base, offset)?; + starknet::SyscallResult::Ok( + IDojoInitSafeDispatcher { + contract_address, + } + ) + } + #[inline(always)] + fn write_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8, value: IDojoInitSafeDispatcher) -> starknet::SyscallResult<()> { + starknet::Store::::write_at_offset(address_domain, base, offset, value.contract_address)?; + starknet::SyscallResult::Ok(()) + } + #[inline(always)] + fn size() -> u8 { + starknet::Store::::size() + } +} + +#[derive(Drop, Copy)] +pub struct IDojoInitSafeDispatcherSubPointers { + pub contract_address: starknet::storage::StoragePointer, +} +impl IDojoInitSafeDispatcherSubPointersImpl of starknet::storage::SubPointers { + type SubPointersType = IDojoInitSafeDispatcherSubPointers; + fn sub_pointers(self: starknet::storage::StoragePointer) -> IDojoInitSafeDispatcherSubPointers { + let base_address = self.__storage_pointer_address__; + let mut current_offset = self.__storage_pointer_offset__; + let contract_address_value = starknet::storage::StoragePointer { + __storage_pointer_address__: base_address, + __storage_pointer_offset__: current_offset, + }; + IDojoInitSafeDispatcherSubPointers { + contract_address: contract_address_value, + } + } +} +#[derive(Drop, Copy)] +pub struct IDojoInitSafeDispatcherSubPointersMut { + pub contract_address: starknet::storage::StoragePointer>, +} +impl IDojoInitSafeDispatcherSubPointersMutImpl of starknet::storage::SubPointersMut { + type SubPointersType = IDojoInitSafeDispatcherSubPointersMut; + fn sub_pointers_mut(self: starknet::storage::StoragePointer>) -> IDojoInitSafeDispatcherSubPointersMut { + let base_address = self.__storage_pointer_address__; + let mut current_offset = self.__storage_pointer_offset__; + let contract_address_value = starknet::storage::StoragePointer { + __storage_pointer_address__: base_address, + __storage_pointer_offset__: current_offset, + }; + IDojoInitSafeDispatcherSubPointersMut { + contract_address: contract_address_value, + } + } +} +impl StorageStorageBaseDrop of core::traits::Drop::; +impl StorageStorageBaseCopy of core::traits::Copy::; +impl StorageStorageBaseMutDrop of core::traits::Drop::; +impl StorageStorageBaseMutCopy of core::traits::Copy::; +impl IDojoInitDispatcherSubPointersDrop of core::traits::Drop::; +impl IDojoInitDispatcherSubPointersCopy of core::traits::Copy::; +impl IDojoInitDispatcherSubPointersMutDrop of core::traits::Drop::; +impl IDojoInitDispatcherSubPointersMutCopy of core::traits::Copy::; +impl IDojoInitLibraryDispatcherSubPointersDrop of core::traits::Drop::; +impl IDojoInitLibraryDispatcherSubPointersCopy of core::traits::Copy::; +impl IDojoInitLibraryDispatcherSubPointersMutDrop of core::traits::Drop::; +impl IDojoInitLibraryDispatcherSubPointersMutCopy of core::traits::Copy::; +impl IDojoInitSafeLibraryDispatcherSubPointersDrop of core::traits::Drop::; +impl IDojoInitSafeLibraryDispatcherSubPointersCopy of core::traits::Copy::; +impl IDojoInitSafeLibraryDispatcherSubPointersMutDrop of core::traits::Drop::; +impl IDojoInitSafeLibraryDispatcherSubPointersMutCopy of core::traits::Copy::; +impl IDojoInitSafeDispatcherSubPointersDrop of core::traits::Drop::; +impl IDojoInitSafeDispatcherSubPointersCopy of core::traits::Copy::; +impl IDojoInitSafeDispatcherSubPointersMutDrop of core::traits::Drop::; +impl IDojoInitSafeDispatcherSubPointersMutCopy of core::traits::Copy::; + + } + + #[starknet::contract] + pub mod withevent { + use dojo::world; + use dojo::world::IWorldDispatcher; + use dojo::world::IWorldDispatcherTrait; + use dojo::world::IWorldProvider; + use dojo::contract::IContract; + use starknet::storage::{ + StorageMapReadAccess, StorageMapWriteAccess, StoragePointerReadAccess, StoragePointerWriteAccess + }; + + #[abi(embed_v0)] + pub impl ContractImpl of IContract { + fn name(self: @ContractState) -> ByteArray { + "withevent" + } + + fn namespace(self: @ContractState) -> ByteArray { + "dojo_test" + } + + fn tag(self: @ContractState) -> ByteArray { + "dojo_test-withevent" + } + + fn name_hash(self: @ContractState) -> felt252 { + 2196275886623691942883456540767114081898043897719876113518403014973431884540 + } + + fn namespace_hash(self: @ContractState) -> felt252 { + 1452123528942907587532668415362544424816022573043154497385993678618948064048 + } + + fn selector(self: @ContractState) -> felt252 { + 3549898308100844368972151697544420289462059777504886668025232769583717017648 + } + } + + #[abi(embed_v0)] + impl WorldProviderImpl of IWorldProvider { + fn world(self: @ContractState) -> IWorldDispatcher { + self.world_dispatcher.read() + } + } + + #[abi(embed_v0)] + impl UpgradableImpl = dojo::contract::upgradeable::upgradeable::UpgradableImpl; + + + #[event] + #[derive(Drop, starknet::Event)] + enum Event { + UpgradeableEvent: dojo::contract::upgradeable::upgradeable::Event, + TestEvent: TestEvent + } + + #[derive(Drop, starknet::Event)] + struct TestEvent { + address: ContractAddress, + } + + #[starknet::interface] + pub trait IDojoInit { + fn dojo_init(self: @ContractState); + } + + #[abi(embed_v0)] + pub impl IDojoInitImpl of IDojoInit { + fn dojo_init(self: @ContractState) { + if starknet::get_caller_address() != self.world().contract_address { + core::panics::panic_with_byte_array( + @format!("Only the world can init contract `{}`, but caller is `{:?}`", + self.tag(), + starknet::get_caller_address(), + )); + } + } + } +impl EventDrop of core::traits::Drop::; +impl EventIsEvent of starknet::Event { + fn append_keys_and_data( + self: @Event, ref keys: Array, ref data: Array + ) { + match self { + Event::UpgradeableEvent(val) => { + core::array::ArrayTrait::append(ref keys, selector!("UpgradeableEvent")); + starknet::Event::append_keys_and_data( + val, ref keys, ref data + ); + }, + Event::TestEvent(val) => { + core::array::ArrayTrait::append(ref keys, selector!("TestEvent")); + starknet::Event::append_keys_and_data( + val, ref keys, ref data + ); + }, + } + } + fn deserialize( + ref keys: Span, ref data: Span, + ) -> Option { + let __selector__ = *core::array::SpanTrait::pop_front(ref keys)?; + if __selector__ == selector!("UpgradeableEvent") { + let val = starknet::Event::deserialize( + ref keys, ref data + )?; + return Option::Some(Event::UpgradeableEvent(val)); + } + if __selector__ == selector!("TestEvent") { + let val = starknet::Event::deserialize( + ref keys, ref data + )?; + return Option::Some(Event::TestEvent(val)); + } + Option::None + } +} +impl EventUpgradeableEventIntoEvent of Into { + fn into(self: dojo::contract::upgradeable::upgradeable::Event) -> Event { + Event::UpgradeableEvent(self) + } +} +impl EventTestEventIntoEvent of Into { + fn into(self: TestEvent) -> Event { + Event::TestEvent(self) + } +} +impl TestEventDrop of core::traits::Drop::; +impl TestEventIsEvent of starknet::Event { + fn append_keys_and_data( + self: @TestEvent, ref keys: Array, ref data: Array + ) { + core::serde::Serde::serialize(self.address, ref data); + } + fn deserialize( + ref keys: Span, ref data: Span, + ) -> Option { + let address = core::serde::Serde::deserialize( + ref data + )?; + Option::Some(TestEvent {address, }) + } +} + pub trait IDojoInitDispatcherTrait { + fn dojo_init(self: T); +} + +#[derive(Copy, Drop, starknet::Store, Serde)] + pub struct IDojoInitDispatcher { + pub contract_address: starknet::ContractAddress, +} + +impl IDojoInitDispatcherImpl of IDojoInitDispatcherTrait { + fn dojo_init(self: IDojoInitDispatcher) { + let mut __calldata__ = core::traits::Default::default(); + + let mut __dispatcher_return_data__ = starknet::syscalls::call_contract_syscall( + self.contract_address, + selector!("dojo_init"), + core::array::ArrayTrait::span(@__calldata__), + ); + let mut __dispatcher_return_data__ = starknet::SyscallResultTrait::unwrap_syscall(__dispatcher_return_data__); + () + } + +} + +#[derive(Copy, Drop, starknet::Store, Serde)] + pub struct IDojoInitLibraryDispatcher { + pub class_hash: starknet::ClassHash, +} + +impl IDojoInitLibraryDispatcherImpl of IDojoInitDispatcherTrait { + fn dojo_init(self: IDojoInitLibraryDispatcher) { + let mut __calldata__ = core::traits::Default::default(); + + let mut __dispatcher_return_data__ = starknet::syscalls::library_call_syscall( + self.class_hash, + selector!("dojo_init"), + core::array::ArrayTrait::span(@__calldata__), + ); + let mut __dispatcher_return_data__ = starknet::SyscallResultTrait::unwrap_syscall(__dispatcher_return_data__); + () + } + +} + + pub trait IDojoInitSafeDispatcherTrait { + #[unstable(feature: "safe_dispatcher")] + fn dojo_init(self: T) -> starknet::SyscallResult<()>; +} + +#[derive(Copy, Drop, starknet::Store, Serde)] + pub struct IDojoInitSafeLibraryDispatcher { + pub class_hash: starknet::ClassHash, +} + +impl IDojoInitSafeLibraryDispatcherImpl of IDojoInitSafeDispatcherTrait { + fn dojo_init(self: IDojoInitSafeLibraryDispatcher) -> starknet::SyscallResult<()> { + let mut __calldata__ = core::traits::Default::default(); + + let mut __dispatcher_return_data__ = starknet::syscalls::library_call_syscall( + self.class_hash, + selector!("dojo_init"), + core::array::ArrayTrait::span(@__calldata__), + ); + let mut __dispatcher_return_data__ = __dispatcher_return_data__?; + Result::Ok(()) + } + +} + + +#[derive(Copy, Drop, starknet::Store, Serde)] + pub struct IDojoInitSafeDispatcher { + pub contract_address: starknet::ContractAddress, +} + +impl IDojoInitSafeDispatcherImpl of IDojoInitSafeDispatcherTrait { + fn dojo_init(self: IDojoInitSafeDispatcher) -> starknet::SyscallResult<()> { + let mut __calldata__ = core::traits::Default::default(); + + let mut __dispatcher_return_data__ = starknet::syscalls::call_contract_syscall( + self.contract_address, + selector!("dojo_init"), + core::array::ArrayTrait::span(@__calldata__), + ); + let mut __dispatcher_return_data__ = __dispatcher_return_data__?; + Result::Ok(()) + } + +} + + +#[phantom] +pub struct Storage { + pub world_dispatcher: IWorldDispatcher, + #[substorage(v0)] + pub upgradeable: dojo::contract::upgradeable::upgradeable::Storage, +} + +#[derive(Drop, Copy)] +pub struct StorageStorageBase { + pub world_dispatcher: starknet::storage::StorageBase, + pub upgradeable: starknet::storage::FlattenedStorage, +} +impl StorageStorageImpl of starknet::storage::StorageTrait { + type BaseType = StorageStorageBase; + fn storage(self: starknet::storage::FlattenedStorage) -> StorageStorageBase { + let world_dispatcher_value = starknet::storage::StorageBase {__base_address__: selector!("world_dispatcher")}; + let upgradeable_value = starknet::storage::FlattenedStorage {}; + StorageStorageBase { + world_dispatcher: world_dispatcher_value, + upgradeable: upgradeable_value, + } + } +} +#[derive(Drop, Copy)] +pub struct StorageStorageBaseMut { + pub world_dispatcher: starknet::storage::StorageBase>, + pub upgradeable: starknet::storage::FlattenedStorage>, +} +impl StorageStorageMutImpl of starknet::storage::StorageTraitMut { + type BaseType = StorageStorageBaseMut; + fn storage_mut(self: starknet::storage::FlattenedStorage>) -> StorageStorageBaseMut { + let world_dispatcher_value = starknet::storage::StorageBase {__base_address__: selector!("world_dispatcher")}; + let upgradeable_value = starknet::storage::FlattenedStorage {}; + StorageStorageBaseMut { + world_dispatcher: world_dispatcher_value, + upgradeable: upgradeable_value, + } + } +} + +pub struct ContractState { + pub upgradeable: dojo::contract::upgradeable::upgradeable::ComponentState, +} + +impl ContractStateDrop of Drop {} + +impl ContractStateDeref of core::ops::SnapshotDeref { + type Target = starknet::storage::FlattenedStorage; + fn snapshot_deref(self: @ContractState) -> starknet::storage::FlattenedStorage { + starknet::storage::FlattenedStorage {} + } +} +impl ContractStateDerefMut of core::ops::DerefMut { + type Target = starknet::storage::FlattenedStorage> ; + fn deref_mut(ref self: ContractState) -> starknet::storage::FlattenedStorage> { + starknet::storage::FlattenedStorage {} + } +} +pub fn unsafe_new_contract_state() -> ContractState { + ContractState { + upgradeable: dojo::contract::upgradeable::upgradeable::unsafe_new_component_state::(), + } +} + +// TODO(Gil): This generates duplicate diagnostics because of the plugin system, squash the duplicates into one. +#[deprecated( + feature: "deprecated_legacy_map", + note: "Use `starknet::storage::Map` instead." +)] +use starknet::storage::Map as LegacyMap; + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__ContractImpl__name(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = ContractImpl::name(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__ContractImpl__namespace(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = ContractImpl::namespace(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__ContractImpl__tag(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = ContractImpl::tag(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__ContractImpl__name_hash(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = ContractImpl::name_hash(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__ContractImpl__namespace_hash(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = ContractImpl::namespace_hash(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__ContractImpl__selector(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = ContractImpl::selector(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__WorldProviderImpl__world(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = WorldProviderImpl::world(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +impl ContractStateUpgradableImpl of + dojo::contract::upgradeable::upgradeable::UnsafeNewContractStateTraitForUpgradableImpl { + fn unsafe_new_contract_state() -> ContractState { + unsafe_new_contract_state() + } +} +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__IDojoInitImpl__dojo_init(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + IDojoInitImpl::dojo_init(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::array::ArrayTrait::span(@arr) +} + + +pub mod __external { + pub use super::__wrapper__ContractImpl__name as name; + pub use super::__wrapper__ContractImpl__namespace as namespace; + pub use super::__wrapper__ContractImpl__tag as tag; + pub use super::__wrapper__ContractImpl__name_hash as name_hash; + pub use super::__wrapper__ContractImpl__namespace_hash as namespace_hash; + pub use super::__wrapper__ContractImpl__selector as selector; + pub use super::__wrapper__WorldProviderImpl__world as world; + pub use super::__wrapper__IDojoInitImpl__dojo_init as dojo_init; +} +pub mod __l1_handler { +} +pub mod __constructor { +} + impl ContractStateEventEmitter of starknet::event::EventEmitter< + ContractState, Event + > { + fn emit>( + ref self: ContractState, event: S + ) { + let event: Event = core::traits::Into::into(event); + let mut keys = Default::::default(); + let mut data = Default::::default(); + starknet::Event::append_keys_and_data(@event, ref keys, ref data); + starknet::SyscallResultTrait::unwrap_syscall( + starknet::syscalls::emit_event_syscall( + core::array::ArrayTrait::span(@keys), + core::array::ArrayTrait::span(@data), + ) + ) + } + } + +impl HasComponentImpl_upgradeable of dojo::contract::upgradeable::upgradeable::HasComponent { + fn get_component(self: @ContractState) -> @dojo::contract::upgradeable::upgradeable::ComponentState { + @dojo::contract::upgradeable::upgradeable::unsafe_new_component_state::() + } + fn get_component_mut(ref self: ContractState) -> dojo::contract::upgradeable::upgradeable::ComponentState { + dojo::contract::upgradeable::upgradeable::unsafe_new_component_state::() + } + fn get_contract(self: @dojo::contract::upgradeable::upgradeable::ComponentState) -> @ContractState { + @unsafe_new_contract_state() + } + fn get_contract_mut(ref self: dojo::contract::upgradeable::upgradeable::ComponentState) -> ContractState { + unsafe_new_contract_state() + } + fn emit>(ref self: dojo::contract::upgradeable::upgradeable::ComponentState, event: S) { + let event: dojo::contract::upgradeable::upgradeable::Event = core::traits::Into::into(event); + let mut contract = dojo::contract::upgradeable::upgradeable::HasComponent::get_contract_mut(ref self); + ContractStateEventEmitter::emit(ref contract, Event::UpgradeableEvent(event)); + } +} +impl IDojoInitDispatcherCopy of core::traits::Copy::; +impl IDojoInitDispatcherDrop of core::traits::Drop::; +impl IDojoInitDispatcherSerde of core::serde::Serde:: { + fn serialize(self: @IDojoInitDispatcher, ref output: core::array::Array) { + core::serde::Serde::serialize(self.contract_address, ref output) + } + fn deserialize(ref serialized: core::array::Span) -> core::option::Option { + core::option::Option::Some(IDojoInitDispatcher { + contract_address: core::serde::Serde::deserialize(ref serialized)?, + }) + } +} +impl StoreIDojoInitDispatcher of starknet::Store:: { + fn read(address_domain: u32, base: starknet::storage_access::StorageBaseAddress) -> starknet::SyscallResult { + let contract_address = starknet::Store::::read(address_domain, base)?; + starknet::SyscallResult::Ok( + IDojoInitDispatcher { + contract_address, + } + ) + } + fn write(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, value: IDojoInitDispatcher) -> starknet::SyscallResult<()> { + starknet::Store::::write(address_domain, base, value.contract_address)?; + starknet::SyscallResult::Ok(()) + } + fn read_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8) -> starknet::SyscallResult { + let contract_address = starknet::Store::::read_at_offset(address_domain, base, offset)?; + starknet::SyscallResult::Ok( + IDojoInitDispatcher { + contract_address, + } + ) + } + #[inline(always)] + fn write_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8, value: IDojoInitDispatcher) -> starknet::SyscallResult<()> { + starknet::Store::::write_at_offset(address_domain, base, offset, value.contract_address)?; + starknet::SyscallResult::Ok(()) + } + #[inline(always)] + fn size() -> u8 { + starknet::Store::::size() + } +} + +#[derive(Drop, Copy)] +pub struct IDojoInitDispatcherSubPointers { + pub contract_address: starknet::storage::StoragePointer, +} +impl IDojoInitDispatcherSubPointersImpl of starknet::storage::SubPointers { + type SubPointersType = IDojoInitDispatcherSubPointers; + fn sub_pointers(self: starknet::storage::StoragePointer) -> IDojoInitDispatcherSubPointers { + let base_address = self.__storage_pointer_address__; + let mut current_offset = self.__storage_pointer_offset__; + let contract_address_value = starknet::storage::StoragePointer { + __storage_pointer_address__: base_address, + __storage_pointer_offset__: current_offset, + }; + IDojoInitDispatcherSubPointers { + contract_address: contract_address_value, + } + } +} +#[derive(Drop, Copy)] +pub struct IDojoInitDispatcherSubPointersMut { + pub contract_address: starknet::storage::StoragePointer>, +} +impl IDojoInitDispatcherSubPointersMutImpl of starknet::storage::SubPointersMut { + type SubPointersType = IDojoInitDispatcherSubPointersMut; + fn sub_pointers_mut(self: starknet::storage::StoragePointer>) -> IDojoInitDispatcherSubPointersMut { + let base_address = self.__storage_pointer_address__; + let mut current_offset = self.__storage_pointer_offset__; + let contract_address_value = starknet::storage::StoragePointer { + __storage_pointer_address__: base_address, + __storage_pointer_offset__: current_offset, + }; + IDojoInitDispatcherSubPointersMut { + contract_address: contract_address_value, + } + } +} +impl IDojoInitLibraryDispatcherCopy of core::traits::Copy::; +impl IDojoInitLibraryDispatcherDrop of core::traits::Drop::; +impl IDojoInitLibraryDispatcherSerde of core::serde::Serde:: { + fn serialize(self: @IDojoInitLibraryDispatcher, ref output: core::array::Array) { + core::serde::Serde::serialize(self.class_hash, ref output) + } + fn deserialize(ref serialized: core::array::Span) -> core::option::Option { + core::option::Option::Some(IDojoInitLibraryDispatcher { + class_hash: core::serde::Serde::deserialize(ref serialized)?, + }) + } +} +impl StoreIDojoInitLibraryDispatcher of starknet::Store:: { + fn read(address_domain: u32, base: starknet::storage_access::StorageBaseAddress) -> starknet::SyscallResult { + let class_hash = starknet::Store::::read(address_domain, base)?; + starknet::SyscallResult::Ok( + IDojoInitLibraryDispatcher { + class_hash, + } + ) + } + fn write(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, value: IDojoInitLibraryDispatcher) -> starknet::SyscallResult<()> { + starknet::Store::::write(address_domain, base, value.class_hash)?; + starknet::SyscallResult::Ok(()) + } + fn read_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8) -> starknet::SyscallResult { + let class_hash = starknet::Store::::read_at_offset(address_domain, base, offset)?; + starknet::SyscallResult::Ok( + IDojoInitLibraryDispatcher { + class_hash, + } + ) + } + #[inline(always)] + fn write_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8, value: IDojoInitLibraryDispatcher) -> starknet::SyscallResult<()> { + starknet::Store::::write_at_offset(address_domain, base, offset, value.class_hash)?; + starknet::SyscallResult::Ok(()) + } + #[inline(always)] + fn size() -> u8 { + starknet::Store::::size() + } +} + +#[derive(Drop, Copy)] +pub struct IDojoInitLibraryDispatcherSubPointers { + pub class_hash: starknet::storage::StoragePointer, +} +impl IDojoInitLibraryDispatcherSubPointersImpl of starknet::storage::SubPointers { + type SubPointersType = IDojoInitLibraryDispatcherSubPointers; + fn sub_pointers(self: starknet::storage::StoragePointer) -> IDojoInitLibraryDispatcherSubPointers { + let base_address = self.__storage_pointer_address__; + let mut current_offset = self.__storage_pointer_offset__; + let class_hash_value = starknet::storage::StoragePointer { + __storage_pointer_address__: base_address, + __storage_pointer_offset__: current_offset, + }; + IDojoInitLibraryDispatcherSubPointers { + class_hash: class_hash_value, + } + } +} +#[derive(Drop, Copy)] +pub struct IDojoInitLibraryDispatcherSubPointersMut { + pub class_hash: starknet::storage::StoragePointer>, +} +impl IDojoInitLibraryDispatcherSubPointersMutImpl of starknet::storage::SubPointersMut { + type SubPointersType = IDojoInitLibraryDispatcherSubPointersMut; + fn sub_pointers_mut(self: starknet::storage::StoragePointer>) -> IDojoInitLibraryDispatcherSubPointersMut { + let base_address = self.__storage_pointer_address__; + let mut current_offset = self.__storage_pointer_offset__; + let class_hash_value = starknet::storage::StoragePointer { + __storage_pointer_address__: base_address, + __storage_pointer_offset__: current_offset, + }; + IDojoInitLibraryDispatcherSubPointersMut { + class_hash: class_hash_value, + } + } +} +impl IDojoInitSafeLibraryDispatcherCopy of core::traits::Copy::; +impl IDojoInitSafeLibraryDispatcherDrop of core::traits::Drop::; +impl IDojoInitSafeLibraryDispatcherSerde of core::serde::Serde:: { + fn serialize(self: @IDojoInitSafeLibraryDispatcher, ref output: core::array::Array) { + core::serde::Serde::serialize(self.class_hash, ref output) + } + fn deserialize(ref serialized: core::array::Span) -> core::option::Option { + core::option::Option::Some(IDojoInitSafeLibraryDispatcher { + class_hash: core::serde::Serde::deserialize(ref serialized)?, + }) + } +} +impl StoreIDojoInitSafeLibraryDispatcher of starknet::Store:: { + fn read(address_domain: u32, base: starknet::storage_access::StorageBaseAddress) -> starknet::SyscallResult { + let class_hash = starknet::Store::::read(address_domain, base)?; + starknet::SyscallResult::Ok( + IDojoInitSafeLibraryDispatcher { + class_hash, + } + ) + } + fn write(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, value: IDojoInitSafeLibraryDispatcher) -> starknet::SyscallResult<()> { + starknet::Store::::write(address_domain, base, value.class_hash)?; + starknet::SyscallResult::Ok(()) + } + fn read_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8) -> starknet::SyscallResult { + let class_hash = starknet::Store::::read_at_offset(address_domain, base, offset)?; + starknet::SyscallResult::Ok( + IDojoInitSafeLibraryDispatcher { + class_hash, + } + ) + } + #[inline(always)] + fn write_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8, value: IDojoInitSafeLibraryDispatcher) -> starknet::SyscallResult<()> { + starknet::Store::::write_at_offset(address_domain, base, offset, value.class_hash)?; + starknet::SyscallResult::Ok(()) + } + #[inline(always)] + fn size() -> u8 { + starknet::Store::::size() + } +} + +#[derive(Drop, Copy)] +pub struct IDojoInitSafeLibraryDispatcherSubPointers { + pub class_hash: starknet::storage::StoragePointer, +} +impl IDojoInitSafeLibraryDispatcherSubPointersImpl of starknet::storage::SubPointers { + type SubPointersType = IDojoInitSafeLibraryDispatcherSubPointers; + fn sub_pointers(self: starknet::storage::StoragePointer) -> IDojoInitSafeLibraryDispatcherSubPointers { + let base_address = self.__storage_pointer_address__; + let mut current_offset = self.__storage_pointer_offset__; + let class_hash_value = starknet::storage::StoragePointer { + __storage_pointer_address__: base_address, + __storage_pointer_offset__: current_offset, + }; + IDojoInitSafeLibraryDispatcherSubPointers { + class_hash: class_hash_value, + } + } +} +#[derive(Drop, Copy)] +pub struct IDojoInitSafeLibraryDispatcherSubPointersMut { + pub class_hash: starknet::storage::StoragePointer>, +} +impl IDojoInitSafeLibraryDispatcherSubPointersMutImpl of starknet::storage::SubPointersMut { + type SubPointersType = IDojoInitSafeLibraryDispatcherSubPointersMut; + fn sub_pointers_mut(self: starknet::storage::StoragePointer>) -> IDojoInitSafeLibraryDispatcherSubPointersMut { + let base_address = self.__storage_pointer_address__; + let mut current_offset = self.__storage_pointer_offset__; + let class_hash_value = starknet::storage::StoragePointer { + __storage_pointer_address__: base_address, + __storage_pointer_offset__: current_offset, + }; + IDojoInitSafeLibraryDispatcherSubPointersMut { + class_hash: class_hash_value, + } + } +} +impl IDojoInitSafeDispatcherCopy of core::traits::Copy::; +impl IDojoInitSafeDispatcherDrop of core::traits::Drop::; +impl IDojoInitSafeDispatcherSerde of core::serde::Serde:: { + fn serialize(self: @IDojoInitSafeDispatcher, ref output: core::array::Array) { + core::serde::Serde::serialize(self.contract_address, ref output) + } + fn deserialize(ref serialized: core::array::Span) -> core::option::Option { + core::option::Option::Some(IDojoInitSafeDispatcher { + contract_address: core::serde::Serde::deserialize(ref serialized)?, + }) + } +} +impl StoreIDojoInitSafeDispatcher of starknet::Store:: { + fn read(address_domain: u32, base: starknet::storage_access::StorageBaseAddress) -> starknet::SyscallResult { + let contract_address = starknet::Store::::read(address_domain, base)?; + starknet::SyscallResult::Ok( + IDojoInitSafeDispatcher { + contract_address, + } + ) + } + fn write(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, value: IDojoInitSafeDispatcher) -> starknet::SyscallResult<()> { + starknet::Store::::write(address_domain, base, value.contract_address)?; + starknet::SyscallResult::Ok(()) + } + fn read_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8) -> starknet::SyscallResult { + let contract_address = starknet::Store::::read_at_offset(address_domain, base, offset)?; + starknet::SyscallResult::Ok( + IDojoInitSafeDispatcher { + contract_address, + } + ) + } + #[inline(always)] + fn write_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8, value: IDojoInitSafeDispatcher) -> starknet::SyscallResult<()> { + starknet::Store::::write_at_offset(address_domain, base, offset, value.contract_address)?; + starknet::SyscallResult::Ok(()) + } + #[inline(always)] + fn size() -> u8 { + starknet::Store::::size() + } +} + +#[derive(Drop, Copy)] +pub struct IDojoInitSafeDispatcherSubPointers { + pub contract_address: starknet::storage::StoragePointer, +} +impl IDojoInitSafeDispatcherSubPointersImpl of starknet::storage::SubPointers { + type SubPointersType = IDojoInitSafeDispatcherSubPointers; + fn sub_pointers(self: starknet::storage::StoragePointer) -> IDojoInitSafeDispatcherSubPointers { + let base_address = self.__storage_pointer_address__; + let mut current_offset = self.__storage_pointer_offset__; + let contract_address_value = starknet::storage::StoragePointer { + __storage_pointer_address__: base_address, + __storage_pointer_offset__: current_offset, + }; + IDojoInitSafeDispatcherSubPointers { + contract_address: contract_address_value, + } + } +} +#[derive(Drop, Copy)] +pub struct IDojoInitSafeDispatcherSubPointersMut { + pub contract_address: starknet::storage::StoragePointer>, +} +impl IDojoInitSafeDispatcherSubPointersMutImpl of starknet::storage::SubPointersMut { + type SubPointersType = IDojoInitSafeDispatcherSubPointersMut; + fn sub_pointers_mut(self: starknet::storage::StoragePointer>) -> IDojoInitSafeDispatcherSubPointersMut { + let base_address = self.__storage_pointer_address__; + let mut current_offset = self.__storage_pointer_offset__; + let contract_address_value = starknet::storage::StoragePointer { + __storage_pointer_address__: base_address, + __storage_pointer_offset__: current_offset, + }; + IDojoInitSafeDispatcherSubPointersMut { + contract_address: contract_address_value, + } + } +} +impl StorageStorageBaseDrop of core::traits::Drop::; +impl StorageStorageBaseCopy of core::traits::Copy::; +impl StorageStorageBaseMutDrop of core::traits::Drop::; +impl StorageStorageBaseMutCopy of core::traits::Copy::; +impl IDojoInitDispatcherSubPointersDrop of core::traits::Drop::; +impl IDojoInitDispatcherSubPointersCopy of core::traits::Copy::; +impl IDojoInitDispatcherSubPointersMutDrop of core::traits::Drop::; +impl IDojoInitDispatcherSubPointersMutCopy of core::traits::Copy::; +impl IDojoInitLibraryDispatcherSubPointersDrop of core::traits::Drop::; +impl IDojoInitLibraryDispatcherSubPointersCopy of core::traits::Copy::; +impl IDojoInitLibraryDispatcherSubPointersMutDrop of core::traits::Drop::; +impl IDojoInitLibraryDispatcherSubPointersMutCopy of core::traits::Copy::; +impl IDojoInitSafeLibraryDispatcherSubPointersDrop of core::traits::Drop::; +impl IDojoInitSafeLibraryDispatcherSubPointersCopy of core::traits::Copy::; +impl IDojoInitSafeLibraryDispatcherSubPointersMutDrop of core::traits::Drop::; +impl IDojoInitSafeLibraryDispatcherSubPointersMutCopy of core::traits::Copy::; +impl IDojoInitSafeDispatcherSubPointersDrop of core::traits::Drop::; +impl IDojoInitSafeDispatcherSubPointersCopy of core::traits::Copy::; +impl IDojoInitSafeDispatcherSubPointersMutDrop of core::traits::Drop::; +impl IDojoInitSafeDispatcherSubPointersMutCopy of core::traits::Copy::; + + } + + #[starknet::contract] + pub mod withcomponent { + use dojo::world; + use dojo::world::IWorldDispatcher; + use dojo::world::IWorldDispatcherTrait; + use dojo::world::IWorldProvider; + use dojo::contract::IContract; + use starknet::storage::{ + StorageMapReadAccess, StorageMapWriteAccess, StoragePointerReadAccess, StoragePointerWriteAccess + }; + + #[abi(embed_v0)] + pub impl ContractImpl of IContract { + fn name(self: @ContractState) -> ByteArray { + "withcomponent" + } + + fn namespace(self: @ContractState) -> ByteArray { + "dojo_test" + } + + fn tag(self: @ContractState) -> ByteArray { + "dojo_test-withcomponent" + } + + fn name_hash(self: @ContractState) -> felt252 { + 999850881662666048155666650426666132968026605763740651763663703103974774091 + } + + fn namespace_hash(self: @ContractState) -> felt252 { + 1452123528942907587532668415362544424816022573043154497385993678618948064048 + } + + fn selector(self: @ContractState) -> felt252 { + 3051237314154062498758064027519150695325862034415997374893619833554034627226 + } + } + + #[abi(embed_v0)] + impl WorldProviderImpl of IWorldProvider { + fn world(self: @ContractState) -> IWorldDispatcher { + self.world_dispatcher.read() + } + } + + #[abi(embed_v0)] + impl UpgradableImpl = dojo::contract::upgradeable::upgradeable::UpgradableImpl; + + #[event] + #[derive(Drop, starknet::Event)] + enum Event { + UpgradeableEvent: dojo::contract::upgradeable::upgradeable::Event, + #[flat] + testcomponent1_event: testcomponent1::Event, + testcomponent2_event: testcomponent2::Event + } + + #[starknet::interface] + pub trait IDojoInit { + fn dojo_init(self: @ContractState); + } + + #[abi(embed_v0)] + pub impl IDojoInitImpl of IDojoInit { + fn dojo_init(self: @ContractState) { + if starknet::get_caller_address() != self.world().contract_address { + core::panics::panic_with_byte_array( + @format!("Only the world can init contract `{}`, but caller is `{:?}`", + self.tag(), + starknet::get_caller_address(), + )); + } + } + } + + +#[phantom] +pub struct Storage { + pub world_dispatcher: IWorldDispatcher, + #[substorage(v0)] + pub upgradeable: dojo::contract::upgradeable::upgradeable::Storage, + #[substorage(v0)] + pub testcomponent1_storage: testcomponent1::Storage, + #[substorage(v0)] + pub testcomponent2_storage: testcomponent2::Storage, +} + +#[derive(Drop, Copy)] +pub struct StorageStorageBase { + pub world_dispatcher: starknet::storage::StorageBase, + pub upgradeable: starknet::storage::FlattenedStorage, + pub testcomponent1_storage: starknet::storage::FlattenedStorage, + pub testcomponent2_storage: starknet::storage::FlattenedStorage, +} +impl StorageStorageImpl of starknet::storage::StorageTrait { + type BaseType = StorageStorageBase; + fn storage(self: starknet::storage::FlattenedStorage) -> StorageStorageBase { + let world_dispatcher_value = starknet::storage::StorageBase {__base_address__: selector!("world_dispatcher")}; + let upgradeable_value = starknet::storage::FlattenedStorage {}; + let testcomponent1_storage_value = starknet::storage::FlattenedStorage {}; + let testcomponent2_storage_value = starknet::storage::FlattenedStorage {}; + StorageStorageBase { + world_dispatcher: world_dispatcher_value, + upgradeable: upgradeable_value, + testcomponent1_storage: testcomponent1_storage_value, + testcomponent2_storage: testcomponent2_storage_value, + } + } +} +#[derive(Drop, Copy)] +pub struct StorageStorageBaseMut { + pub world_dispatcher: starknet::storage::StorageBase>, + pub upgradeable: starknet::storage::FlattenedStorage>, + pub testcomponent1_storage: starknet::storage::FlattenedStorage>, + pub testcomponent2_storage: starknet::storage::FlattenedStorage>, +} +impl StorageStorageMutImpl of starknet::storage::StorageTraitMut { + type BaseType = StorageStorageBaseMut; + fn storage_mut(self: starknet::storage::FlattenedStorage>) -> StorageStorageBaseMut { + let world_dispatcher_value = starknet::storage::StorageBase {__base_address__: selector!("world_dispatcher")}; + let upgradeable_value = starknet::storage::FlattenedStorage {}; + let testcomponent1_storage_value = starknet::storage::FlattenedStorage {}; + let testcomponent2_storage_value = starknet::storage::FlattenedStorage {}; + StorageStorageBaseMut { + world_dispatcher: world_dispatcher_value, + upgradeable: upgradeable_value, + testcomponent1_storage: testcomponent1_storage_value, + testcomponent2_storage: testcomponent2_storage_value, + } + } +} + +pub struct ContractState { + pub upgradeable: dojo::contract::upgradeable::upgradeable::ComponentState, + pub testcomponent1_storage: testcomponent1::ComponentState, + pub testcomponent2_storage: testcomponent2::ComponentState, +} + +impl ContractStateDrop of Drop {} + +impl ContractStateDeref of core::ops::SnapshotDeref { + type Target = starknet::storage::FlattenedStorage; + fn snapshot_deref(self: @ContractState) -> starknet::storage::FlattenedStorage { + starknet::storage::FlattenedStorage {} + } +} +impl ContractStateDerefMut of core::ops::DerefMut { + type Target = starknet::storage::FlattenedStorage> ; + fn deref_mut(ref self: ContractState) -> starknet::storage::FlattenedStorage> { + starknet::storage::FlattenedStorage {} + } +} +pub fn unsafe_new_contract_state() -> ContractState { + ContractState { + upgradeable: dojo::contract::upgradeable::upgradeable::unsafe_new_component_state::(), + testcomponent1_storage: testcomponent1::unsafe_new_component_state::(), + testcomponent2_storage: testcomponent2::unsafe_new_component_state::(), + } +} + +// TODO(Gil): This generates duplicate diagnostics because of the plugin system, squash the duplicates into one. +#[deprecated( + feature: "deprecated_legacy_map", + note: "Use `starknet::storage::Map` instead." +)] +use starknet::storage::Map as LegacyMap; + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__ContractImpl__name(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = ContractImpl::name(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__ContractImpl__namespace(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = ContractImpl::namespace(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__ContractImpl__tag(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = ContractImpl::tag(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__ContractImpl__name_hash(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = ContractImpl::name_hash(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__ContractImpl__namespace_hash(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = ContractImpl::namespace_hash(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__ContractImpl__selector(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = ContractImpl::selector(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__WorldProviderImpl__world(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = WorldProviderImpl::world(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +impl ContractStateUpgradableImpl of + dojo::contract::upgradeable::upgradeable::UnsafeNewContractStateTraitForUpgradableImpl { + fn unsafe_new_contract_state() -> ContractState { + unsafe_new_contract_state() + } +} +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__IDojoInitImpl__dojo_init(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + IDojoInitImpl::dojo_init(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::array::ArrayTrait::span(@arr) +} + + +pub mod __external { + pub use super::__wrapper__ContractImpl__name as name; + pub use super::__wrapper__ContractImpl__namespace as namespace; + pub use super::__wrapper__ContractImpl__tag as tag; + pub use super::__wrapper__ContractImpl__name_hash as name_hash; + pub use super::__wrapper__ContractImpl__namespace_hash as namespace_hash; + pub use super::__wrapper__ContractImpl__selector as selector; + pub use super::__wrapper__WorldProviderImpl__world as world; + pub use super::__wrapper__IDojoInitImpl__dojo_init as dojo_init; +} +pub mod __l1_handler { +} +pub mod __constructor { +} + impl ContractStateEventEmitter of starknet::event::EventEmitter< + ContractState, Event + > { + fn emit>( + ref self: ContractState, event: S + ) { + let event: Event = core::traits::Into::into(event); + let mut keys = Default::::default(); + let mut data = Default::::default(); + starknet::Event::append_keys_and_data(@event, ref keys, ref data); + starknet::SyscallResultTrait::unwrap_syscall( + starknet::syscalls::emit_event_syscall( + core::array::ArrayTrait::span(@keys), + core::array::ArrayTrait::span(@data), + ) + ) + } + } + +impl HasComponentImpl_upgradeable of dojo::contract::upgradeable::upgradeable::HasComponent { + fn get_component(self: @ContractState) -> @dojo::contract::upgradeable::upgradeable::ComponentState { + @dojo::contract::upgradeable::upgradeable::unsafe_new_component_state::() + } + fn get_component_mut(ref self: ContractState) -> dojo::contract::upgradeable::upgradeable::ComponentState { + dojo::contract::upgradeable::upgradeable::unsafe_new_component_state::() + } + fn get_contract(self: @dojo::contract::upgradeable::upgradeable::ComponentState) -> @ContractState { + @unsafe_new_contract_state() + } + fn get_contract_mut(ref self: dojo::contract::upgradeable::upgradeable::ComponentState) -> ContractState { + unsafe_new_contract_state() + } + fn emit>(ref self: dojo::contract::upgradeable::upgradeable::ComponentState, event: S) { + let event: dojo::contract::upgradeable::upgradeable::Event = core::traits::Into::into(event); + let mut contract = dojo::contract::upgradeable::upgradeable::HasComponent::get_contract_mut(ref self); + ContractStateEventEmitter::emit(ref contract, Event::UpgradeableEvent(event)); + } +} +impl HasComponentImpl_testcomponent1 of testcomponent1::HasComponent { + fn get_component(self: @ContractState) -> @testcomponent1::ComponentState { + @testcomponent1::unsafe_new_component_state::() + } + fn get_component_mut(ref self: ContractState) -> testcomponent1::ComponentState { + testcomponent1::unsafe_new_component_state::() + } + fn get_contract(self: @testcomponent1::ComponentState) -> @ContractState { + @unsafe_new_contract_state() + } + fn get_contract_mut(ref self: testcomponent1::ComponentState) -> ContractState { + unsafe_new_contract_state() + } + fn emit>(ref self: testcomponent1::ComponentState, event: S) { + let event: testcomponent1::Event = core::traits::Into::into(event); + let mut contract = testcomponent1::HasComponent::get_contract_mut(ref self); + ContractStateEventEmitter::emit(ref contract, Event::testcomponent1_event(event)); + } +} +impl HasComponentImpl_testcomponent2 of testcomponent2::HasComponent { + fn get_component(self: @ContractState) -> @testcomponent2::ComponentState { + @testcomponent2::unsafe_new_component_state::() + } + fn get_component_mut(ref self: ContractState) -> testcomponent2::ComponentState { + testcomponent2::unsafe_new_component_state::() + } + fn get_contract(self: @testcomponent2::ComponentState) -> @ContractState { + @unsafe_new_contract_state() + } + fn get_contract_mut(ref self: testcomponent2::ComponentState) -> ContractState { + unsafe_new_contract_state() + } + fn emit>(ref self: testcomponent2::ComponentState, event: S) { + let event: testcomponent2::Event = core::traits::Into::into(event); + let mut contract = testcomponent2::HasComponent::get_contract_mut(ref self); + ContractStateEventEmitter::emit(ref contract, Event::testcomponent2_event(event)); + } +} +impl EventDrop of core::traits::Drop::; +impl EventIsEvent of starknet::Event { + fn append_keys_and_data( + self: @Event, ref keys: Array, ref data: Array + ) { + match self { + Event::UpgradeableEvent(val) => { + core::array::ArrayTrait::append(ref keys, selector!("UpgradeableEvent")); + starknet::Event::append_keys_and_data( + val, ref keys, ref data + ); + }, + Event::testcomponent1_event(val) => { + starknet::Event::append_keys_and_data( + val, ref keys, ref data + ); + }, + Event::testcomponent2_event(val) => { + core::array::ArrayTrait::append(ref keys, selector!("testcomponent2_event")); + starknet::Event::append_keys_and_data( + val, ref keys, ref data + ); + }, + } + } + fn deserialize( + ref keys: Span, ref data: Span, + ) -> Option { + { + let mut keys = keys; + let mut data = data; + match starknet::Event::deserialize(ref keys, ref data) { + Option::Some(val) => { + return Option::Some(Event::testcomponent1_event(val)); + }, + Option::None => {}, + }; + } + let __selector__ = *core::array::SpanTrait::pop_front(ref keys)?; + if __selector__ == selector!("UpgradeableEvent") { + let val = starknet::Event::deserialize( + ref keys, ref data + )?; + return Option::Some(Event::UpgradeableEvent(val)); + } + if __selector__ == selector!("testcomponent2_event") { + let val = starknet::Event::deserialize( + ref keys, ref data + )?; + return Option::Some(Event::testcomponent2_event(val)); + } + Option::None + } +} +impl EventUpgradeableEventIntoEvent of Into { + fn into(self: dojo::contract::upgradeable::upgradeable::Event) -> Event { + Event::UpgradeableEvent(self) + } +} +impl Eventtestcomponent1_eventIntoEvent of Into { + fn into(self: testcomponent1::Event) -> Event { + Event::testcomponent1_event(self) + } +} +impl Eventtestcomponent2_eventIntoEvent of Into { + fn into(self: testcomponent2::Event) -> Event { + Event::testcomponent2_event(self) + } +} + pub trait IDojoInitDispatcherTrait { + fn dojo_init(self: T); +} + +#[derive(Copy, Drop, starknet::Store, Serde)] + pub struct IDojoInitDispatcher { + pub contract_address: starknet::ContractAddress, +} + +impl IDojoInitDispatcherImpl of IDojoInitDispatcherTrait { + fn dojo_init(self: IDojoInitDispatcher) { + let mut __calldata__ = core::traits::Default::default(); + + let mut __dispatcher_return_data__ = starknet::syscalls::call_contract_syscall( + self.contract_address, + selector!("dojo_init"), + core::array::ArrayTrait::span(@__calldata__), + ); + let mut __dispatcher_return_data__ = starknet::SyscallResultTrait::unwrap_syscall(__dispatcher_return_data__); + () + } + +} + +#[derive(Copy, Drop, starknet::Store, Serde)] + pub struct IDojoInitLibraryDispatcher { + pub class_hash: starknet::ClassHash, +} + +impl IDojoInitLibraryDispatcherImpl of IDojoInitDispatcherTrait { + fn dojo_init(self: IDojoInitLibraryDispatcher) { + let mut __calldata__ = core::traits::Default::default(); + + let mut __dispatcher_return_data__ = starknet::syscalls::library_call_syscall( + self.class_hash, + selector!("dojo_init"), + core::array::ArrayTrait::span(@__calldata__), + ); + let mut __dispatcher_return_data__ = starknet::SyscallResultTrait::unwrap_syscall(__dispatcher_return_data__); + () + } + +} + + pub trait IDojoInitSafeDispatcherTrait { + #[unstable(feature: "safe_dispatcher")] + fn dojo_init(self: T) -> starknet::SyscallResult<()>; +} + +#[derive(Copy, Drop, starknet::Store, Serde)] + pub struct IDojoInitSafeLibraryDispatcher { + pub class_hash: starknet::ClassHash, +} + +impl IDojoInitSafeLibraryDispatcherImpl of IDojoInitSafeDispatcherTrait { + fn dojo_init(self: IDojoInitSafeLibraryDispatcher) -> starknet::SyscallResult<()> { + let mut __calldata__ = core::traits::Default::default(); + + let mut __dispatcher_return_data__ = starknet::syscalls::library_call_syscall( + self.class_hash, + selector!("dojo_init"), + core::array::ArrayTrait::span(@__calldata__), + ); + let mut __dispatcher_return_data__ = __dispatcher_return_data__?; + Result::Ok(()) + } + +} + + +#[derive(Copy, Drop, starknet::Store, Serde)] + pub struct IDojoInitSafeDispatcher { + pub contract_address: starknet::ContractAddress, +} + +impl IDojoInitSafeDispatcherImpl of IDojoInitSafeDispatcherTrait { + fn dojo_init(self: IDojoInitSafeDispatcher) -> starknet::SyscallResult<()> { + let mut __calldata__ = core::traits::Default::default(); + + let mut __dispatcher_return_data__ = starknet::syscalls::call_contract_syscall( + self.contract_address, + selector!("dojo_init"), + core::array::ArrayTrait::span(@__calldata__), + ); + let mut __dispatcher_return_data__ = __dispatcher_return_data__?; + Result::Ok(()) + } + +} +impl StorageStorageBaseDrop of core::traits::Drop::; +impl StorageStorageBaseCopy of core::traits::Copy::; +impl StorageStorageBaseMutDrop of core::traits::Drop::; +impl StorageStorageBaseMutCopy of core::traits::Copy::; +impl IDojoInitDispatcherCopy of core::traits::Copy::; +impl IDojoInitDispatcherDrop of core::traits::Drop::; +impl IDojoInitDispatcherSerde of core::serde::Serde:: { + fn serialize(self: @IDojoInitDispatcher, ref output: core::array::Array) { + core::serde::Serde::serialize(self.contract_address, ref output) + } + fn deserialize(ref serialized: core::array::Span) -> core::option::Option { + core::option::Option::Some(IDojoInitDispatcher { + contract_address: core::serde::Serde::deserialize(ref serialized)?, + }) + } +} +impl StoreIDojoInitDispatcher of starknet::Store:: { + fn read(address_domain: u32, base: starknet::storage_access::StorageBaseAddress) -> starknet::SyscallResult { + let contract_address = starknet::Store::::read(address_domain, base)?; + starknet::SyscallResult::Ok( + IDojoInitDispatcher { + contract_address, + } + ) + } + fn write(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, value: IDojoInitDispatcher) -> starknet::SyscallResult<()> { + starknet::Store::::write(address_domain, base, value.contract_address)?; + starknet::SyscallResult::Ok(()) + } + fn read_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8) -> starknet::SyscallResult { + let contract_address = starknet::Store::::read_at_offset(address_domain, base, offset)?; + starknet::SyscallResult::Ok( + IDojoInitDispatcher { + contract_address, + } + ) + } + #[inline(always)] + fn write_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8, value: IDojoInitDispatcher) -> starknet::SyscallResult<()> { + starknet::Store::::write_at_offset(address_domain, base, offset, value.contract_address)?; + starknet::SyscallResult::Ok(()) + } + #[inline(always)] + fn size() -> u8 { + starknet::Store::::size() + } +} + +#[derive(Drop, Copy)] +pub struct IDojoInitDispatcherSubPointers { + pub contract_address: starknet::storage::StoragePointer, +} +impl IDojoInitDispatcherSubPointersImpl of starknet::storage::SubPointers { + type SubPointersType = IDojoInitDispatcherSubPointers; + fn sub_pointers(self: starknet::storage::StoragePointer) -> IDojoInitDispatcherSubPointers { + let base_address = self.__storage_pointer_address__; + let mut current_offset = self.__storage_pointer_offset__; + let contract_address_value = starknet::storage::StoragePointer { + __storage_pointer_address__: base_address, + __storage_pointer_offset__: current_offset, + }; + IDojoInitDispatcherSubPointers { + contract_address: contract_address_value, + } + } +} +#[derive(Drop, Copy)] +pub struct IDojoInitDispatcherSubPointersMut { + pub contract_address: starknet::storage::StoragePointer>, +} +impl IDojoInitDispatcherSubPointersMutImpl of starknet::storage::SubPointersMut { + type SubPointersType = IDojoInitDispatcherSubPointersMut; + fn sub_pointers_mut(self: starknet::storage::StoragePointer>) -> IDojoInitDispatcherSubPointersMut { + let base_address = self.__storage_pointer_address__; + let mut current_offset = self.__storage_pointer_offset__; + let contract_address_value = starknet::storage::StoragePointer { + __storage_pointer_address__: base_address, + __storage_pointer_offset__: current_offset, + }; + IDojoInitDispatcherSubPointersMut { + contract_address: contract_address_value, + } + } +} +impl IDojoInitLibraryDispatcherCopy of core::traits::Copy::; +impl IDojoInitLibraryDispatcherDrop of core::traits::Drop::; +impl IDojoInitLibraryDispatcherSerde of core::serde::Serde:: { + fn serialize(self: @IDojoInitLibraryDispatcher, ref output: core::array::Array) { + core::serde::Serde::serialize(self.class_hash, ref output) + } + fn deserialize(ref serialized: core::array::Span) -> core::option::Option { + core::option::Option::Some(IDojoInitLibraryDispatcher { + class_hash: core::serde::Serde::deserialize(ref serialized)?, + }) + } +} +impl StoreIDojoInitLibraryDispatcher of starknet::Store:: { + fn read(address_domain: u32, base: starknet::storage_access::StorageBaseAddress) -> starknet::SyscallResult { + let class_hash = starknet::Store::::read(address_domain, base)?; + starknet::SyscallResult::Ok( + IDojoInitLibraryDispatcher { + class_hash, + } + ) + } + fn write(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, value: IDojoInitLibraryDispatcher) -> starknet::SyscallResult<()> { + starknet::Store::::write(address_domain, base, value.class_hash)?; + starknet::SyscallResult::Ok(()) + } + fn read_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8) -> starknet::SyscallResult { + let class_hash = starknet::Store::::read_at_offset(address_domain, base, offset)?; + starknet::SyscallResult::Ok( + IDojoInitLibraryDispatcher { + class_hash, + } + ) + } + #[inline(always)] + fn write_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8, value: IDojoInitLibraryDispatcher) -> starknet::SyscallResult<()> { + starknet::Store::::write_at_offset(address_domain, base, offset, value.class_hash)?; + starknet::SyscallResult::Ok(()) + } + #[inline(always)] + fn size() -> u8 { + starknet::Store::::size() + } +} + +#[derive(Drop, Copy)] +pub struct IDojoInitLibraryDispatcherSubPointers { + pub class_hash: starknet::storage::StoragePointer, +} +impl IDojoInitLibraryDispatcherSubPointersImpl of starknet::storage::SubPointers { + type SubPointersType = IDojoInitLibraryDispatcherSubPointers; + fn sub_pointers(self: starknet::storage::StoragePointer) -> IDojoInitLibraryDispatcherSubPointers { + let base_address = self.__storage_pointer_address__; + let mut current_offset = self.__storage_pointer_offset__; + let class_hash_value = starknet::storage::StoragePointer { + __storage_pointer_address__: base_address, + __storage_pointer_offset__: current_offset, + }; + IDojoInitLibraryDispatcherSubPointers { + class_hash: class_hash_value, + } + } +} +#[derive(Drop, Copy)] +pub struct IDojoInitLibraryDispatcherSubPointersMut { + pub class_hash: starknet::storage::StoragePointer>, +} +impl IDojoInitLibraryDispatcherSubPointersMutImpl of starknet::storage::SubPointersMut { + type SubPointersType = IDojoInitLibraryDispatcherSubPointersMut; + fn sub_pointers_mut(self: starknet::storage::StoragePointer>) -> IDojoInitLibraryDispatcherSubPointersMut { + let base_address = self.__storage_pointer_address__; + let mut current_offset = self.__storage_pointer_offset__; + let class_hash_value = starknet::storage::StoragePointer { + __storage_pointer_address__: base_address, + __storage_pointer_offset__: current_offset, + }; + IDojoInitLibraryDispatcherSubPointersMut { + class_hash: class_hash_value, + } + } +} +impl IDojoInitSafeLibraryDispatcherCopy of core::traits::Copy::; +impl IDojoInitSafeLibraryDispatcherDrop of core::traits::Drop::; +impl IDojoInitSafeLibraryDispatcherSerde of core::serde::Serde:: { + fn serialize(self: @IDojoInitSafeLibraryDispatcher, ref output: core::array::Array) { + core::serde::Serde::serialize(self.class_hash, ref output) + } + fn deserialize(ref serialized: core::array::Span) -> core::option::Option { + core::option::Option::Some(IDojoInitSafeLibraryDispatcher { + class_hash: core::serde::Serde::deserialize(ref serialized)?, + }) + } +} +impl StoreIDojoInitSafeLibraryDispatcher of starknet::Store:: { + fn read(address_domain: u32, base: starknet::storage_access::StorageBaseAddress) -> starknet::SyscallResult { + let class_hash = starknet::Store::::read(address_domain, base)?; + starknet::SyscallResult::Ok( + IDojoInitSafeLibraryDispatcher { + class_hash, + } + ) + } + fn write(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, value: IDojoInitSafeLibraryDispatcher) -> starknet::SyscallResult<()> { + starknet::Store::::write(address_domain, base, value.class_hash)?; + starknet::SyscallResult::Ok(()) + } + fn read_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8) -> starknet::SyscallResult { + let class_hash = starknet::Store::::read_at_offset(address_domain, base, offset)?; + starknet::SyscallResult::Ok( + IDojoInitSafeLibraryDispatcher { + class_hash, + } + ) + } + #[inline(always)] + fn write_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8, value: IDojoInitSafeLibraryDispatcher) -> starknet::SyscallResult<()> { + starknet::Store::::write_at_offset(address_domain, base, offset, value.class_hash)?; + starknet::SyscallResult::Ok(()) + } + #[inline(always)] + fn size() -> u8 { + starknet::Store::::size() + } +} + +#[derive(Drop, Copy)] +pub struct IDojoInitSafeLibraryDispatcherSubPointers { + pub class_hash: starknet::storage::StoragePointer, +} +impl IDojoInitSafeLibraryDispatcherSubPointersImpl of starknet::storage::SubPointers { + type SubPointersType = IDojoInitSafeLibraryDispatcherSubPointers; + fn sub_pointers(self: starknet::storage::StoragePointer) -> IDojoInitSafeLibraryDispatcherSubPointers { + let base_address = self.__storage_pointer_address__; + let mut current_offset = self.__storage_pointer_offset__; + let class_hash_value = starknet::storage::StoragePointer { + __storage_pointer_address__: base_address, + __storage_pointer_offset__: current_offset, + }; + IDojoInitSafeLibraryDispatcherSubPointers { + class_hash: class_hash_value, + } + } +} +#[derive(Drop, Copy)] +pub struct IDojoInitSafeLibraryDispatcherSubPointersMut { + pub class_hash: starknet::storage::StoragePointer>, +} +impl IDojoInitSafeLibraryDispatcherSubPointersMutImpl of starknet::storage::SubPointersMut { + type SubPointersType = IDojoInitSafeLibraryDispatcherSubPointersMut; + fn sub_pointers_mut(self: starknet::storage::StoragePointer>) -> IDojoInitSafeLibraryDispatcherSubPointersMut { + let base_address = self.__storage_pointer_address__; + let mut current_offset = self.__storage_pointer_offset__; + let class_hash_value = starknet::storage::StoragePointer { + __storage_pointer_address__: base_address, + __storage_pointer_offset__: current_offset, + }; + IDojoInitSafeLibraryDispatcherSubPointersMut { + class_hash: class_hash_value, + } + } +} +impl IDojoInitSafeDispatcherCopy of core::traits::Copy::; +impl IDojoInitSafeDispatcherDrop of core::traits::Drop::; +impl IDojoInitSafeDispatcherSerde of core::serde::Serde:: { + fn serialize(self: @IDojoInitSafeDispatcher, ref output: core::array::Array) { + core::serde::Serde::serialize(self.contract_address, ref output) + } + fn deserialize(ref serialized: core::array::Span) -> core::option::Option { + core::option::Option::Some(IDojoInitSafeDispatcher { + contract_address: core::serde::Serde::deserialize(ref serialized)?, + }) + } +} +impl StoreIDojoInitSafeDispatcher of starknet::Store:: { + fn read(address_domain: u32, base: starknet::storage_access::StorageBaseAddress) -> starknet::SyscallResult { + let contract_address = starknet::Store::::read(address_domain, base)?; + starknet::SyscallResult::Ok( + IDojoInitSafeDispatcher { + contract_address, + } + ) + } + fn write(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, value: IDojoInitSafeDispatcher) -> starknet::SyscallResult<()> { + starknet::Store::::write(address_domain, base, value.contract_address)?; + starknet::SyscallResult::Ok(()) + } + fn read_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8) -> starknet::SyscallResult { + let contract_address = starknet::Store::::read_at_offset(address_domain, base, offset)?; + starknet::SyscallResult::Ok( + IDojoInitSafeDispatcher { + contract_address, + } + ) + } + #[inline(always)] + fn write_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8, value: IDojoInitSafeDispatcher) -> starknet::SyscallResult<()> { + starknet::Store::::write_at_offset(address_domain, base, offset, value.contract_address)?; + starknet::SyscallResult::Ok(()) + } + #[inline(always)] + fn size() -> u8 { + starknet::Store::::size() + } +} + +#[derive(Drop, Copy)] +pub struct IDojoInitSafeDispatcherSubPointers { + pub contract_address: starknet::storage::StoragePointer, +} +impl IDojoInitSafeDispatcherSubPointersImpl of starknet::storage::SubPointers { + type SubPointersType = IDojoInitSafeDispatcherSubPointers; + fn sub_pointers(self: starknet::storage::StoragePointer) -> IDojoInitSafeDispatcherSubPointers { + let base_address = self.__storage_pointer_address__; + let mut current_offset = self.__storage_pointer_offset__; + let contract_address_value = starknet::storage::StoragePointer { + __storage_pointer_address__: base_address, + __storage_pointer_offset__: current_offset, + }; + IDojoInitSafeDispatcherSubPointers { + contract_address: contract_address_value, + } + } +} +#[derive(Drop, Copy)] +pub struct IDojoInitSafeDispatcherSubPointersMut { + pub contract_address: starknet::storage::StoragePointer>, +} +impl IDojoInitSafeDispatcherSubPointersMutImpl of starknet::storage::SubPointersMut { + type SubPointersType = IDojoInitSafeDispatcherSubPointersMut; + fn sub_pointers_mut(self: starknet::storage::StoragePointer>) -> IDojoInitSafeDispatcherSubPointersMut { + let base_address = self.__storage_pointer_address__; + let mut current_offset = self.__storage_pointer_offset__; + let contract_address_value = starknet::storage::StoragePointer { + __storage_pointer_address__: base_address, + __storage_pointer_offset__: current_offset, + }; + IDojoInitSafeDispatcherSubPointersMut { + contract_address: contract_address_value, + } + } +} +impl IDojoInitDispatcherSubPointersDrop of core::traits::Drop::; +impl IDojoInitDispatcherSubPointersCopy of core::traits::Copy::; +impl IDojoInitDispatcherSubPointersMutDrop of core::traits::Drop::; +impl IDojoInitDispatcherSubPointersMutCopy of core::traits::Copy::; +impl IDojoInitLibraryDispatcherSubPointersDrop of core::traits::Drop::; +impl IDojoInitLibraryDispatcherSubPointersCopy of core::traits::Copy::; +impl IDojoInitLibraryDispatcherSubPointersMutDrop of core::traits::Drop::; +impl IDojoInitLibraryDispatcherSubPointersMutCopy of core::traits::Copy::; +impl IDojoInitSafeLibraryDispatcherSubPointersDrop of core::traits::Drop::; +impl IDojoInitSafeLibraryDispatcherSubPointersCopy of core::traits::Copy::; +impl IDojoInitSafeLibraryDispatcherSubPointersMutDrop of core::traits::Drop::; +impl IDojoInitSafeLibraryDispatcherSubPointersMutCopy of core::traits::Copy::; +impl IDojoInitSafeDispatcherSubPointersDrop of core::traits::Drop::; +impl IDojoInitSafeDispatcherSubPointersCopy of core::traits::Copy::; +impl IDojoInitSafeDispatcherSubPointersMutDrop of core::traits::Drop::; +impl IDojoInitSafeDispatcherSubPointersMutCopy of core::traits::Copy::; + + } + + #[starknet::interface] + pub trait IEmptyTrait {} + + #[starknet::interface] + pub trait IFaultyTrait { + fn do_with_attrs(self: @TContractState, p1: u8) -> u16; + } + + #[starknet::interface] + pub trait INominalTrait { + fn do_no_param(self: @TContractState) -> felt252;fn do_no_param_but_world(self: @TContractState) -> felt252;fn do_no_param_but_world_ref(ref self: TContractState) -> felt252;fn do_params_no_world(self: @TContractState, p1: felt252, p2: u8) -> felt252;fn do_params_and_world(self: @TContractState, p2: u8) -> felt252;fn do_params_and_world_ref(ref self: TContractState, p2: u8) -> felt252;fn do_with_self(self: @ContractState) -> felt252;fn do_with_ref_self(ref self: ContractState) -> felt252; + } + + #[starknet::interface] + pub trait IFaultyTrait { + fn do_with_self_and_world(self: @ContractState, world: @IWorldDispatcher) -> felt252;fn do_with_ref_self_and_world(ref self: ContractState, ref world: IWorldDispatcher) -> felt252;fn do_with_self_and_world_inv(self: @TContractState, self: @ContractState) -> felt252;fn do_with_ref_self_and_world_inv(ref self: TContractState, ref self: ContractState +) -> felt252;fn do_with_several_world_dispatchers(self: @TContractState, vec: Vec2, ref another_world: IWorldDispatcher +) -> felt252;fn do_with_world_not_named_world(self: @TContractState, another_world: @IWorldDispatcher) -> felt252;fn do_with_world_not_first(self: @TContractState, vec: Vec2, ref world: IWorldDispatcher) -> felt252; + } + + #[starknet::contract] + pub mod MyFaultyContract { + use dojo::world; + use dojo::world::IWorldDispatcher; + use dojo::world::IWorldDispatcherTrait; + use dojo::world::IWorldProvider; + use dojo::contract::IContract; + use starknet::storage::{ + StorageMapReadAccess, StorageMapWriteAccess, StoragePointerReadAccess, StoragePointerWriteAccess + }; + + #[abi(embed_v0)] + pub impl ContractImpl of IContract { + fn name(self: @ContractState) -> ByteArray { + "MyFaultyContract" + } + + fn namespace(self: @ContractState) -> ByteArray { + "dojo_test" + } + + fn tag(self: @ContractState) -> ByteArray { + "dojo_test-MyFaultyContract" + } + + fn name_hash(self: @ContractState) -> felt252 { + 3439743807865759203015037013733809315384408083697880336790137144257764256358 + } + + fn namespace_hash(self: @ContractState) -> felt252 { + 1452123528942907587532668415362544424816022573043154497385993678618948064048 + } + + fn selector(self: @ContractState) -> felt252 { + 3304414327641815709216225681190245445308480446755012097234787467696641395890 + } + } + + #[abi(embed_v0)] + impl WorldProviderImpl of IWorldProvider { + fn world(self: @ContractState) -> IWorldDispatcher { + self.world_dispatcher.read() + } + } + + #[abi(embed_v0)] + impl UpgradableImpl = dojo::contract::upgradeable::upgradeable::UpgradableImpl; + + #[abi(embed_v0)] + impl TestFaultyImpl of IFaultyTrait {fn do_with_self_and_world(self: @ContractState) -> felt252 { 'land' +}fn do_with_ref_self_and_world( ref self: ContractState) -> felt252 { 'land' +}fn do_with_self_and_world_inv(self: @ContractState, self: @ContractState) -> felt252 {let world = self.world_dispatcher.read(); 'land' +}fn do_with_ref_self_and_world_inv(ref self: ContractState, ref self: ContractState +) -> felt252 {let world = self.world_dispatcher.read(); 'land' +}fn do_with_several_world_dispatchers(self: @ContractState, vec: Vec2, ref another_world: IWorldDispatcher +) -> felt252 {let world = self.world_dispatcher.read(); 'land' +}fn do_with_world_not_named_world(self: @ContractState, another_world: @IWorldDispatcher) -> felt252 { 'land' +}fn do_with_world_not_first(self: @ContractState, vec: Vec2) -> felt252 { 'land' +}} + #[generate_trait] + impl InternalImplBad of InternalUtils {fn bad_func_using_generate(self: @ContractState) -> felt252 {let world = self.world_dispatcher.read(); 'land' +}} + #[starknet::interface] + pub trait IDojoInit { + fn dojo_init(self: @ContractState); + } + + #[abi(embed_v0)] + pub impl IDojoInitImpl of IDojoInit { + fn dojo_init(self: @ContractState) { + if starknet::get_caller_address() != self.world().contract_address { + core::panics::panic_with_byte_array( + @format!("Only the world can init contract `{}`, but caller is `{:?}`", + self.tag(), + starknet::get_caller_address(), + )); + } + } + } + + #[event] + #[derive(Drop, starknet::Event)] + enum Event { + UpgradeableEvent: dojo::contract::upgradeable::upgradeable::Event, + } + trait InternalUtils{fn bad_func_using_generate(self: @ContractState) -> felt252; +} + pub trait IDojoInitDispatcherTrait { + fn dojo_init(self: T); +} + +#[derive(Copy, Drop, starknet::Store, Serde)] + pub struct IDojoInitDispatcher { + pub contract_address: starknet::ContractAddress, +} + +impl IDojoInitDispatcherImpl of IDojoInitDispatcherTrait { + fn dojo_init(self: IDojoInitDispatcher) { + let mut __calldata__ = core::traits::Default::default(); + + let mut __dispatcher_return_data__ = starknet::syscalls::call_contract_syscall( + self.contract_address, + selector!("dojo_init"), + core::array::ArrayTrait::span(@__calldata__), + ); + let mut __dispatcher_return_data__ = starknet::SyscallResultTrait::unwrap_syscall(__dispatcher_return_data__); + () + } + +} + +#[derive(Copy, Drop, starknet::Store, Serde)] + pub struct IDojoInitLibraryDispatcher { + pub class_hash: starknet::ClassHash, +} + +impl IDojoInitLibraryDispatcherImpl of IDojoInitDispatcherTrait { + fn dojo_init(self: IDojoInitLibraryDispatcher) { + let mut __calldata__ = core::traits::Default::default(); + + let mut __dispatcher_return_data__ = starknet::syscalls::library_call_syscall( + self.class_hash, + selector!("dojo_init"), + core::array::ArrayTrait::span(@__calldata__), + ); + let mut __dispatcher_return_data__ = starknet::SyscallResultTrait::unwrap_syscall(__dispatcher_return_data__); + () + } + +} + + pub trait IDojoInitSafeDispatcherTrait { + #[unstable(feature: "safe_dispatcher")] + fn dojo_init(self: T) -> starknet::SyscallResult<()>; +} + +#[derive(Copy, Drop, starknet::Store, Serde)] + pub struct IDojoInitSafeLibraryDispatcher { + pub class_hash: starknet::ClassHash, +} + +impl IDojoInitSafeLibraryDispatcherImpl of IDojoInitSafeDispatcherTrait { + fn dojo_init(self: IDojoInitSafeLibraryDispatcher) -> starknet::SyscallResult<()> { + let mut __calldata__ = core::traits::Default::default(); + + let mut __dispatcher_return_data__ = starknet::syscalls::library_call_syscall( + self.class_hash, + selector!("dojo_init"), + core::array::ArrayTrait::span(@__calldata__), + ); + let mut __dispatcher_return_data__ = __dispatcher_return_data__?; + Result::Ok(()) + } + +} + + +#[derive(Copy, Drop, starknet::Store, Serde)] + pub struct IDojoInitSafeDispatcher { + pub contract_address: starknet::ContractAddress, +} + +impl IDojoInitSafeDispatcherImpl of IDojoInitSafeDispatcherTrait { + fn dojo_init(self: IDojoInitSafeDispatcher) -> starknet::SyscallResult<()> { + let mut __calldata__ = core::traits::Default::default(); + + let mut __dispatcher_return_data__ = starknet::syscalls::call_contract_syscall( + self.contract_address, + selector!("dojo_init"), + core::array::ArrayTrait::span(@__calldata__), + ); + let mut __dispatcher_return_data__ = __dispatcher_return_data__?; + Result::Ok(()) + } + +} +impl EventDrop of core::traits::Drop::; +impl EventIsEvent of starknet::Event { + fn append_keys_and_data( + self: @Event, ref keys: Array, ref data: Array + ) { + match self { + Event::UpgradeableEvent(val) => { + core::array::ArrayTrait::append(ref keys, selector!("UpgradeableEvent")); + starknet::Event::append_keys_and_data( + val, ref keys, ref data + ); + }, + } + } + fn deserialize( + ref keys: Span, ref data: Span, + ) -> Option { + let __selector__ = *core::array::SpanTrait::pop_front(ref keys)?; + if __selector__ == selector!("UpgradeableEvent") { + let val = starknet::Event::deserialize( + ref keys, ref data + )?; + return Option::Some(Event::UpgradeableEvent(val)); + } + Option::None + } +} +impl EventUpgradeableEventIntoEvent of Into { + fn into(self: dojo::contract::upgradeable::upgradeable::Event) -> Event { + Event::UpgradeableEvent(self) + } +} + + +#[phantom] +pub struct Storage { + pub world_dispatcher: IWorldDispatcher, + #[substorage(v0)] + pub upgradeable: dojo::contract::upgradeable::upgradeable::Storage, +} + +#[derive(Drop, Copy)] +pub struct StorageStorageBase { + pub world_dispatcher: starknet::storage::StorageBase, + pub upgradeable: starknet::storage::FlattenedStorage, +} +impl StorageStorageImpl of starknet::storage::StorageTrait { + type BaseType = StorageStorageBase; + fn storage(self: starknet::storage::FlattenedStorage) -> StorageStorageBase { + let world_dispatcher_value = starknet::storage::StorageBase {__base_address__: selector!("world_dispatcher")}; + let upgradeable_value = starknet::storage::FlattenedStorage {}; + StorageStorageBase { + world_dispatcher: world_dispatcher_value, + upgradeable: upgradeable_value, + } + } +} +#[derive(Drop, Copy)] +pub struct StorageStorageBaseMut { + pub world_dispatcher: starknet::storage::StorageBase>, + pub upgradeable: starknet::storage::FlattenedStorage>, +} +impl StorageStorageMutImpl of starknet::storage::StorageTraitMut { + type BaseType = StorageStorageBaseMut; + fn storage_mut(self: starknet::storage::FlattenedStorage>) -> StorageStorageBaseMut { + let world_dispatcher_value = starknet::storage::StorageBase {__base_address__: selector!("world_dispatcher")}; + let upgradeable_value = starknet::storage::FlattenedStorage {}; + StorageStorageBaseMut { + world_dispatcher: world_dispatcher_value, + upgradeable: upgradeable_value, + } + } +} + +pub struct ContractState { + pub upgradeable: dojo::contract::upgradeable::upgradeable::ComponentState, +} + +impl ContractStateDrop of Drop {} + +impl ContractStateDeref of core::ops::SnapshotDeref { + type Target = starknet::storage::FlattenedStorage; + fn snapshot_deref(self: @ContractState) -> starknet::storage::FlattenedStorage { + starknet::storage::FlattenedStorage {} + } +} +impl ContractStateDerefMut of core::ops::DerefMut { + type Target = starknet::storage::FlattenedStorage> ; + fn deref_mut(ref self: ContractState) -> starknet::storage::FlattenedStorage> { + starknet::storage::FlattenedStorage {} + } +} +pub fn unsafe_new_contract_state() -> ContractState { + ContractState { + upgradeable: dojo::contract::upgradeable::upgradeable::unsafe_new_component_state::(), + } +} + +// TODO(Gil): This generates duplicate diagnostics because of the plugin system, squash the duplicates into one. +#[deprecated( + feature: "deprecated_legacy_map", + note: "Use `starknet::storage::Map` instead." +)] +use starknet::storage::Map as LegacyMap; + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__ContractImpl__name(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = ContractImpl::name(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__ContractImpl__namespace(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = ContractImpl::namespace(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__ContractImpl__tag(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = ContractImpl::tag(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__ContractImpl__name_hash(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = ContractImpl::name_hash(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__ContractImpl__namespace_hash(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = ContractImpl::namespace_hash(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__ContractImpl__selector(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = ContractImpl::selector(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__WorldProviderImpl__world(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = WorldProviderImpl::world(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +impl ContractStateUpgradableImpl of + dojo::contract::upgradeable::upgradeable::UnsafeNewContractStateTraitForUpgradableImpl { + fn unsafe_new_contract_state() -> ContractState { + unsafe_new_contract_state() + } +} +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__TestFaultyImpl__do_with_self_and_world(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = TestFaultyImpl::do_with_self_and_world(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__TestFaultyImpl__do_with_ref_self_and_world(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = TestFaultyImpl::do_with_ref_self_and_world(ref contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__TestFaultyImpl__do_with_self_and_world_inv(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + let __arg_self = core::option::OptionTraitImpl::expect( + core::serde::Serde::<@ContractState>::deserialize(ref data), + 'Failed to deserialize param #1' + ); + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = TestFaultyImpl::do_with_self_and_world_inv(@contract_state, __arg_self); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__TestFaultyImpl__do_with_ref_self_and_world_inv(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + let mut __arg_self = core::option::OptionTraitImpl::expect( + core::serde::Serde::::deserialize(ref data), + 'Failed to deserialize param #1' + ); + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = TestFaultyImpl::do_with_ref_self_and_world_inv(ref contract_state, ref __arg_self); + let mut arr = ArrayTrait::new(); + // References. + core::serde::Serde::::serialize(@__arg_self, ref arr); + // Result. + core::serde::Serde::::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__TestFaultyImpl__do_with_several_world_dispatchers(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + let __arg_vec = core::option::OptionTraitImpl::expect( + core::serde::Serde::::deserialize(ref data), + 'Failed to deserialize param #1' + ); + let mut __arg_another_world = core::option::OptionTraitImpl::expect( + core::serde::Serde::::deserialize(ref data), + 'Failed to deserialize param #2' + ); + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = TestFaultyImpl::do_with_several_world_dispatchers(@contract_state, __arg_vec, ref __arg_another_world); + let mut arr = ArrayTrait::new(); + // References. + core::serde::Serde::::serialize(@__arg_another_world, ref arr); + // Result. + core::serde::Serde::::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__TestFaultyImpl__do_with_world_not_named_world(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + let __arg_another_world = core::option::OptionTraitImpl::expect( + core::serde::Serde::<@IWorldDispatcher>::deserialize(ref data), + 'Failed to deserialize param #1' + ); + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = TestFaultyImpl::do_with_world_not_named_world(@contract_state, __arg_another_world); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__TestFaultyImpl__do_with_world_not_first(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + let __arg_vec = core::option::OptionTraitImpl::expect( + core::serde::Serde::::deserialize(ref data), + 'Failed to deserialize param #1' + ); + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = TestFaultyImpl::do_with_world_not_first(@contract_state, __arg_vec); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__IDojoInitImpl__dojo_init(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + IDojoInitImpl::dojo_init(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::array::ArrayTrait::span(@arr) +} + + +pub mod __external { + pub use super::__wrapper__ContractImpl__name as name; + pub use super::__wrapper__ContractImpl__namespace as namespace; + pub use super::__wrapper__ContractImpl__tag as tag; + pub use super::__wrapper__ContractImpl__name_hash as name_hash; + pub use super::__wrapper__ContractImpl__namespace_hash as namespace_hash; + pub use super::__wrapper__ContractImpl__selector as selector; + pub use super::__wrapper__WorldProviderImpl__world as world; + pub use super::__wrapper__TestFaultyImpl__do_with_self_and_world as do_with_self_and_world; + pub use super::__wrapper__TestFaultyImpl__do_with_ref_self_and_world as do_with_ref_self_and_world; + pub use super::__wrapper__TestFaultyImpl__do_with_self_and_world_inv as do_with_self_and_world_inv; + pub use super::__wrapper__TestFaultyImpl__do_with_ref_self_and_world_inv as do_with_ref_self_and_world_inv; + pub use super::__wrapper__TestFaultyImpl__do_with_several_world_dispatchers as do_with_several_world_dispatchers; + pub use super::__wrapper__TestFaultyImpl__do_with_world_not_named_world as do_with_world_not_named_world; + pub use super::__wrapper__TestFaultyImpl__do_with_world_not_first as do_with_world_not_first; + pub use super::__wrapper__IDojoInitImpl__dojo_init as dojo_init; +} +pub mod __l1_handler { +} +pub mod __constructor { +} + impl ContractStateEventEmitter of starknet::event::EventEmitter< + ContractState, Event + > { + fn emit>( + ref self: ContractState, event: S + ) { + let event: Event = core::traits::Into::into(event); + let mut keys = Default::::default(); + let mut data = Default::::default(); + starknet::Event::append_keys_and_data(@event, ref keys, ref data); + starknet::SyscallResultTrait::unwrap_syscall( + starknet::syscalls::emit_event_syscall( + core::array::ArrayTrait::span(@keys), + core::array::ArrayTrait::span(@data), + ) + ) + } + } + +impl HasComponentImpl_upgradeable of dojo::contract::upgradeable::upgradeable::HasComponent { + fn get_component(self: @ContractState) -> @dojo::contract::upgradeable::upgradeable::ComponentState { + @dojo::contract::upgradeable::upgradeable::unsafe_new_component_state::() + } + fn get_component_mut(ref self: ContractState) -> dojo::contract::upgradeable::upgradeable::ComponentState { + dojo::contract::upgradeable::upgradeable::unsafe_new_component_state::() + } + fn get_contract(self: @dojo::contract::upgradeable::upgradeable::ComponentState) -> @ContractState { + @unsafe_new_contract_state() + } + fn get_contract_mut(ref self: dojo::contract::upgradeable::upgradeable::ComponentState) -> ContractState { + unsafe_new_contract_state() + } + fn emit>(ref self: dojo::contract::upgradeable::upgradeable::ComponentState, event: S) { + let event: dojo::contract::upgradeable::upgradeable::Event = core::traits::Into::into(event); + let mut contract = dojo::contract::upgradeable::upgradeable::HasComponent::get_contract_mut(ref self); + ContractStateEventEmitter::emit(ref contract, Event::UpgradeableEvent(event)); + } +} +impl IDojoInitDispatcherCopy of core::traits::Copy::; +impl IDojoInitDispatcherDrop of core::traits::Drop::; +impl IDojoInitDispatcherSerde of core::serde::Serde:: { + fn serialize(self: @IDojoInitDispatcher, ref output: core::array::Array) { + core::serde::Serde::serialize(self.contract_address, ref output) + } + fn deserialize(ref serialized: core::array::Span) -> core::option::Option { + core::option::Option::Some(IDojoInitDispatcher { + contract_address: core::serde::Serde::deserialize(ref serialized)?, + }) + } +} +impl StoreIDojoInitDispatcher of starknet::Store:: { + fn read(address_domain: u32, base: starknet::storage_access::StorageBaseAddress) -> starknet::SyscallResult { + let contract_address = starknet::Store::::read(address_domain, base)?; + starknet::SyscallResult::Ok( + IDojoInitDispatcher { + contract_address, + } + ) + } + fn write(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, value: IDojoInitDispatcher) -> starknet::SyscallResult<()> { + starknet::Store::::write(address_domain, base, value.contract_address)?; + starknet::SyscallResult::Ok(()) + } + fn read_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8) -> starknet::SyscallResult { + let contract_address = starknet::Store::::read_at_offset(address_domain, base, offset)?; + starknet::SyscallResult::Ok( + IDojoInitDispatcher { + contract_address, + } + ) + } + #[inline(always)] + fn write_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8, value: IDojoInitDispatcher) -> starknet::SyscallResult<()> { + starknet::Store::::write_at_offset(address_domain, base, offset, value.contract_address)?; + starknet::SyscallResult::Ok(()) + } + #[inline(always)] + fn size() -> u8 { + starknet::Store::::size() + } +} + +#[derive(Drop, Copy)] +pub struct IDojoInitDispatcherSubPointers { + pub contract_address: starknet::storage::StoragePointer, +} +impl IDojoInitDispatcherSubPointersImpl of starknet::storage::SubPointers { + type SubPointersType = IDojoInitDispatcherSubPointers; + fn sub_pointers(self: starknet::storage::StoragePointer) -> IDojoInitDispatcherSubPointers { + let base_address = self.__storage_pointer_address__; + let mut current_offset = self.__storage_pointer_offset__; + let contract_address_value = starknet::storage::StoragePointer { + __storage_pointer_address__: base_address, + __storage_pointer_offset__: current_offset, + }; + IDojoInitDispatcherSubPointers { + contract_address: contract_address_value, + } + } +} +#[derive(Drop, Copy)] +pub struct IDojoInitDispatcherSubPointersMut { + pub contract_address: starknet::storage::StoragePointer>, +} +impl IDojoInitDispatcherSubPointersMutImpl of starknet::storage::SubPointersMut { + type SubPointersType = IDojoInitDispatcherSubPointersMut; + fn sub_pointers_mut(self: starknet::storage::StoragePointer>) -> IDojoInitDispatcherSubPointersMut { + let base_address = self.__storage_pointer_address__; + let mut current_offset = self.__storage_pointer_offset__; + let contract_address_value = starknet::storage::StoragePointer { + __storage_pointer_address__: base_address, + __storage_pointer_offset__: current_offset, + }; + IDojoInitDispatcherSubPointersMut { + contract_address: contract_address_value, + } + } +} +impl IDojoInitLibraryDispatcherCopy of core::traits::Copy::; +impl IDojoInitLibraryDispatcherDrop of core::traits::Drop::; +impl IDojoInitLibraryDispatcherSerde of core::serde::Serde:: { + fn serialize(self: @IDojoInitLibraryDispatcher, ref output: core::array::Array) { + core::serde::Serde::serialize(self.class_hash, ref output) + } + fn deserialize(ref serialized: core::array::Span) -> core::option::Option { + core::option::Option::Some(IDojoInitLibraryDispatcher { + class_hash: core::serde::Serde::deserialize(ref serialized)?, + }) + } +} +impl StoreIDojoInitLibraryDispatcher of starknet::Store:: { + fn read(address_domain: u32, base: starknet::storage_access::StorageBaseAddress) -> starknet::SyscallResult { + let class_hash = starknet::Store::::read(address_domain, base)?; + starknet::SyscallResult::Ok( + IDojoInitLibraryDispatcher { + class_hash, + } + ) + } + fn write(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, value: IDojoInitLibraryDispatcher) -> starknet::SyscallResult<()> { + starknet::Store::::write(address_domain, base, value.class_hash)?; + starknet::SyscallResult::Ok(()) + } + fn read_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8) -> starknet::SyscallResult { + let class_hash = starknet::Store::::read_at_offset(address_domain, base, offset)?; + starknet::SyscallResult::Ok( + IDojoInitLibraryDispatcher { + class_hash, + } + ) + } + #[inline(always)] + fn write_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8, value: IDojoInitLibraryDispatcher) -> starknet::SyscallResult<()> { + starknet::Store::::write_at_offset(address_domain, base, offset, value.class_hash)?; + starknet::SyscallResult::Ok(()) + } + #[inline(always)] + fn size() -> u8 { + starknet::Store::::size() + } +} + +#[derive(Drop, Copy)] +pub struct IDojoInitLibraryDispatcherSubPointers { + pub class_hash: starknet::storage::StoragePointer, +} +impl IDojoInitLibraryDispatcherSubPointersImpl of starknet::storage::SubPointers { + type SubPointersType = IDojoInitLibraryDispatcherSubPointers; + fn sub_pointers(self: starknet::storage::StoragePointer) -> IDojoInitLibraryDispatcherSubPointers { + let base_address = self.__storage_pointer_address__; + let mut current_offset = self.__storage_pointer_offset__; + let class_hash_value = starknet::storage::StoragePointer { + __storage_pointer_address__: base_address, + __storage_pointer_offset__: current_offset, + }; + IDojoInitLibraryDispatcherSubPointers { + class_hash: class_hash_value, + } + } +} +#[derive(Drop, Copy)] +pub struct IDojoInitLibraryDispatcherSubPointersMut { + pub class_hash: starknet::storage::StoragePointer>, +} +impl IDojoInitLibraryDispatcherSubPointersMutImpl of starknet::storage::SubPointersMut { + type SubPointersType = IDojoInitLibraryDispatcherSubPointersMut; + fn sub_pointers_mut(self: starknet::storage::StoragePointer>) -> IDojoInitLibraryDispatcherSubPointersMut { + let base_address = self.__storage_pointer_address__; + let mut current_offset = self.__storage_pointer_offset__; + let class_hash_value = starknet::storage::StoragePointer { + __storage_pointer_address__: base_address, + __storage_pointer_offset__: current_offset, + }; + IDojoInitLibraryDispatcherSubPointersMut { + class_hash: class_hash_value, + } + } +} +impl IDojoInitSafeLibraryDispatcherCopy of core::traits::Copy::; +impl IDojoInitSafeLibraryDispatcherDrop of core::traits::Drop::; +impl IDojoInitSafeLibraryDispatcherSerde of core::serde::Serde:: { + fn serialize(self: @IDojoInitSafeLibraryDispatcher, ref output: core::array::Array) { + core::serde::Serde::serialize(self.class_hash, ref output) + } + fn deserialize(ref serialized: core::array::Span) -> core::option::Option { + core::option::Option::Some(IDojoInitSafeLibraryDispatcher { + class_hash: core::serde::Serde::deserialize(ref serialized)?, + }) + } +} +impl StoreIDojoInitSafeLibraryDispatcher of starknet::Store:: { + fn read(address_domain: u32, base: starknet::storage_access::StorageBaseAddress) -> starknet::SyscallResult { + let class_hash = starknet::Store::::read(address_domain, base)?; + starknet::SyscallResult::Ok( + IDojoInitSafeLibraryDispatcher { + class_hash, + } + ) + } + fn write(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, value: IDojoInitSafeLibraryDispatcher) -> starknet::SyscallResult<()> { + starknet::Store::::write(address_domain, base, value.class_hash)?; + starknet::SyscallResult::Ok(()) + } + fn read_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8) -> starknet::SyscallResult { + let class_hash = starknet::Store::::read_at_offset(address_domain, base, offset)?; + starknet::SyscallResult::Ok( + IDojoInitSafeLibraryDispatcher { + class_hash, + } + ) + } + #[inline(always)] + fn write_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8, value: IDojoInitSafeLibraryDispatcher) -> starknet::SyscallResult<()> { + starknet::Store::::write_at_offset(address_domain, base, offset, value.class_hash)?; + starknet::SyscallResult::Ok(()) + } + #[inline(always)] + fn size() -> u8 { + starknet::Store::::size() + } +} + +#[derive(Drop, Copy)] +pub struct IDojoInitSafeLibraryDispatcherSubPointers { + pub class_hash: starknet::storage::StoragePointer, +} +impl IDojoInitSafeLibraryDispatcherSubPointersImpl of starknet::storage::SubPointers { + type SubPointersType = IDojoInitSafeLibraryDispatcherSubPointers; + fn sub_pointers(self: starknet::storage::StoragePointer) -> IDojoInitSafeLibraryDispatcherSubPointers { + let base_address = self.__storage_pointer_address__; + let mut current_offset = self.__storage_pointer_offset__; + let class_hash_value = starknet::storage::StoragePointer { + __storage_pointer_address__: base_address, + __storage_pointer_offset__: current_offset, + }; + IDojoInitSafeLibraryDispatcherSubPointers { + class_hash: class_hash_value, + } + } +} +#[derive(Drop, Copy)] +pub struct IDojoInitSafeLibraryDispatcherSubPointersMut { + pub class_hash: starknet::storage::StoragePointer>, +} +impl IDojoInitSafeLibraryDispatcherSubPointersMutImpl of starknet::storage::SubPointersMut { + type SubPointersType = IDojoInitSafeLibraryDispatcherSubPointersMut; + fn sub_pointers_mut(self: starknet::storage::StoragePointer>) -> IDojoInitSafeLibraryDispatcherSubPointersMut { + let base_address = self.__storage_pointer_address__; + let mut current_offset = self.__storage_pointer_offset__; + let class_hash_value = starknet::storage::StoragePointer { + __storage_pointer_address__: base_address, + __storage_pointer_offset__: current_offset, + }; + IDojoInitSafeLibraryDispatcherSubPointersMut { + class_hash: class_hash_value, + } + } +} +impl IDojoInitSafeDispatcherCopy of core::traits::Copy::; +impl IDojoInitSafeDispatcherDrop of core::traits::Drop::; +impl IDojoInitSafeDispatcherSerde of core::serde::Serde:: { + fn serialize(self: @IDojoInitSafeDispatcher, ref output: core::array::Array) { + core::serde::Serde::serialize(self.contract_address, ref output) + } + fn deserialize(ref serialized: core::array::Span) -> core::option::Option { + core::option::Option::Some(IDojoInitSafeDispatcher { + contract_address: core::serde::Serde::deserialize(ref serialized)?, + }) + } +} +impl StoreIDojoInitSafeDispatcher of starknet::Store:: { + fn read(address_domain: u32, base: starknet::storage_access::StorageBaseAddress) -> starknet::SyscallResult { + let contract_address = starknet::Store::::read(address_domain, base)?; + starknet::SyscallResult::Ok( + IDojoInitSafeDispatcher { + contract_address, + } + ) + } + fn write(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, value: IDojoInitSafeDispatcher) -> starknet::SyscallResult<()> { + starknet::Store::::write(address_domain, base, value.contract_address)?; + starknet::SyscallResult::Ok(()) + } + fn read_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8) -> starknet::SyscallResult { + let contract_address = starknet::Store::::read_at_offset(address_domain, base, offset)?; + starknet::SyscallResult::Ok( + IDojoInitSafeDispatcher { + contract_address, + } + ) + } + #[inline(always)] + fn write_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8, value: IDojoInitSafeDispatcher) -> starknet::SyscallResult<()> { + starknet::Store::::write_at_offset(address_domain, base, offset, value.contract_address)?; + starknet::SyscallResult::Ok(()) + } + #[inline(always)] + fn size() -> u8 { + starknet::Store::::size() + } +} + +#[derive(Drop, Copy)] +pub struct IDojoInitSafeDispatcherSubPointers { + pub contract_address: starknet::storage::StoragePointer, +} +impl IDojoInitSafeDispatcherSubPointersImpl of starknet::storage::SubPointers { + type SubPointersType = IDojoInitSafeDispatcherSubPointers; + fn sub_pointers(self: starknet::storage::StoragePointer) -> IDojoInitSafeDispatcherSubPointers { + let base_address = self.__storage_pointer_address__; + let mut current_offset = self.__storage_pointer_offset__; + let contract_address_value = starknet::storage::StoragePointer { + __storage_pointer_address__: base_address, + __storage_pointer_offset__: current_offset, + }; + IDojoInitSafeDispatcherSubPointers { + contract_address: contract_address_value, + } + } +} +#[derive(Drop, Copy)] +pub struct IDojoInitSafeDispatcherSubPointersMut { + pub contract_address: starknet::storage::StoragePointer>, +} +impl IDojoInitSafeDispatcherSubPointersMutImpl of starknet::storage::SubPointersMut { + type SubPointersType = IDojoInitSafeDispatcherSubPointersMut; + fn sub_pointers_mut(self: starknet::storage::StoragePointer>) -> IDojoInitSafeDispatcherSubPointersMut { + let base_address = self.__storage_pointer_address__; + let mut current_offset = self.__storage_pointer_offset__; + let contract_address_value = starknet::storage::StoragePointer { + __storage_pointer_address__: base_address, + __storage_pointer_offset__: current_offset, + }; + IDojoInitSafeDispatcherSubPointersMut { + contract_address: contract_address_value, + } + } +} +impl StorageStorageBaseDrop of core::traits::Drop::; +impl StorageStorageBaseCopy of core::traits::Copy::; +impl StorageStorageBaseMutDrop of core::traits::Drop::; +impl StorageStorageBaseMutCopy of core::traits::Copy::; +impl IDojoInitDispatcherSubPointersDrop of core::traits::Drop::; +impl IDojoInitDispatcherSubPointersCopy of core::traits::Copy::; +impl IDojoInitDispatcherSubPointersMutDrop of core::traits::Drop::; +impl IDojoInitDispatcherSubPointersMutCopy of core::traits::Copy::; +impl IDojoInitLibraryDispatcherSubPointersDrop of core::traits::Drop::; +impl IDojoInitLibraryDispatcherSubPointersCopy of core::traits::Copy::; +impl IDojoInitLibraryDispatcherSubPointersMutDrop of core::traits::Drop::; +impl IDojoInitLibraryDispatcherSubPointersMutCopy of core::traits::Copy::; +impl IDojoInitSafeLibraryDispatcherSubPointersDrop of core::traits::Drop::; +impl IDojoInitSafeLibraryDispatcherSubPointersCopy of core::traits::Copy::; +impl IDojoInitSafeLibraryDispatcherSubPointersMutDrop of core::traits::Drop::; +impl IDojoInitSafeLibraryDispatcherSubPointersMutCopy of core::traits::Copy::; +impl IDojoInitSafeDispatcherSubPointersDrop of core::traits::Drop::; +impl IDojoInitSafeDispatcherSubPointersCopy of core::traits::Copy::; +impl IDojoInitSafeDispatcherSubPointersMutDrop of core::traits::Drop::; +impl IDojoInitSafeDispatcherSubPointersMutCopy of core::traits::Copy::; + + } + + #[starknet::contract] + pub mod MyNominalContract { + use dojo::world; + use dojo::world::IWorldDispatcher; + use dojo::world::IWorldDispatcherTrait; + use dojo::world::IWorldProvider; + use dojo::contract::IContract; + use starknet::storage::{ + StorageMapReadAccess, StorageMapWriteAccess, StoragePointerReadAccess, StoragePointerWriteAccess + }; + + #[abi(embed_v0)] + pub impl ContractImpl of IContract { + fn name(self: @ContractState) -> ByteArray { + "MyNominalContract" + } + + fn namespace(self: @ContractState) -> ByteArray { + "dojo_test" + } + + fn tag(self: @ContractState) -> ByteArray { + "dojo_test-MyNominalContract" + } + + fn name_hash(self: @ContractState) -> felt252 { + 1172628497499445169993220559087829230676589931723677494032285307738203070578 + } + + fn namespace_hash(self: @ContractState) -> felt252 { + 1452123528942907587532668415362544424816022573043154497385993678618948064048 + } + + fn selector(self: @ContractState) -> felt252 { + 1466845198188516049094649763342542731381088471625065496527510975945391631525 + } + } + + #[abi(embed_v0)] + impl WorldProviderImpl of IWorldProvider { + fn world(self: @ContractState) -> IWorldDispatcher { + self.world_dispatcher.read() + } + } + + #[abi(embed_v0)] + impl UpgradableImpl = dojo::contract::upgradeable::upgradeable::UpgradableImpl; + + #[derive(Drop)] + struct Action { + damage: u8 + } + + #[abi(embed_v0)] + impl TestNominalImpl of INominalTrait {fn do_no_param(self: @ContractState) -> felt252 { 'land' +}fn do_no_param_but_world(self: @ContractState) -> felt252 {let world = self.world_dispatcher.read(); 'land' +}fn do_no_param_but_world_ref(ref self: ContractState) -> felt252 {let world = self.world_dispatcher.read(); 'land' +}fn do_params_no_world(self: @ContractState, p1: felt252, p2: u8) -> felt252 { 'land' +}fn do_params_and_world(self: @ContractState, p2: u8) -> felt252 {let world = self.world_dispatcher.read(); 'land' +}fn do_params_and_world_ref(ref self: ContractState, p2: u8) -> felt252 {let world = self.world_dispatcher.read(); 'land' +}fn do_with_self(self: @ContractState) -> felt252 { 'land' +}fn do_with_ref_self(ref self: ContractState) -> felt252 { 'land' +}} + #[generate_trait] + impl ImplInternalNoContractState of InternalNoContractState { + fn func1(world: IWorldDispatcher) -> felt252 { + let _w = world; + 42 + } + } + + #[starknet::interface] + pub trait IDojoInit { + fn dojo_init(self: @ContractState); + } + + #[abi(embed_v0)] + pub impl IDojoInitImpl of IDojoInit { + fn dojo_init(self: @ContractState) { + if starknet::get_caller_address() != self.world().contract_address { + core::panics::panic_with_byte_array( + @format!("Only the world can init contract `{}`, but caller is `{:?}`", + self.tag(), + starknet::get_caller_address(), + )); + } + } + } + + #[event] + #[derive(Drop, starknet::Event)] + enum Event { + UpgradeableEvent: dojo::contract::upgradeable::upgradeable::Event, + } +impl ActionDrop of core::traits::Drop::; + trait InternalNoContractState { + fn func1(world: IWorldDispatcher) -> felt252; + } + pub trait IDojoInitDispatcherTrait { + fn dojo_init(self: T); +} + +#[derive(Copy, Drop, starknet::Store, Serde)] + pub struct IDojoInitDispatcher { + pub contract_address: starknet::ContractAddress, +} + +impl IDojoInitDispatcherImpl of IDojoInitDispatcherTrait { + fn dojo_init(self: IDojoInitDispatcher) { + let mut __calldata__ = core::traits::Default::default(); + + let mut __dispatcher_return_data__ = starknet::syscalls::call_contract_syscall( + self.contract_address, + selector!("dojo_init"), + core::array::ArrayTrait::span(@__calldata__), + ); + let mut __dispatcher_return_data__ = starknet::SyscallResultTrait::unwrap_syscall(__dispatcher_return_data__); + () + } + +} + +#[derive(Copy, Drop, starknet::Store, Serde)] + pub struct IDojoInitLibraryDispatcher { + pub class_hash: starknet::ClassHash, +} + +impl IDojoInitLibraryDispatcherImpl of IDojoInitDispatcherTrait { + fn dojo_init(self: IDojoInitLibraryDispatcher) { + let mut __calldata__ = core::traits::Default::default(); + + let mut __dispatcher_return_data__ = starknet::syscalls::library_call_syscall( + self.class_hash, + selector!("dojo_init"), + core::array::ArrayTrait::span(@__calldata__), + ); + let mut __dispatcher_return_data__ = starknet::SyscallResultTrait::unwrap_syscall(__dispatcher_return_data__); + () + } + +} + + pub trait IDojoInitSafeDispatcherTrait { + #[unstable(feature: "safe_dispatcher")] + fn dojo_init(self: T) -> starknet::SyscallResult<()>; +} + +#[derive(Copy, Drop, starknet::Store, Serde)] + pub struct IDojoInitSafeLibraryDispatcher { + pub class_hash: starknet::ClassHash, +} + +impl IDojoInitSafeLibraryDispatcherImpl of IDojoInitSafeDispatcherTrait { + fn dojo_init(self: IDojoInitSafeLibraryDispatcher) -> starknet::SyscallResult<()> { + let mut __calldata__ = core::traits::Default::default(); + + let mut __dispatcher_return_data__ = starknet::syscalls::library_call_syscall( + self.class_hash, + selector!("dojo_init"), + core::array::ArrayTrait::span(@__calldata__), + ); + let mut __dispatcher_return_data__ = __dispatcher_return_data__?; + Result::Ok(()) + } + +} + + +#[derive(Copy, Drop, starknet::Store, Serde)] + pub struct IDojoInitSafeDispatcher { + pub contract_address: starknet::ContractAddress, +} + +impl IDojoInitSafeDispatcherImpl of IDojoInitSafeDispatcherTrait { + fn dojo_init(self: IDojoInitSafeDispatcher) -> starknet::SyscallResult<()> { + let mut __calldata__ = core::traits::Default::default(); + + let mut __dispatcher_return_data__ = starknet::syscalls::call_contract_syscall( + self.contract_address, + selector!("dojo_init"), + core::array::ArrayTrait::span(@__calldata__), + ); + let mut __dispatcher_return_data__ = __dispatcher_return_data__?; + Result::Ok(()) + } + +} +impl EventDrop of core::traits::Drop::; +impl EventIsEvent of starknet::Event { + fn append_keys_and_data( + self: @Event, ref keys: Array, ref data: Array + ) { + match self { + Event::UpgradeableEvent(val) => { + core::array::ArrayTrait::append(ref keys, selector!("UpgradeableEvent")); + starknet::Event::append_keys_and_data( + val, ref keys, ref data + ); + }, + } + } + fn deserialize( + ref keys: Span, ref data: Span, + ) -> Option { + let __selector__ = *core::array::SpanTrait::pop_front(ref keys)?; + if __selector__ == selector!("UpgradeableEvent") { + let val = starknet::Event::deserialize( + ref keys, ref data + )?; + return Option::Some(Event::UpgradeableEvent(val)); + } + Option::None + } +} +impl EventUpgradeableEventIntoEvent of Into { + fn into(self: dojo::contract::upgradeable::upgradeable::Event) -> Event { + Event::UpgradeableEvent(self) + } +} + + +#[phantom] +pub struct Storage { + pub world_dispatcher: IWorldDispatcher, + #[substorage(v0)] + pub upgradeable: dojo::contract::upgradeable::upgradeable::Storage, +} + +#[derive(Drop, Copy)] +pub struct StorageStorageBase { + pub world_dispatcher: starknet::storage::StorageBase, + pub upgradeable: starknet::storage::FlattenedStorage, +} +impl StorageStorageImpl of starknet::storage::StorageTrait { + type BaseType = StorageStorageBase; + fn storage(self: starknet::storage::FlattenedStorage) -> StorageStorageBase { + let world_dispatcher_value = starknet::storage::StorageBase {__base_address__: selector!("world_dispatcher")}; + let upgradeable_value = starknet::storage::FlattenedStorage {}; + StorageStorageBase { + world_dispatcher: world_dispatcher_value, + upgradeable: upgradeable_value, + } + } +} +#[derive(Drop, Copy)] +pub struct StorageStorageBaseMut { + pub world_dispatcher: starknet::storage::StorageBase>, + pub upgradeable: starknet::storage::FlattenedStorage>, +} +impl StorageStorageMutImpl of starknet::storage::StorageTraitMut { + type BaseType = StorageStorageBaseMut; + fn storage_mut(self: starknet::storage::FlattenedStorage>) -> StorageStorageBaseMut { + let world_dispatcher_value = starknet::storage::StorageBase {__base_address__: selector!("world_dispatcher")}; + let upgradeable_value = starknet::storage::FlattenedStorage {}; + StorageStorageBaseMut { + world_dispatcher: world_dispatcher_value, + upgradeable: upgradeable_value, + } + } +} + +pub struct ContractState { + pub upgradeable: dojo::contract::upgradeable::upgradeable::ComponentState, +} + +impl ContractStateDrop of Drop {} + +impl ContractStateDeref of core::ops::SnapshotDeref { + type Target = starknet::storage::FlattenedStorage; + fn snapshot_deref(self: @ContractState) -> starknet::storage::FlattenedStorage { + starknet::storage::FlattenedStorage {} + } +} +impl ContractStateDerefMut of core::ops::DerefMut { + type Target = starknet::storage::FlattenedStorage> ; + fn deref_mut(ref self: ContractState) -> starknet::storage::FlattenedStorage> { + starknet::storage::FlattenedStorage {} + } +} +pub fn unsafe_new_contract_state() -> ContractState { + ContractState { + upgradeable: dojo::contract::upgradeable::upgradeable::unsafe_new_component_state::(), + } +} + +// TODO(Gil): This generates duplicate diagnostics because of the plugin system, squash the duplicates into one. +#[deprecated( + feature: "deprecated_legacy_map", + note: "Use `starknet::storage::Map` instead." +)] +use starknet::storage::Map as LegacyMap; + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__ContractImpl__name(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = ContractImpl::name(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__ContractImpl__namespace(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = ContractImpl::namespace(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__ContractImpl__tag(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = ContractImpl::tag(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__ContractImpl__name_hash(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = ContractImpl::name_hash(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__ContractImpl__namespace_hash(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = ContractImpl::namespace_hash(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__ContractImpl__selector(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = ContractImpl::selector(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__WorldProviderImpl__world(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = WorldProviderImpl::world(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +impl ContractStateUpgradableImpl of + dojo::contract::upgradeable::upgradeable::UnsafeNewContractStateTraitForUpgradableImpl { + fn unsafe_new_contract_state() -> ContractState { + unsafe_new_contract_state() + } +} +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__TestNominalImpl__do_no_param(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = TestNominalImpl::do_no_param(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__TestNominalImpl__do_no_param_but_world(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = TestNominalImpl::do_no_param_but_world(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__TestNominalImpl__do_no_param_but_world_ref(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = TestNominalImpl::do_no_param_but_world_ref(ref contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__TestNominalImpl__do_params_no_world(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + let __arg_p1 = core::option::OptionTraitImpl::expect( + core::serde::Serde::::deserialize(ref data), + 'Failed to deserialize param #1' + ); + let __arg_p2 = core::option::OptionTraitImpl::expect( + core::serde::Serde::::deserialize(ref data), + 'Failed to deserialize param #2' + ); + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = TestNominalImpl::do_params_no_world(@contract_state, __arg_p1, __arg_p2); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__TestNominalImpl__do_params_and_world(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + let __arg_p2 = core::option::OptionTraitImpl::expect( + core::serde::Serde::::deserialize(ref data), + 'Failed to deserialize param #1' + ); + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = TestNominalImpl::do_params_and_world(@contract_state, __arg_p2); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__TestNominalImpl__do_params_and_world_ref(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + let __arg_p2 = core::option::OptionTraitImpl::expect( + core::serde::Serde::::deserialize(ref data), + 'Failed to deserialize param #1' + ); + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = TestNominalImpl::do_params_and_world_ref(ref contract_state, __arg_p2); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__TestNominalImpl__do_with_self(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = TestNominalImpl::do_with_self(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__TestNominalImpl__do_with_ref_self(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = TestNominalImpl::do_with_ref_self(ref contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__IDojoInitImpl__dojo_init(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + IDojoInitImpl::dojo_init(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::array::ArrayTrait::span(@arr) +} + + +pub mod __external { + pub use super::__wrapper__ContractImpl__name as name; + pub use super::__wrapper__ContractImpl__namespace as namespace; + pub use super::__wrapper__ContractImpl__tag as tag; + pub use super::__wrapper__ContractImpl__name_hash as name_hash; + pub use super::__wrapper__ContractImpl__namespace_hash as namespace_hash; + pub use super::__wrapper__ContractImpl__selector as selector; + pub use super::__wrapper__WorldProviderImpl__world as world; + pub use super::__wrapper__TestNominalImpl__do_no_param as do_no_param; + pub use super::__wrapper__TestNominalImpl__do_no_param_but_world as do_no_param_but_world; + pub use super::__wrapper__TestNominalImpl__do_no_param_but_world_ref as do_no_param_but_world_ref; + pub use super::__wrapper__TestNominalImpl__do_params_no_world as do_params_no_world; + pub use super::__wrapper__TestNominalImpl__do_params_and_world as do_params_and_world; + pub use super::__wrapper__TestNominalImpl__do_params_and_world_ref as do_params_and_world_ref; + pub use super::__wrapper__TestNominalImpl__do_with_self as do_with_self; + pub use super::__wrapper__TestNominalImpl__do_with_ref_self as do_with_ref_self; + pub use super::__wrapper__IDojoInitImpl__dojo_init as dojo_init; +} +pub mod __l1_handler { +} +pub mod __constructor { +} + impl ContractStateEventEmitter of starknet::event::EventEmitter< + ContractState, Event + > { + fn emit>( + ref self: ContractState, event: S + ) { + let event: Event = core::traits::Into::into(event); + let mut keys = Default::::default(); + let mut data = Default::::default(); + starknet::Event::append_keys_and_data(@event, ref keys, ref data); + starknet::SyscallResultTrait::unwrap_syscall( + starknet::syscalls::emit_event_syscall( + core::array::ArrayTrait::span(@keys), + core::array::ArrayTrait::span(@data), + ) + ) + } + } + +impl HasComponentImpl_upgradeable of dojo::contract::upgradeable::upgradeable::HasComponent { + fn get_component(self: @ContractState) -> @dojo::contract::upgradeable::upgradeable::ComponentState { + @dojo::contract::upgradeable::upgradeable::unsafe_new_component_state::() + } + fn get_component_mut(ref self: ContractState) -> dojo::contract::upgradeable::upgradeable::ComponentState { + dojo::contract::upgradeable::upgradeable::unsafe_new_component_state::() + } + fn get_contract(self: @dojo::contract::upgradeable::upgradeable::ComponentState) -> @ContractState { + @unsafe_new_contract_state() + } + fn get_contract_mut(ref self: dojo::contract::upgradeable::upgradeable::ComponentState) -> ContractState { + unsafe_new_contract_state() + } + fn emit>(ref self: dojo::contract::upgradeable::upgradeable::ComponentState, event: S) { + let event: dojo::contract::upgradeable::upgradeable::Event = core::traits::Into::into(event); + let mut contract = dojo::contract::upgradeable::upgradeable::HasComponent::get_contract_mut(ref self); + ContractStateEventEmitter::emit(ref contract, Event::UpgradeableEvent(event)); + } +} +impl IDojoInitDispatcherCopy of core::traits::Copy::; +impl IDojoInitDispatcherDrop of core::traits::Drop::; +impl IDojoInitDispatcherSerde of core::serde::Serde:: { + fn serialize(self: @IDojoInitDispatcher, ref output: core::array::Array) { + core::serde::Serde::serialize(self.contract_address, ref output) + } + fn deserialize(ref serialized: core::array::Span) -> core::option::Option { + core::option::Option::Some(IDojoInitDispatcher { + contract_address: core::serde::Serde::deserialize(ref serialized)?, + }) + } +} +impl StoreIDojoInitDispatcher of starknet::Store:: { + fn read(address_domain: u32, base: starknet::storage_access::StorageBaseAddress) -> starknet::SyscallResult { + let contract_address = starknet::Store::::read(address_domain, base)?; + starknet::SyscallResult::Ok( + IDojoInitDispatcher { + contract_address, + } + ) + } + fn write(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, value: IDojoInitDispatcher) -> starknet::SyscallResult<()> { + starknet::Store::::write(address_domain, base, value.contract_address)?; + starknet::SyscallResult::Ok(()) + } + fn read_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8) -> starknet::SyscallResult { + let contract_address = starknet::Store::::read_at_offset(address_domain, base, offset)?; + starknet::SyscallResult::Ok( + IDojoInitDispatcher { + contract_address, + } + ) + } + #[inline(always)] + fn write_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8, value: IDojoInitDispatcher) -> starknet::SyscallResult<()> { + starknet::Store::::write_at_offset(address_domain, base, offset, value.contract_address)?; + starknet::SyscallResult::Ok(()) + } + #[inline(always)] + fn size() -> u8 { + starknet::Store::::size() + } +} + +#[derive(Drop, Copy)] +pub struct IDojoInitDispatcherSubPointers { + pub contract_address: starknet::storage::StoragePointer, +} +impl IDojoInitDispatcherSubPointersImpl of starknet::storage::SubPointers { + type SubPointersType = IDojoInitDispatcherSubPointers; + fn sub_pointers(self: starknet::storage::StoragePointer) -> IDojoInitDispatcherSubPointers { + let base_address = self.__storage_pointer_address__; + let mut current_offset = self.__storage_pointer_offset__; + let contract_address_value = starknet::storage::StoragePointer { + __storage_pointer_address__: base_address, + __storage_pointer_offset__: current_offset, + }; + IDojoInitDispatcherSubPointers { + contract_address: contract_address_value, + } + } +} +#[derive(Drop, Copy)] +pub struct IDojoInitDispatcherSubPointersMut { + pub contract_address: starknet::storage::StoragePointer>, +} +impl IDojoInitDispatcherSubPointersMutImpl of starknet::storage::SubPointersMut { + type SubPointersType = IDojoInitDispatcherSubPointersMut; + fn sub_pointers_mut(self: starknet::storage::StoragePointer>) -> IDojoInitDispatcherSubPointersMut { + let base_address = self.__storage_pointer_address__; + let mut current_offset = self.__storage_pointer_offset__; + let contract_address_value = starknet::storage::StoragePointer { + __storage_pointer_address__: base_address, + __storage_pointer_offset__: current_offset, + }; + IDojoInitDispatcherSubPointersMut { + contract_address: contract_address_value, + } + } +} +impl IDojoInitLibraryDispatcherCopy of core::traits::Copy::; +impl IDojoInitLibraryDispatcherDrop of core::traits::Drop::; +impl IDojoInitLibraryDispatcherSerde of core::serde::Serde:: { + fn serialize(self: @IDojoInitLibraryDispatcher, ref output: core::array::Array) { + core::serde::Serde::serialize(self.class_hash, ref output) + } + fn deserialize(ref serialized: core::array::Span) -> core::option::Option { + core::option::Option::Some(IDojoInitLibraryDispatcher { + class_hash: core::serde::Serde::deserialize(ref serialized)?, + }) + } +} +impl StoreIDojoInitLibraryDispatcher of starknet::Store:: { + fn read(address_domain: u32, base: starknet::storage_access::StorageBaseAddress) -> starknet::SyscallResult { + let class_hash = starknet::Store::::read(address_domain, base)?; + starknet::SyscallResult::Ok( + IDojoInitLibraryDispatcher { + class_hash, + } + ) + } + fn write(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, value: IDojoInitLibraryDispatcher) -> starknet::SyscallResult<()> { + starknet::Store::::write(address_domain, base, value.class_hash)?; + starknet::SyscallResult::Ok(()) + } + fn read_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8) -> starknet::SyscallResult { + let class_hash = starknet::Store::::read_at_offset(address_domain, base, offset)?; + starknet::SyscallResult::Ok( + IDojoInitLibraryDispatcher { + class_hash, + } + ) + } + #[inline(always)] + fn write_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8, value: IDojoInitLibraryDispatcher) -> starknet::SyscallResult<()> { + starknet::Store::::write_at_offset(address_domain, base, offset, value.class_hash)?; + starknet::SyscallResult::Ok(()) + } + #[inline(always)] + fn size() -> u8 { + starknet::Store::::size() + } +} + +#[derive(Drop, Copy)] +pub struct IDojoInitLibraryDispatcherSubPointers { + pub class_hash: starknet::storage::StoragePointer, +} +impl IDojoInitLibraryDispatcherSubPointersImpl of starknet::storage::SubPointers { + type SubPointersType = IDojoInitLibraryDispatcherSubPointers; + fn sub_pointers(self: starknet::storage::StoragePointer) -> IDojoInitLibraryDispatcherSubPointers { + let base_address = self.__storage_pointer_address__; + let mut current_offset = self.__storage_pointer_offset__; + let class_hash_value = starknet::storage::StoragePointer { + __storage_pointer_address__: base_address, + __storage_pointer_offset__: current_offset, + }; + IDojoInitLibraryDispatcherSubPointers { + class_hash: class_hash_value, + } + } +} +#[derive(Drop, Copy)] +pub struct IDojoInitLibraryDispatcherSubPointersMut { + pub class_hash: starknet::storage::StoragePointer>, +} +impl IDojoInitLibraryDispatcherSubPointersMutImpl of starknet::storage::SubPointersMut { + type SubPointersType = IDojoInitLibraryDispatcherSubPointersMut; + fn sub_pointers_mut(self: starknet::storage::StoragePointer>) -> IDojoInitLibraryDispatcherSubPointersMut { + let base_address = self.__storage_pointer_address__; + let mut current_offset = self.__storage_pointer_offset__; + let class_hash_value = starknet::storage::StoragePointer { + __storage_pointer_address__: base_address, + __storage_pointer_offset__: current_offset, + }; + IDojoInitLibraryDispatcherSubPointersMut { + class_hash: class_hash_value, + } + } +} +impl IDojoInitSafeLibraryDispatcherCopy of core::traits::Copy::; +impl IDojoInitSafeLibraryDispatcherDrop of core::traits::Drop::; +impl IDojoInitSafeLibraryDispatcherSerde of core::serde::Serde:: { + fn serialize(self: @IDojoInitSafeLibraryDispatcher, ref output: core::array::Array) { + core::serde::Serde::serialize(self.class_hash, ref output) + } + fn deserialize(ref serialized: core::array::Span) -> core::option::Option { + core::option::Option::Some(IDojoInitSafeLibraryDispatcher { + class_hash: core::serde::Serde::deserialize(ref serialized)?, + }) + } +} +impl StoreIDojoInitSafeLibraryDispatcher of starknet::Store:: { + fn read(address_domain: u32, base: starknet::storage_access::StorageBaseAddress) -> starknet::SyscallResult { + let class_hash = starknet::Store::::read(address_domain, base)?; + starknet::SyscallResult::Ok( + IDojoInitSafeLibraryDispatcher { + class_hash, + } + ) + } + fn write(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, value: IDojoInitSafeLibraryDispatcher) -> starknet::SyscallResult<()> { + starknet::Store::::write(address_domain, base, value.class_hash)?; + starknet::SyscallResult::Ok(()) + } + fn read_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8) -> starknet::SyscallResult { + let class_hash = starknet::Store::::read_at_offset(address_domain, base, offset)?; + starknet::SyscallResult::Ok( + IDojoInitSafeLibraryDispatcher { + class_hash, + } + ) + } + #[inline(always)] + fn write_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8, value: IDojoInitSafeLibraryDispatcher) -> starknet::SyscallResult<()> { + starknet::Store::::write_at_offset(address_domain, base, offset, value.class_hash)?; + starknet::SyscallResult::Ok(()) + } + #[inline(always)] + fn size() -> u8 { + starknet::Store::::size() + } +} + +#[derive(Drop, Copy)] +pub struct IDojoInitSafeLibraryDispatcherSubPointers { + pub class_hash: starknet::storage::StoragePointer, +} +impl IDojoInitSafeLibraryDispatcherSubPointersImpl of starknet::storage::SubPointers { + type SubPointersType = IDojoInitSafeLibraryDispatcherSubPointers; + fn sub_pointers(self: starknet::storage::StoragePointer) -> IDojoInitSafeLibraryDispatcherSubPointers { + let base_address = self.__storage_pointer_address__; + let mut current_offset = self.__storage_pointer_offset__; + let class_hash_value = starknet::storage::StoragePointer { + __storage_pointer_address__: base_address, + __storage_pointer_offset__: current_offset, + }; + IDojoInitSafeLibraryDispatcherSubPointers { + class_hash: class_hash_value, + } + } +} +#[derive(Drop, Copy)] +pub struct IDojoInitSafeLibraryDispatcherSubPointersMut { + pub class_hash: starknet::storage::StoragePointer>, +} +impl IDojoInitSafeLibraryDispatcherSubPointersMutImpl of starknet::storage::SubPointersMut { + type SubPointersType = IDojoInitSafeLibraryDispatcherSubPointersMut; + fn sub_pointers_mut(self: starknet::storage::StoragePointer>) -> IDojoInitSafeLibraryDispatcherSubPointersMut { + let base_address = self.__storage_pointer_address__; + let mut current_offset = self.__storage_pointer_offset__; + let class_hash_value = starknet::storage::StoragePointer { + __storage_pointer_address__: base_address, + __storage_pointer_offset__: current_offset, + }; + IDojoInitSafeLibraryDispatcherSubPointersMut { + class_hash: class_hash_value, + } + } +} +impl IDojoInitSafeDispatcherCopy of core::traits::Copy::; +impl IDojoInitSafeDispatcherDrop of core::traits::Drop::; +impl IDojoInitSafeDispatcherSerde of core::serde::Serde:: { + fn serialize(self: @IDojoInitSafeDispatcher, ref output: core::array::Array) { + core::serde::Serde::serialize(self.contract_address, ref output) + } + fn deserialize(ref serialized: core::array::Span) -> core::option::Option { + core::option::Option::Some(IDojoInitSafeDispatcher { + contract_address: core::serde::Serde::deserialize(ref serialized)?, + }) + } +} +impl StoreIDojoInitSafeDispatcher of starknet::Store:: { + fn read(address_domain: u32, base: starknet::storage_access::StorageBaseAddress) -> starknet::SyscallResult { + let contract_address = starknet::Store::::read(address_domain, base)?; + starknet::SyscallResult::Ok( + IDojoInitSafeDispatcher { + contract_address, + } + ) + } + fn write(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, value: IDojoInitSafeDispatcher) -> starknet::SyscallResult<()> { + starknet::Store::::write(address_domain, base, value.contract_address)?; + starknet::SyscallResult::Ok(()) + } + fn read_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8) -> starknet::SyscallResult { + let contract_address = starknet::Store::::read_at_offset(address_domain, base, offset)?; + starknet::SyscallResult::Ok( + IDojoInitSafeDispatcher { + contract_address, + } + ) + } + #[inline(always)] + fn write_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8, value: IDojoInitSafeDispatcher) -> starknet::SyscallResult<()> { + starknet::Store::::write_at_offset(address_domain, base, offset, value.contract_address)?; + starknet::SyscallResult::Ok(()) + } + #[inline(always)] + fn size() -> u8 { + starknet::Store::::size() + } +} + +#[derive(Drop, Copy)] +pub struct IDojoInitSafeDispatcherSubPointers { + pub contract_address: starknet::storage::StoragePointer, +} +impl IDojoInitSafeDispatcherSubPointersImpl of starknet::storage::SubPointers { + type SubPointersType = IDojoInitSafeDispatcherSubPointers; + fn sub_pointers(self: starknet::storage::StoragePointer) -> IDojoInitSafeDispatcherSubPointers { + let base_address = self.__storage_pointer_address__; + let mut current_offset = self.__storage_pointer_offset__; + let contract_address_value = starknet::storage::StoragePointer { + __storage_pointer_address__: base_address, + __storage_pointer_offset__: current_offset, + }; + IDojoInitSafeDispatcherSubPointers { + contract_address: contract_address_value, + } + } +} +#[derive(Drop, Copy)] +pub struct IDojoInitSafeDispatcherSubPointersMut { + pub contract_address: starknet::storage::StoragePointer>, +} +impl IDojoInitSafeDispatcherSubPointersMutImpl of starknet::storage::SubPointersMut { + type SubPointersType = IDojoInitSafeDispatcherSubPointersMut; + fn sub_pointers_mut(self: starknet::storage::StoragePointer>) -> IDojoInitSafeDispatcherSubPointersMut { + let base_address = self.__storage_pointer_address__; + let mut current_offset = self.__storage_pointer_offset__; + let contract_address_value = starknet::storage::StoragePointer { + __storage_pointer_address__: base_address, + __storage_pointer_offset__: current_offset, + }; + IDojoInitSafeDispatcherSubPointersMut { + contract_address: contract_address_value, + } + } +} +impl StorageStorageBaseDrop of core::traits::Drop::; +impl StorageStorageBaseCopy of core::traits::Copy::; +impl StorageStorageBaseMutDrop of core::traits::Drop::; +impl StorageStorageBaseMutCopy of core::traits::Copy::; +impl IDojoInitDispatcherSubPointersDrop of core::traits::Drop::; +impl IDojoInitDispatcherSubPointersCopy of core::traits::Copy::; +impl IDojoInitDispatcherSubPointersMutDrop of core::traits::Drop::; +impl IDojoInitDispatcherSubPointersMutCopy of core::traits::Copy::; +impl IDojoInitLibraryDispatcherSubPointersDrop of core::traits::Drop::; +impl IDojoInitLibraryDispatcherSubPointersCopy of core::traits::Copy::; +impl IDojoInitLibraryDispatcherSubPointersMutDrop of core::traits::Drop::; +impl IDojoInitLibraryDispatcherSubPointersMutCopy of core::traits::Copy::; +impl IDojoInitSafeLibraryDispatcherSubPointersDrop of core::traits::Drop::; +impl IDojoInitSafeLibraryDispatcherSubPointersCopy of core::traits::Copy::; +impl IDojoInitSafeLibraryDispatcherSubPointersMutDrop of core::traits::Drop::; +impl IDojoInitSafeLibraryDispatcherSubPointersMutCopy of core::traits::Copy::; +impl IDojoInitSafeDispatcherSubPointersDrop of core::traits::Drop::; +impl IDojoInitSafeDispatcherSubPointersCopy of core::traits::Copy::; +impl IDojoInitSafeDispatcherSubPointersMutDrop of core::traits::Drop::; +impl IDojoInitSafeDispatcherSubPointersMutCopy of core::traits::Copy::; + + } + + #[starknet::contract] + pub mod init_test { + use dojo::world; + use dojo::world::IWorldDispatcher; + use dojo::world::IWorldDispatcherTrait; + use dojo::world::IWorldProvider; + use dojo::contract::IContract; + use starknet::storage::{ + StorageMapReadAccess, StorageMapWriteAccess, StoragePointerReadAccess, StoragePointerWriteAccess + }; + + #[abi(embed_v0)] + pub impl ContractImpl of IContract { + fn name(self: @ContractState) -> ByteArray { + "init_test" + } + + fn namespace(self: @ContractState) -> ByteArray { + "dojo_test" + } + + fn tag(self: @ContractState) -> ByteArray { + "dojo_test-init_test" + } + + fn name_hash(self: @ContractState) -> felt252 { + 1673722391095039242574232979635399085098867563460816803458086922970092209409 + } + + fn namespace_hash(self: @ContractState) -> felt252 { + 1452123528942907587532668415362544424816022573043154497385993678618948064048 + } + + fn selector(self: @ContractState) -> felt252 { + 3030310726300416277764466172753931798577418912153146471062249714457767216078 + } + } + + #[abi(embed_v0)] + impl WorldProviderImpl of IWorldProvider { + fn world(self: @ContractState) -> IWorldDispatcher { + self.world_dispatcher.read() + } + } + + #[abi(embed_v0)] + impl UpgradableImpl = dojo::contract::upgradeable::upgradeable::UpgradableImpl; + + #[starknet::interface] + pub trait IDojoInit { + fn dojo_init(self: @ContractState, actions_address: ContractAddress, actions_class: ClassHash, value: u8 +); + } + + #[abi(embed_v0)] + pub impl IDojoInitImpl of IDojoInit { + fn dojo_init(self: @ContractState, actions_address: ContractAddress, actions_class: ClassHash, value: u8 +) {let world = self.world_dispatcher.read();if starknet::get_caller_address() != self.world().contract_address { core::panics::panic_with_byte_array(@format!("Only the world can init contract `{}`, but caller is `{:?}`", self.tag(), starknet::get_caller_address())); } emit!( + world, + ContractInitialized { + contract_address: actions_address, contract_class: actions_class, value + } + ); +} +} + #[event] + #[derive(Drop, starknet::Event)] + enum Event { + UpgradeableEvent: dojo::contract::upgradeable::upgradeable::Event, + } + pub trait IDojoInitDispatcherTrait { + fn dojo_init(self: T, actions_address: ContractAddress, actions_class: ClassHash, value: u8 +); +} + +#[derive(Copy, Drop, starknet::Store, Serde)] + pub struct IDojoInitDispatcher { + pub contract_address: starknet::ContractAddress, +} + +impl IDojoInitDispatcherImpl of IDojoInitDispatcherTrait { + fn dojo_init(self: IDojoInitDispatcher, actions_address: ContractAddress, actions_class: ClassHash, value: u8 +) { + let mut __calldata__ = core::traits::Default::default(); + core::serde::Serde::::serialize(@actions_address, ref __calldata__); + core::serde::Serde::::serialize(@actions_class, ref __calldata__); + core::serde::Serde::::serialize(@value, ref __calldata__); + + let mut __dispatcher_return_data__ = starknet::syscalls::call_contract_syscall( + self.contract_address, + selector!("dojo_init"), + core::array::ArrayTrait::span(@__calldata__), + ); + let mut __dispatcher_return_data__ = starknet::SyscallResultTrait::unwrap_syscall(__dispatcher_return_data__); + () + } + +} + +#[derive(Copy, Drop, starknet::Store, Serde)] + pub struct IDojoInitLibraryDispatcher { + pub class_hash: starknet::ClassHash, +} + +impl IDojoInitLibraryDispatcherImpl of IDojoInitDispatcherTrait { + fn dojo_init(self: IDojoInitLibraryDispatcher, actions_address: ContractAddress, actions_class: ClassHash, value: u8 +) { + let mut __calldata__ = core::traits::Default::default(); + core::serde::Serde::::serialize(@actions_address, ref __calldata__); + core::serde::Serde::::serialize(@actions_class, ref __calldata__); + core::serde::Serde::::serialize(@value, ref __calldata__); + + let mut __dispatcher_return_data__ = starknet::syscalls::library_call_syscall( + self.class_hash, + selector!("dojo_init"), + core::array::ArrayTrait::span(@__calldata__), + ); + let mut __dispatcher_return_data__ = starknet::SyscallResultTrait::unwrap_syscall(__dispatcher_return_data__); + () + } + +} + + pub trait IDojoInitSafeDispatcherTrait { + #[unstable(feature: "safe_dispatcher")] + fn dojo_init(self: T, actions_address: ContractAddress, actions_class: ClassHash, value: u8 +) -> starknet::SyscallResult<()>; +} + +#[derive(Copy, Drop, starknet::Store, Serde)] + pub struct IDojoInitSafeLibraryDispatcher { + pub class_hash: starknet::ClassHash, +} + +impl IDojoInitSafeLibraryDispatcherImpl of IDojoInitSafeDispatcherTrait { + fn dojo_init(self: IDojoInitSafeLibraryDispatcher, actions_address: ContractAddress, actions_class: ClassHash, value: u8 +) -> starknet::SyscallResult<()> { + let mut __calldata__ = core::traits::Default::default(); + core::serde::Serde::::serialize(@actions_address, ref __calldata__); + core::serde::Serde::::serialize(@actions_class, ref __calldata__); + core::serde::Serde::::serialize(@value, ref __calldata__); + + let mut __dispatcher_return_data__ = starknet::syscalls::library_call_syscall( + self.class_hash, + selector!("dojo_init"), + core::array::ArrayTrait::span(@__calldata__), + ); + let mut __dispatcher_return_data__ = __dispatcher_return_data__?; + Result::Ok(()) + } + +} + + +#[derive(Copy, Drop, starknet::Store, Serde)] + pub struct IDojoInitSafeDispatcher { + pub contract_address: starknet::ContractAddress, +} + +impl IDojoInitSafeDispatcherImpl of IDojoInitSafeDispatcherTrait { + fn dojo_init(self: IDojoInitSafeDispatcher, actions_address: ContractAddress, actions_class: ClassHash, value: u8 +) -> starknet::SyscallResult<()> { + let mut __calldata__ = core::traits::Default::default(); + core::serde::Serde::::serialize(@actions_address, ref __calldata__); + core::serde::Serde::::serialize(@actions_class, ref __calldata__); + core::serde::Serde::::serialize(@value, ref __calldata__); + + let mut __dispatcher_return_data__ = starknet::syscalls::call_contract_syscall( + self.contract_address, + selector!("dojo_init"), + core::array::ArrayTrait::span(@__calldata__), + ); + let mut __dispatcher_return_data__ = __dispatcher_return_data__?; + Result::Ok(()) + } + +} +impl EventDrop of core::traits::Drop::; +impl EventIsEvent of starknet::Event { + fn append_keys_and_data( + self: @Event, ref keys: Array, ref data: Array + ) { + match self { + Event::UpgradeableEvent(val) => { + core::array::ArrayTrait::append(ref keys, selector!("UpgradeableEvent")); + starknet::Event::append_keys_and_data( + val, ref keys, ref data + ); + }, + } + } + fn deserialize( + ref keys: Span, ref data: Span, + ) -> Option { + let __selector__ = *core::array::SpanTrait::pop_front(ref keys)?; + if __selector__ == selector!("UpgradeableEvent") { + let val = starknet::Event::deserialize( + ref keys, ref data + )?; + return Option::Some(Event::UpgradeableEvent(val)); + } + Option::None + } +} +impl EventUpgradeableEventIntoEvent of Into { + fn into(self: dojo::contract::upgradeable::upgradeable::Event) -> Event { + Event::UpgradeableEvent(self) + } +} + + +#[phantom] +pub struct Storage { + pub world_dispatcher: IWorldDispatcher, + #[substorage(v0)] + pub upgradeable: dojo::contract::upgradeable::upgradeable::Storage, +} + +#[derive(Drop, Copy)] +pub struct StorageStorageBase { + pub world_dispatcher: starknet::storage::StorageBase, + pub upgradeable: starknet::storage::FlattenedStorage, +} +impl StorageStorageImpl of starknet::storage::StorageTrait { + type BaseType = StorageStorageBase; + fn storage(self: starknet::storage::FlattenedStorage) -> StorageStorageBase { + let world_dispatcher_value = starknet::storage::StorageBase {__base_address__: selector!("world_dispatcher")}; + let upgradeable_value = starknet::storage::FlattenedStorage {}; + StorageStorageBase { + world_dispatcher: world_dispatcher_value, + upgradeable: upgradeable_value, + } + } +} +#[derive(Drop, Copy)] +pub struct StorageStorageBaseMut { + pub world_dispatcher: starknet::storage::StorageBase>, + pub upgradeable: starknet::storage::FlattenedStorage>, +} +impl StorageStorageMutImpl of starknet::storage::StorageTraitMut { + type BaseType = StorageStorageBaseMut; + fn storage_mut(self: starknet::storage::FlattenedStorage>) -> StorageStorageBaseMut { + let world_dispatcher_value = starknet::storage::StorageBase {__base_address__: selector!("world_dispatcher")}; + let upgradeable_value = starknet::storage::FlattenedStorage {}; + StorageStorageBaseMut { + world_dispatcher: world_dispatcher_value, + upgradeable: upgradeable_value, + } + } +} + +pub struct ContractState { + pub upgradeable: dojo::contract::upgradeable::upgradeable::ComponentState, +} + +impl ContractStateDrop of Drop {} + +impl ContractStateDeref of core::ops::SnapshotDeref { + type Target = starknet::storage::FlattenedStorage; + fn snapshot_deref(self: @ContractState) -> starknet::storage::FlattenedStorage { + starknet::storage::FlattenedStorage {} + } +} +impl ContractStateDerefMut of core::ops::DerefMut { + type Target = starknet::storage::FlattenedStorage> ; + fn deref_mut(ref self: ContractState) -> starknet::storage::FlattenedStorage> { + starknet::storage::FlattenedStorage {} + } +} +pub fn unsafe_new_contract_state() -> ContractState { + ContractState { + upgradeable: dojo::contract::upgradeable::upgradeable::unsafe_new_component_state::(), + } +} + +// TODO(Gil): This generates duplicate diagnostics because of the plugin system, squash the duplicates into one. +#[deprecated( + feature: "deprecated_legacy_map", + note: "Use `starknet::storage::Map` instead." +)] +use starknet::storage::Map as LegacyMap; + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__ContractImpl__name(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = ContractImpl::name(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__ContractImpl__namespace(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = ContractImpl::namespace(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__ContractImpl__tag(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = ContractImpl::tag(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__ContractImpl__name_hash(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = ContractImpl::name_hash(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__ContractImpl__namespace_hash(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = ContractImpl::namespace_hash(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__ContractImpl__selector(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = ContractImpl::selector(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__WorldProviderImpl__world(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = WorldProviderImpl::world(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +impl ContractStateUpgradableImpl of + dojo::contract::upgradeable::upgradeable::UnsafeNewContractStateTraitForUpgradableImpl { + fn unsafe_new_contract_state() -> ContractState { + unsafe_new_contract_state() + } +} +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__IDojoInitImpl__dojo_init(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + let __arg_actions_address = core::option::OptionTraitImpl::expect( + core::serde::Serde::::deserialize(ref data), + 'Failed to deserialize param #1' + ); + let __arg_actions_class = core::option::OptionTraitImpl::expect( + core::serde::Serde::::deserialize(ref data), + 'Failed to deserialize param #2' + ); + let __arg_value = core::option::OptionTraitImpl::expect( + core::serde::Serde::::deserialize(ref data), + 'Failed to deserialize param #3' + ); + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + IDojoInitImpl::dojo_init(@contract_state, __arg_actions_address, __arg_actions_class, __arg_value); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::array::ArrayTrait::span(@arr) +} + + +pub mod __external { + pub use super::__wrapper__ContractImpl__name as name; + pub use super::__wrapper__ContractImpl__namespace as namespace; + pub use super::__wrapper__ContractImpl__tag as tag; + pub use super::__wrapper__ContractImpl__name_hash as name_hash; + pub use super::__wrapper__ContractImpl__namespace_hash as namespace_hash; + pub use super::__wrapper__ContractImpl__selector as selector; + pub use super::__wrapper__WorldProviderImpl__world as world; + pub use super::__wrapper__IDojoInitImpl__dojo_init as dojo_init; +} +pub mod __l1_handler { +} +pub mod __constructor { +} + impl ContractStateEventEmitter of starknet::event::EventEmitter< + ContractState, Event + > { + fn emit>( + ref self: ContractState, event: S + ) { + let event: Event = core::traits::Into::into(event); + let mut keys = Default::::default(); + let mut data = Default::::default(); + starknet::Event::append_keys_and_data(@event, ref keys, ref data); + starknet::SyscallResultTrait::unwrap_syscall( + starknet::syscalls::emit_event_syscall( + core::array::ArrayTrait::span(@keys), + core::array::ArrayTrait::span(@data), + ) + ) + } + } + +impl HasComponentImpl_upgradeable of dojo::contract::upgradeable::upgradeable::HasComponent { + fn get_component(self: @ContractState) -> @dojo::contract::upgradeable::upgradeable::ComponentState { + @dojo::contract::upgradeable::upgradeable::unsafe_new_component_state::() + } + fn get_component_mut(ref self: ContractState) -> dojo::contract::upgradeable::upgradeable::ComponentState { + dojo::contract::upgradeable::upgradeable::unsafe_new_component_state::() + } + fn get_contract(self: @dojo::contract::upgradeable::upgradeable::ComponentState) -> @ContractState { + @unsafe_new_contract_state() + } + fn get_contract_mut(ref self: dojo::contract::upgradeable::upgradeable::ComponentState) -> ContractState { + unsafe_new_contract_state() + } + fn emit>(ref self: dojo::contract::upgradeable::upgradeable::ComponentState, event: S) { + let event: dojo::contract::upgradeable::upgradeable::Event = core::traits::Into::into(event); + let mut contract = dojo::contract::upgradeable::upgradeable::HasComponent::get_contract_mut(ref self); + ContractStateEventEmitter::emit(ref contract, Event::UpgradeableEvent(event)); + } +} +impl IDojoInitDispatcherCopy of core::traits::Copy::; +impl IDojoInitDispatcherDrop of core::traits::Drop::; +impl IDojoInitDispatcherSerde of core::serde::Serde:: { + fn serialize(self: @IDojoInitDispatcher, ref output: core::array::Array) { + core::serde::Serde::serialize(self.contract_address, ref output) + } + fn deserialize(ref serialized: core::array::Span) -> core::option::Option { + core::option::Option::Some(IDojoInitDispatcher { + contract_address: core::serde::Serde::deserialize(ref serialized)?, + }) + } +} +impl StoreIDojoInitDispatcher of starknet::Store:: { + fn read(address_domain: u32, base: starknet::storage_access::StorageBaseAddress) -> starknet::SyscallResult { + let contract_address = starknet::Store::::read(address_domain, base)?; + starknet::SyscallResult::Ok( + IDojoInitDispatcher { + contract_address, + } + ) + } + fn write(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, value: IDojoInitDispatcher) -> starknet::SyscallResult<()> { + starknet::Store::::write(address_domain, base, value.contract_address)?; + starknet::SyscallResult::Ok(()) + } + fn read_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8) -> starknet::SyscallResult { + let contract_address = starknet::Store::::read_at_offset(address_domain, base, offset)?; + starknet::SyscallResult::Ok( + IDojoInitDispatcher { + contract_address, + } + ) + } + #[inline(always)] + fn write_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8, value: IDojoInitDispatcher) -> starknet::SyscallResult<()> { + starknet::Store::::write_at_offset(address_domain, base, offset, value.contract_address)?; + starknet::SyscallResult::Ok(()) + } + #[inline(always)] + fn size() -> u8 { + starknet::Store::::size() + } +} + +#[derive(Drop, Copy)] +pub struct IDojoInitDispatcherSubPointers { + pub contract_address: starknet::storage::StoragePointer, +} +impl IDojoInitDispatcherSubPointersImpl of starknet::storage::SubPointers { + type SubPointersType = IDojoInitDispatcherSubPointers; + fn sub_pointers(self: starknet::storage::StoragePointer) -> IDojoInitDispatcherSubPointers { + let base_address = self.__storage_pointer_address__; + let mut current_offset = self.__storage_pointer_offset__; + let contract_address_value = starknet::storage::StoragePointer { + __storage_pointer_address__: base_address, + __storage_pointer_offset__: current_offset, + }; + IDojoInitDispatcherSubPointers { + contract_address: contract_address_value, + } + } +} +#[derive(Drop, Copy)] +pub struct IDojoInitDispatcherSubPointersMut { + pub contract_address: starknet::storage::StoragePointer>, +} +impl IDojoInitDispatcherSubPointersMutImpl of starknet::storage::SubPointersMut { + type SubPointersType = IDojoInitDispatcherSubPointersMut; + fn sub_pointers_mut(self: starknet::storage::StoragePointer>) -> IDojoInitDispatcherSubPointersMut { + let base_address = self.__storage_pointer_address__; + let mut current_offset = self.__storage_pointer_offset__; + let contract_address_value = starknet::storage::StoragePointer { + __storage_pointer_address__: base_address, + __storage_pointer_offset__: current_offset, + }; + IDojoInitDispatcherSubPointersMut { + contract_address: contract_address_value, + } + } +} +impl IDojoInitLibraryDispatcherCopy of core::traits::Copy::; +impl IDojoInitLibraryDispatcherDrop of core::traits::Drop::; +impl IDojoInitLibraryDispatcherSerde of core::serde::Serde:: { + fn serialize(self: @IDojoInitLibraryDispatcher, ref output: core::array::Array) { + core::serde::Serde::serialize(self.class_hash, ref output) + } + fn deserialize(ref serialized: core::array::Span) -> core::option::Option { + core::option::Option::Some(IDojoInitLibraryDispatcher { + class_hash: core::serde::Serde::deserialize(ref serialized)?, + }) + } +} +impl StoreIDojoInitLibraryDispatcher of starknet::Store:: { + fn read(address_domain: u32, base: starknet::storage_access::StorageBaseAddress) -> starknet::SyscallResult { + let class_hash = starknet::Store::::read(address_domain, base)?; + starknet::SyscallResult::Ok( + IDojoInitLibraryDispatcher { + class_hash, + } + ) + } + fn write(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, value: IDojoInitLibraryDispatcher) -> starknet::SyscallResult<()> { + starknet::Store::::write(address_domain, base, value.class_hash)?; + starknet::SyscallResult::Ok(()) + } + fn read_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8) -> starknet::SyscallResult { + let class_hash = starknet::Store::::read_at_offset(address_domain, base, offset)?; + starknet::SyscallResult::Ok( + IDojoInitLibraryDispatcher { + class_hash, + } + ) + } + #[inline(always)] + fn write_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8, value: IDojoInitLibraryDispatcher) -> starknet::SyscallResult<()> { + starknet::Store::::write_at_offset(address_domain, base, offset, value.class_hash)?; + starknet::SyscallResult::Ok(()) + } + #[inline(always)] + fn size() -> u8 { + starknet::Store::::size() + } +} + +#[derive(Drop, Copy)] +pub struct IDojoInitLibraryDispatcherSubPointers { + pub class_hash: starknet::storage::StoragePointer, +} +impl IDojoInitLibraryDispatcherSubPointersImpl of starknet::storage::SubPointers { + type SubPointersType = IDojoInitLibraryDispatcherSubPointers; + fn sub_pointers(self: starknet::storage::StoragePointer) -> IDojoInitLibraryDispatcherSubPointers { + let base_address = self.__storage_pointer_address__; + let mut current_offset = self.__storage_pointer_offset__; + let class_hash_value = starknet::storage::StoragePointer { + __storage_pointer_address__: base_address, + __storage_pointer_offset__: current_offset, + }; + IDojoInitLibraryDispatcherSubPointers { + class_hash: class_hash_value, + } + } +} +#[derive(Drop, Copy)] +pub struct IDojoInitLibraryDispatcherSubPointersMut { + pub class_hash: starknet::storage::StoragePointer>, +} +impl IDojoInitLibraryDispatcherSubPointersMutImpl of starknet::storage::SubPointersMut { + type SubPointersType = IDojoInitLibraryDispatcherSubPointersMut; + fn sub_pointers_mut(self: starknet::storage::StoragePointer>) -> IDojoInitLibraryDispatcherSubPointersMut { + let base_address = self.__storage_pointer_address__; + let mut current_offset = self.__storage_pointer_offset__; + let class_hash_value = starknet::storage::StoragePointer { + __storage_pointer_address__: base_address, + __storage_pointer_offset__: current_offset, + }; + IDojoInitLibraryDispatcherSubPointersMut { + class_hash: class_hash_value, + } + } +} +impl IDojoInitSafeLibraryDispatcherCopy of core::traits::Copy::; +impl IDojoInitSafeLibraryDispatcherDrop of core::traits::Drop::; +impl IDojoInitSafeLibraryDispatcherSerde of core::serde::Serde:: { + fn serialize(self: @IDojoInitSafeLibraryDispatcher, ref output: core::array::Array) { + core::serde::Serde::serialize(self.class_hash, ref output) + } + fn deserialize(ref serialized: core::array::Span) -> core::option::Option { + core::option::Option::Some(IDojoInitSafeLibraryDispatcher { + class_hash: core::serde::Serde::deserialize(ref serialized)?, + }) + } +} +impl StoreIDojoInitSafeLibraryDispatcher of starknet::Store:: { + fn read(address_domain: u32, base: starknet::storage_access::StorageBaseAddress) -> starknet::SyscallResult { + let class_hash = starknet::Store::::read(address_domain, base)?; + starknet::SyscallResult::Ok( + IDojoInitSafeLibraryDispatcher { + class_hash, + } + ) + } + fn write(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, value: IDojoInitSafeLibraryDispatcher) -> starknet::SyscallResult<()> { + starknet::Store::::write(address_domain, base, value.class_hash)?; + starknet::SyscallResult::Ok(()) + } + fn read_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8) -> starknet::SyscallResult { + let class_hash = starknet::Store::::read_at_offset(address_domain, base, offset)?; + starknet::SyscallResult::Ok( + IDojoInitSafeLibraryDispatcher { + class_hash, + } + ) + } + #[inline(always)] + fn write_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8, value: IDojoInitSafeLibraryDispatcher) -> starknet::SyscallResult<()> { + starknet::Store::::write_at_offset(address_domain, base, offset, value.class_hash)?; + starknet::SyscallResult::Ok(()) + } + #[inline(always)] + fn size() -> u8 { + starknet::Store::::size() + } +} + +#[derive(Drop, Copy)] +pub struct IDojoInitSafeLibraryDispatcherSubPointers { + pub class_hash: starknet::storage::StoragePointer, +} +impl IDojoInitSafeLibraryDispatcherSubPointersImpl of starknet::storage::SubPointers { + type SubPointersType = IDojoInitSafeLibraryDispatcherSubPointers; + fn sub_pointers(self: starknet::storage::StoragePointer) -> IDojoInitSafeLibraryDispatcherSubPointers { + let base_address = self.__storage_pointer_address__; + let mut current_offset = self.__storage_pointer_offset__; + let class_hash_value = starknet::storage::StoragePointer { + __storage_pointer_address__: base_address, + __storage_pointer_offset__: current_offset, + }; + IDojoInitSafeLibraryDispatcherSubPointers { + class_hash: class_hash_value, + } + } +} +#[derive(Drop, Copy)] +pub struct IDojoInitSafeLibraryDispatcherSubPointersMut { + pub class_hash: starknet::storage::StoragePointer>, +} +impl IDojoInitSafeLibraryDispatcherSubPointersMutImpl of starknet::storage::SubPointersMut { + type SubPointersType = IDojoInitSafeLibraryDispatcherSubPointersMut; + fn sub_pointers_mut(self: starknet::storage::StoragePointer>) -> IDojoInitSafeLibraryDispatcherSubPointersMut { + let base_address = self.__storage_pointer_address__; + let mut current_offset = self.__storage_pointer_offset__; + let class_hash_value = starknet::storage::StoragePointer { + __storage_pointer_address__: base_address, + __storage_pointer_offset__: current_offset, + }; + IDojoInitSafeLibraryDispatcherSubPointersMut { + class_hash: class_hash_value, + } + } +} +impl IDojoInitSafeDispatcherCopy of core::traits::Copy::; +impl IDojoInitSafeDispatcherDrop of core::traits::Drop::; +impl IDojoInitSafeDispatcherSerde of core::serde::Serde:: { + fn serialize(self: @IDojoInitSafeDispatcher, ref output: core::array::Array) { + core::serde::Serde::serialize(self.contract_address, ref output) + } + fn deserialize(ref serialized: core::array::Span) -> core::option::Option { + core::option::Option::Some(IDojoInitSafeDispatcher { + contract_address: core::serde::Serde::deserialize(ref serialized)?, + }) + } +} +impl StoreIDojoInitSafeDispatcher of starknet::Store:: { + fn read(address_domain: u32, base: starknet::storage_access::StorageBaseAddress) -> starknet::SyscallResult { + let contract_address = starknet::Store::::read(address_domain, base)?; + starknet::SyscallResult::Ok( + IDojoInitSafeDispatcher { + contract_address, + } + ) + } + fn write(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, value: IDojoInitSafeDispatcher) -> starknet::SyscallResult<()> { + starknet::Store::::write(address_domain, base, value.contract_address)?; + starknet::SyscallResult::Ok(()) + } + fn read_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8) -> starknet::SyscallResult { + let contract_address = starknet::Store::::read_at_offset(address_domain, base, offset)?; + starknet::SyscallResult::Ok( + IDojoInitSafeDispatcher { + contract_address, + } + ) + } + #[inline(always)] + fn write_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8, value: IDojoInitSafeDispatcher) -> starknet::SyscallResult<()> { + starknet::Store::::write_at_offset(address_domain, base, offset, value.contract_address)?; + starknet::SyscallResult::Ok(()) + } + #[inline(always)] + fn size() -> u8 { + starknet::Store::::size() + } +} + +#[derive(Drop, Copy)] +pub struct IDojoInitSafeDispatcherSubPointers { + pub contract_address: starknet::storage::StoragePointer, +} +impl IDojoInitSafeDispatcherSubPointersImpl of starknet::storage::SubPointers { + type SubPointersType = IDojoInitSafeDispatcherSubPointers; + fn sub_pointers(self: starknet::storage::StoragePointer) -> IDojoInitSafeDispatcherSubPointers { + let base_address = self.__storage_pointer_address__; + let mut current_offset = self.__storage_pointer_offset__; + let contract_address_value = starknet::storage::StoragePointer { + __storage_pointer_address__: base_address, + __storage_pointer_offset__: current_offset, + }; + IDojoInitSafeDispatcherSubPointers { + contract_address: contract_address_value, + } + } +} +#[derive(Drop, Copy)] +pub struct IDojoInitSafeDispatcherSubPointersMut { + pub contract_address: starknet::storage::StoragePointer>, +} +impl IDojoInitSafeDispatcherSubPointersMutImpl of starknet::storage::SubPointersMut { + type SubPointersType = IDojoInitSafeDispatcherSubPointersMut; + fn sub_pointers_mut(self: starknet::storage::StoragePointer>) -> IDojoInitSafeDispatcherSubPointersMut { + let base_address = self.__storage_pointer_address__; + let mut current_offset = self.__storage_pointer_offset__; + let contract_address_value = starknet::storage::StoragePointer { + __storage_pointer_address__: base_address, + __storage_pointer_offset__: current_offset, + }; + IDojoInitSafeDispatcherSubPointersMut { + contract_address: contract_address_value, + } + } +} +impl StorageStorageBaseDrop of core::traits::Drop::; +impl StorageStorageBaseCopy of core::traits::Copy::; +impl StorageStorageBaseMutDrop of core::traits::Drop::; +impl StorageStorageBaseMutCopy of core::traits::Copy::; +impl IDojoInitDispatcherSubPointersDrop of core::traits::Drop::; +impl IDojoInitDispatcherSubPointersCopy of core::traits::Copy::; +impl IDojoInitDispatcherSubPointersMutDrop of core::traits::Drop::; +impl IDojoInitDispatcherSubPointersMutCopy of core::traits::Copy::; +impl IDojoInitLibraryDispatcherSubPointersDrop of core::traits::Drop::; +impl IDojoInitLibraryDispatcherSubPointersCopy of core::traits::Copy::; +impl IDojoInitLibraryDispatcherSubPointersMutDrop of core::traits::Drop::; +impl IDojoInitLibraryDispatcherSubPointersMutCopy of core::traits::Copy::; +impl IDojoInitSafeLibraryDispatcherSubPointersDrop of core::traits::Drop::; +impl IDojoInitSafeLibraryDispatcherSubPointersCopy of core::traits::Copy::; +impl IDojoInitSafeLibraryDispatcherSubPointersMutDrop of core::traits::Drop::; +impl IDojoInitSafeLibraryDispatcherSubPointersMutCopy of core::traits::Copy::; +impl IDojoInitSafeDispatcherSubPointersDrop of core::traits::Drop::; +impl IDojoInitSafeDispatcherSubPointersCopy of core::traits::Copy::; +impl IDojoInitSafeDispatcherSubPointersMutDrop of core::traits::Drop::; +impl IDojoInitSafeDispatcherSubPointersMutCopy of core::traits::Copy::; + + } + + #[starknet::contract] + pub mod no_init_test { + use dojo::world; + use dojo::world::IWorldDispatcher; + use dojo::world::IWorldDispatcherTrait; + use dojo::world::IWorldProvider; + use dojo::contract::IContract; + use starknet::storage::{ + StorageMapReadAccess, StorageMapWriteAccess, StoragePointerReadAccess, StoragePointerWriteAccess + }; + + #[abi(embed_v0)] + pub impl ContractImpl of IContract { + fn name(self: @ContractState) -> ByteArray { + "no_init_test" + } + + fn namespace(self: @ContractState) -> ByteArray { + "dojo_test" + } + + fn tag(self: @ContractState) -> ByteArray { + "dojo_test-no_init_test" + } + + fn name_hash(self: @ContractState) -> felt252 { + 2188407785440294979090510634648735461326850740369373015349552249835679156474 + } + + fn namespace_hash(self: @ContractState) -> felt252 { + 1452123528942907587532668415362544424816022573043154497385993678618948064048 + } + + fn selector(self: @ContractState) -> felt252 { + 1612380646418854749267717900057829622040529970486094087524750323429009828706 + } + } + + #[abi(embed_v0)] + impl WorldProviderImpl of IWorldProvider { + fn world(self: @ContractState) -> IWorldDispatcher { + self.world_dispatcher.read() + } + } + + #[abi(embed_v0)] + impl UpgradableImpl = dojo::contract::upgradeable::upgradeable::UpgradableImpl; + + + #[starknet::interface] + pub trait IDojoInit { + fn dojo_init(self: @ContractState); + } + + #[abi(embed_v0)] + pub impl IDojoInitImpl of IDojoInit { + fn dojo_init(self: @ContractState) { + if starknet::get_caller_address() != self.world().contract_address { + core::panics::panic_with_byte_array( + @format!("Only the world can init contract `{}`, but caller is `{:?}`", + self.tag(), + starknet::get_caller_address(), + )); + } + } + } + + #[event] + #[derive(Drop, starknet::Event)] + enum Event { + UpgradeableEvent: dojo::contract::upgradeable::upgradeable::Event, + } + pub trait IDojoInitDispatcherTrait { + fn dojo_init(self: T); +} + +#[derive(Copy, Drop, starknet::Store, Serde)] + pub struct IDojoInitDispatcher { + pub contract_address: starknet::ContractAddress, +} + +impl IDojoInitDispatcherImpl of IDojoInitDispatcherTrait { + fn dojo_init(self: IDojoInitDispatcher) { + let mut __calldata__ = core::traits::Default::default(); + + let mut __dispatcher_return_data__ = starknet::syscalls::call_contract_syscall( + self.contract_address, + selector!("dojo_init"), + core::array::ArrayTrait::span(@__calldata__), + ); + let mut __dispatcher_return_data__ = starknet::SyscallResultTrait::unwrap_syscall(__dispatcher_return_data__); + () + } + +} + +#[derive(Copy, Drop, starknet::Store, Serde)] + pub struct IDojoInitLibraryDispatcher { + pub class_hash: starknet::ClassHash, +} + +impl IDojoInitLibraryDispatcherImpl of IDojoInitDispatcherTrait { + fn dojo_init(self: IDojoInitLibraryDispatcher) { + let mut __calldata__ = core::traits::Default::default(); + + let mut __dispatcher_return_data__ = starknet::syscalls::library_call_syscall( + self.class_hash, + selector!("dojo_init"), + core::array::ArrayTrait::span(@__calldata__), + ); + let mut __dispatcher_return_data__ = starknet::SyscallResultTrait::unwrap_syscall(__dispatcher_return_data__); + () + } + +} + + pub trait IDojoInitSafeDispatcherTrait { + #[unstable(feature: "safe_dispatcher")] + fn dojo_init(self: T) -> starknet::SyscallResult<()>; +} + +#[derive(Copy, Drop, starknet::Store, Serde)] + pub struct IDojoInitSafeLibraryDispatcher { + pub class_hash: starknet::ClassHash, +} + +impl IDojoInitSafeLibraryDispatcherImpl of IDojoInitSafeDispatcherTrait { + fn dojo_init(self: IDojoInitSafeLibraryDispatcher) -> starknet::SyscallResult<()> { + let mut __calldata__ = core::traits::Default::default(); + + let mut __dispatcher_return_data__ = starknet::syscalls::library_call_syscall( + self.class_hash, + selector!("dojo_init"), + core::array::ArrayTrait::span(@__calldata__), + ); + let mut __dispatcher_return_data__ = __dispatcher_return_data__?; + Result::Ok(()) + } + +} + + +#[derive(Copy, Drop, starknet::Store, Serde)] + pub struct IDojoInitSafeDispatcher { + pub contract_address: starknet::ContractAddress, +} + +impl IDojoInitSafeDispatcherImpl of IDojoInitSafeDispatcherTrait { + fn dojo_init(self: IDojoInitSafeDispatcher) -> starknet::SyscallResult<()> { + let mut __calldata__ = core::traits::Default::default(); + + let mut __dispatcher_return_data__ = starknet::syscalls::call_contract_syscall( + self.contract_address, + selector!("dojo_init"), + core::array::ArrayTrait::span(@__calldata__), + ); + let mut __dispatcher_return_data__ = __dispatcher_return_data__?; + Result::Ok(()) + } + +} +impl EventDrop of core::traits::Drop::; +impl EventIsEvent of starknet::Event { + fn append_keys_and_data( + self: @Event, ref keys: Array, ref data: Array + ) { + match self { + Event::UpgradeableEvent(val) => { + core::array::ArrayTrait::append(ref keys, selector!("UpgradeableEvent")); + starknet::Event::append_keys_and_data( + val, ref keys, ref data + ); + }, + } + } + fn deserialize( + ref keys: Span, ref data: Span, + ) -> Option { + let __selector__ = *core::array::SpanTrait::pop_front(ref keys)?; + if __selector__ == selector!("UpgradeableEvent") { + let val = starknet::Event::deserialize( + ref keys, ref data + )?; + return Option::Some(Event::UpgradeableEvent(val)); + } + Option::None + } +} +impl EventUpgradeableEventIntoEvent of Into { + fn into(self: dojo::contract::upgradeable::upgradeable::Event) -> Event { + Event::UpgradeableEvent(self) + } +} + + +#[phantom] +pub struct Storage { + pub world_dispatcher: IWorldDispatcher, + #[substorage(v0)] + pub upgradeable: dojo::contract::upgradeable::upgradeable::Storage, +} + +#[derive(Drop, Copy)] +pub struct StorageStorageBase { + pub world_dispatcher: starknet::storage::StorageBase, + pub upgradeable: starknet::storage::FlattenedStorage, +} +impl StorageStorageImpl of starknet::storage::StorageTrait { + type BaseType = StorageStorageBase; + fn storage(self: starknet::storage::FlattenedStorage) -> StorageStorageBase { + let world_dispatcher_value = starknet::storage::StorageBase {__base_address__: selector!("world_dispatcher")}; + let upgradeable_value = starknet::storage::FlattenedStorage {}; + StorageStorageBase { + world_dispatcher: world_dispatcher_value, + upgradeable: upgradeable_value, + } + } +} +#[derive(Drop, Copy)] +pub struct StorageStorageBaseMut { + pub world_dispatcher: starknet::storage::StorageBase>, + pub upgradeable: starknet::storage::FlattenedStorage>, +} +impl StorageStorageMutImpl of starknet::storage::StorageTraitMut { + type BaseType = StorageStorageBaseMut; + fn storage_mut(self: starknet::storage::FlattenedStorage>) -> StorageStorageBaseMut { + let world_dispatcher_value = starknet::storage::StorageBase {__base_address__: selector!("world_dispatcher")}; + let upgradeable_value = starknet::storage::FlattenedStorage {}; + StorageStorageBaseMut { + world_dispatcher: world_dispatcher_value, + upgradeable: upgradeable_value, + } + } +} + +pub struct ContractState { + pub upgradeable: dojo::contract::upgradeable::upgradeable::ComponentState, +} + +impl ContractStateDrop of Drop {} + +impl ContractStateDeref of core::ops::SnapshotDeref { + type Target = starknet::storage::FlattenedStorage; + fn snapshot_deref(self: @ContractState) -> starknet::storage::FlattenedStorage { + starknet::storage::FlattenedStorage {} + } +} +impl ContractStateDerefMut of core::ops::DerefMut { + type Target = starknet::storage::FlattenedStorage> ; + fn deref_mut(ref self: ContractState) -> starknet::storage::FlattenedStorage> { + starknet::storage::FlattenedStorage {} + } +} +pub fn unsafe_new_contract_state() -> ContractState { + ContractState { + upgradeable: dojo::contract::upgradeable::upgradeable::unsafe_new_component_state::(), + } +} + +// TODO(Gil): This generates duplicate diagnostics because of the plugin system, squash the duplicates into one. +#[deprecated( + feature: "deprecated_legacy_map", + note: "Use `starknet::storage::Map` instead." +)] +use starknet::storage::Map as LegacyMap; + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__ContractImpl__name(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = ContractImpl::name(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__ContractImpl__namespace(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = ContractImpl::namespace(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__ContractImpl__tag(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = ContractImpl::tag(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__ContractImpl__name_hash(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = ContractImpl::name_hash(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__ContractImpl__namespace_hash(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = ContractImpl::namespace_hash(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__ContractImpl__selector(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = ContractImpl::selector(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__WorldProviderImpl__world(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + let res = WorldProviderImpl::world(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::serde::Serde::::serialize(@res, ref arr); + core::array::ArrayTrait::span(@arr) +} + +impl ContractStateUpgradableImpl of + dojo::contract::upgradeable::upgradeable::UnsafeNewContractStateTraitForUpgradableImpl { + fn unsafe_new_contract_state() -> ContractState { + unsafe_new_contract_state() + } +} +#[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)] +fn __wrapper__IDojoInitImpl__dojo_init(mut data: Span::) -> Span:: { + core::internal::require_implicit::(); + core::internal::revoke_ap_tracking(); + core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), 'Out of gas'); + + assert(core::array::SpanTrait::is_empty(data), 'Input too long for arguments'); + core::option::OptionTraitImpl::expect( + core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), 'Out of gas', + ); + let mut contract_state = unsafe_new_contract_state(); + IDojoInitImpl::dojo_init(@contract_state, ); + let mut arr = ArrayTrait::new(); + // References. + // Result. + core::array::ArrayTrait::span(@arr) +} + + +pub mod __external { + pub use super::__wrapper__ContractImpl__name as name; + pub use super::__wrapper__ContractImpl__namespace as namespace; + pub use super::__wrapper__ContractImpl__tag as tag; + pub use super::__wrapper__ContractImpl__name_hash as name_hash; + pub use super::__wrapper__ContractImpl__namespace_hash as namespace_hash; + pub use super::__wrapper__ContractImpl__selector as selector; + pub use super::__wrapper__WorldProviderImpl__world as world; + pub use super::__wrapper__IDojoInitImpl__dojo_init as dojo_init; +} +pub mod __l1_handler { +} +pub mod __constructor { +} + impl ContractStateEventEmitter of starknet::event::EventEmitter< + ContractState, Event + > { + fn emit>( + ref self: ContractState, event: S + ) { + let event: Event = core::traits::Into::into(event); + let mut keys = Default::::default(); + let mut data = Default::::default(); + starknet::Event::append_keys_and_data(@event, ref keys, ref data); + starknet::SyscallResultTrait::unwrap_syscall( + starknet::syscalls::emit_event_syscall( + core::array::ArrayTrait::span(@keys), + core::array::ArrayTrait::span(@data), + ) + ) + } + } + +impl HasComponentImpl_upgradeable of dojo::contract::upgradeable::upgradeable::HasComponent { + fn get_component(self: @ContractState) -> @dojo::contract::upgradeable::upgradeable::ComponentState { + @dojo::contract::upgradeable::upgradeable::unsafe_new_component_state::() + } + fn get_component_mut(ref self: ContractState) -> dojo::contract::upgradeable::upgradeable::ComponentState { + dojo::contract::upgradeable::upgradeable::unsafe_new_component_state::() + } + fn get_contract(self: @dojo::contract::upgradeable::upgradeable::ComponentState) -> @ContractState { + @unsafe_new_contract_state() + } + fn get_contract_mut(ref self: dojo::contract::upgradeable::upgradeable::ComponentState) -> ContractState { + unsafe_new_contract_state() + } + fn emit>(ref self: dojo::contract::upgradeable::upgradeable::ComponentState, event: S) { + let event: dojo::contract::upgradeable::upgradeable::Event = core::traits::Into::into(event); + let mut contract = dojo::contract::upgradeable::upgradeable::HasComponent::get_contract_mut(ref self); + ContractStateEventEmitter::emit(ref contract, Event::UpgradeableEvent(event)); + } +} +impl IDojoInitDispatcherCopy of core::traits::Copy::; +impl IDojoInitDispatcherDrop of core::traits::Drop::; +impl IDojoInitDispatcherSerde of core::serde::Serde:: { + fn serialize(self: @IDojoInitDispatcher, ref output: core::array::Array) { + core::serde::Serde::serialize(self.contract_address, ref output) + } + fn deserialize(ref serialized: core::array::Span) -> core::option::Option { + core::option::Option::Some(IDojoInitDispatcher { + contract_address: core::serde::Serde::deserialize(ref serialized)?, + }) + } +} +impl StoreIDojoInitDispatcher of starknet::Store:: { + fn read(address_domain: u32, base: starknet::storage_access::StorageBaseAddress) -> starknet::SyscallResult { + let contract_address = starknet::Store::::read(address_domain, base)?; + starknet::SyscallResult::Ok( + IDojoInitDispatcher { + contract_address, + } + ) + } + fn write(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, value: IDojoInitDispatcher) -> starknet::SyscallResult<()> { + starknet::Store::::write(address_domain, base, value.contract_address)?; + starknet::SyscallResult::Ok(()) + } + fn read_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8) -> starknet::SyscallResult { + let contract_address = starknet::Store::::read_at_offset(address_domain, base, offset)?; + starknet::SyscallResult::Ok( + IDojoInitDispatcher { + contract_address, + } + ) + } + #[inline(always)] + fn write_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8, value: IDojoInitDispatcher) -> starknet::SyscallResult<()> { + starknet::Store::::write_at_offset(address_domain, base, offset, value.contract_address)?; + starknet::SyscallResult::Ok(()) + } + #[inline(always)] + fn size() -> u8 { + starknet::Store::::size() + } +} + +#[derive(Drop, Copy)] +pub struct IDojoInitDispatcherSubPointers { + pub contract_address: starknet::storage::StoragePointer, +} +impl IDojoInitDispatcherSubPointersImpl of starknet::storage::SubPointers { + type SubPointersType = IDojoInitDispatcherSubPointers; + fn sub_pointers(self: starknet::storage::StoragePointer) -> IDojoInitDispatcherSubPointers { + let base_address = self.__storage_pointer_address__; + let mut current_offset = self.__storage_pointer_offset__; + let contract_address_value = starknet::storage::StoragePointer { + __storage_pointer_address__: base_address, + __storage_pointer_offset__: current_offset, + }; + IDojoInitDispatcherSubPointers { + contract_address: contract_address_value, + } + } +} +#[derive(Drop, Copy)] +pub struct IDojoInitDispatcherSubPointersMut { + pub contract_address: starknet::storage::StoragePointer>, +} +impl IDojoInitDispatcherSubPointersMutImpl of starknet::storage::SubPointersMut { + type SubPointersType = IDojoInitDispatcherSubPointersMut; + fn sub_pointers_mut(self: starknet::storage::StoragePointer>) -> IDojoInitDispatcherSubPointersMut { + let base_address = self.__storage_pointer_address__; + let mut current_offset = self.__storage_pointer_offset__; + let contract_address_value = starknet::storage::StoragePointer { + __storage_pointer_address__: base_address, + __storage_pointer_offset__: current_offset, + }; + IDojoInitDispatcherSubPointersMut { + contract_address: contract_address_value, + } + } +} +impl IDojoInitLibraryDispatcherCopy of core::traits::Copy::; +impl IDojoInitLibraryDispatcherDrop of core::traits::Drop::; +impl IDojoInitLibraryDispatcherSerde of core::serde::Serde:: { + fn serialize(self: @IDojoInitLibraryDispatcher, ref output: core::array::Array) { + core::serde::Serde::serialize(self.class_hash, ref output) + } + fn deserialize(ref serialized: core::array::Span) -> core::option::Option { + core::option::Option::Some(IDojoInitLibraryDispatcher { + class_hash: core::serde::Serde::deserialize(ref serialized)?, + }) + } +} +impl StoreIDojoInitLibraryDispatcher of starknet::Store:: { + fn read(address_domain: u32, base: starknet::storage_access::StorageBaseAddress) -> starknet::SyscallResult { + let class_hash = starknet::Store::::read(address_domain, base)?; + starknet::SyscallResult::Ok( + IDojoInitLibraryDispatcher { + class_hash, + } + ) + } + fn write(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, value: IDojoInitLibraryDispatcher) -> starknet::SyscallResult<()> { + starknet::Store::::write(address_domain, base, value.class_hash)?; + starknet::SyscallResult::Ok(()) + } + fn read_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8) -> starknet::SyscallResult { + let class_hash = starknet::Store::::read_at_offset(address_domain, base, offset)?; + starknet::SyscallResult::Ok( + IDojoInitLibraryDispatcher { + class_hash, + } + ) + } + #[inline(always)] + fn write_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8, value: IDojoInitLibraryDispatcher) -> starknet::SyscallResult<()> { + starknet::Store::::write_at_offset(address_domain, base, offset, value.class_hash)?; + starknet::SyscallResult::Ok(()) + } + #[inline(always)] + fn size() -> u8 { + starknet::Store::::size() + } +} + +#[derive(Drop, Copy)] +pub struct IDojoInitLibraryDispatcherSubPointers { + pub class_hash: starknet::storage::StoragePointer, +} +impl IDojoInitLibraryDispatcherSubPointersImpl of starknet::storage::SubPointers { + type SubPointersType = IDojoInitLibraryDispatcherSubPointers; + fn sub_pointers(self: starknet::storage::StoragePointer) -> IDojoInitLibraryDispatcherSubPointers { + let base_address = self.__storage_pointer_address__; + let mut current_offset = self.__storage_pointer_offset__; + let class_hash_value = starknet::storage::StoragePointer { + __storage_pointer_address__: base_address, + __storage_pointer_offset__: current_offset, + }; + IDojoInitLibraryDispatcherSubPointers { + class_hash: class_hash_value, + } + } +} +#[derive(Drop, Copy)] +pub struct IDojoInitLibraryDispatcherSubPointersMut { + pub class_hash: starknet::storage::StoragePointer>, +} +impl IDojoInitLibraryDispatcherSubPointersMutImpl of starknet::storage::SubPointersMut { + type SubPointersType = IDojoInitLibraryDispatcherSubPointersMut; + fn sub_pointers_mut(self: starknet::storage::StoragePointer>) -> IDojoInitLibraryDispatcherSubPointersMut { + let base_address = self.__storage_pointer_address__; + let mut current_offset = self.__storage_pointer_offset__; + let class_hash_value = starknet::storage::StoragePointer { + __storage_pointer_address__: base_address, + __storage_pointer_offset__: current_offset, + }; + IDojoInitLibraryDispatcherSubPointersMut { + class_hash: class_hash_value, + } + } +} +impl IDojoInitSafeLibraryDispatcherCopy of core::traits::Copy::; +impl IDojoInitSafeLibraryDispatcherDrop of core::traits::Drop::; +impl IDojoInitSafeLibraryDispatcherSerde of core::serde::Serde:: { + fn serialize(self: @IDojoInitSafeLibraryDispatcher, ref output: core::array::Array) { + core::serde::Serde::serialize(self.class_hash, ref output) + } + fn deserialize(ref serialized: core::array::Span) -> core::option::Option { + core::option::Option::Some(IDojoInitSafeLibraryDispatcher { + class_hash: core::serde::Serde::deserialize(ref serialized)?, + }) + } +} +impl StoreIDojoInitSafeLibraryDispatcher of starknet::Store:: { + fn read(address_domain: u32, base: starknet::storage_access::StorageBaseAddress) -> starknet::SyscallResult { + let class_hash = starknet::Store::::read(address_domain, base)?; + starknet::SyscallResult::Ok( + IDojoInitSafeLibraryDispatcher { + class_hash, + } + ) + } + fn write(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, value: IDojoInitSafeLibraryDispatcher) -> starknet::SyscallResult<()> { + starknet::Store::::write(address_domain, base, value.class_hash)?; + starknet::SyscallResult::Ok(()) + } + fn read_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8) -> starknet::SyscallResult { + let class_hash = starknet::Store::::read_at_offset(address_domain, base, offset)?; + starknet::SyscallResult::Ok( + IDojoInitSafeLibraryDispatcher { + class_hash, + } + ) + } + #[inline(always)] + fn write_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8, value: IDojoInitSafeLibraryDispatcher) -> starknet::SyscallResult<()> { + starknet::Store::::write_at_offset(address_domain, base, offset, value.class_hash)?; + starknet::SyscallResult::Ok(()) + } + #[inline(always)] + fn size() -> u8 { + starknet::Store::::size() + } +} + +#[derive(Drop, Copy)] +pub struct IDojoInitSafeLibraryDispatcherSubPointers { + pub class_hash: starknet::storage::StoragePointer, +} +impl IDojoInitSafeLibraryDispatcherSubPointersImpl of starknet::storage::SubPointers { + type SubPointersType = IDojoInitSafeLibraryDispatcherSubPointers; + fn sub_pointers(self: starknet::storage::StoragePointer) -> IDojoInitSafeLibraryDispatcherSubPointers { + let base_address = self.__storage_pointer_address__; + let mut current_offset = self.__storage_pointer_offset__; + let class_hash_value = starknet::storage::StoragePointer { + __storage_pointer_address__: base_address, + __storage_pointer_offset__: current_offset, + }; + IDojoInitSafeLibraryDispatcherSubPointers { + class_hash: class_hash_value, + } + } +} +#[derive(Drop, Copy)] +pub struct IDojoInitSafeLibraryDispatcherSubPointersMut { + pub class_hash: starknet::storage::StoragePointer>, +} +impl IDojoInitSafeLibraryDispatcherSubPointersMutImpl of starknet::storage::SubPointersMut { + type SubPointersType = IDojoInitSafeLibraryDispatcherSubPointersMut; + fn sub_pointers_mut(self: starknet::storage::StoragePointer>) -> IDojoInitSafeLibraryDispatcherSubPointersMut { + let base_address = self.__storage_pointer_address__; + let mut current_offset = self.__storage_pointer_offset__; + let class_hash_value = starknet::storage::StoragePointer { + __storage_pointer_address__: base_address, + __storage_pointer_offset__: current_offset, + }; + IDojoInitSafeLibraryDispatcherSubPointersMut { + class_hash: class_hash_value, + } + } +} +impl IDojoInitSafeDispatcherCopy of core::traits::Copy::; +impl IDojoInitSafeDispatcherDrop of core::traits::Drop::; +impl IDojoInitSafeDispatcherSerde of core::serde::Serde:: { + fn serialize(self: @IDojoInitSafeDispatcher, ref output: core::array::Array) { + core::serde::Serde::serialize(self.contract_address, ref output) + } + fn deserialize(ref serialized: core::array::Span) -> core::option::Option { + core::option::Option::Some(IDojoInitSafeDispatcher { + contract_address: core::serde::Serde::deserialize(ref serialized)?, + }) + } +} +impl StoreIDojoInitSafeDispatcher of starknet::Store:: { + fn read(address_domain: u32, base: starknet::storage_access::StorageBaseAddress) -> starknet::SyscallResult { + let contract_address = starknet::Store::::read(address_domain, base)?; + starknet::SyscallResult::Ok( + IDojoInitSafeDispatcher { + contract_address, + } + ) + } + fn write(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, value: IDojoInitSafeDispatcher) -> starknet::SyscallResult<()> { + starknet::Store::::write(address_domain, base, value.contract_address)?; + starknet::SyscallResult::Ok(()) + } + fn read_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8) -> starknet::SyscallResult { + let contract_address = starknet::Store::::read_at_offset(address_domain, base, offset)?; + starknet::SyscallResult::Ok( + IDojoInitSafeDispatcher { + contract_address, + } + ) + } + #[inline(always)] + fn write_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8, value: IDojoInitSafeDispatcher) -> starknet::SyscallResult<()> { + starknet::Store::::write_at_offset(address_domain, base, offset, value.contract_address)?; + starknet::SyscallResult::Ok(()) + } + #[inline(always)] + fn size() -> u8 { + starknet::Store::::size() + } +} + +#[derive(Drop, Copy)] +pub struct IDojoInitSafeDispatcherSubPointers { + pub contract_address: starknet::storage::StoragePointer, +} +impl IDojoInitSafeDispatcherSubPointersImpl of starknet::storage::SubPointers { + type SubPointersType = IDojoInitSafeDispatcherSubPointers; + fn sub_pointers(self: starknet::storage::StoragePointer) -> IDojoInitSafeDispatcherSubPointers { + let base_address = self.__storage_pointer_address__; + let mut current_offset = self.__storage_pointer_offset__; + let contract_address_value = starknet::storage::StoragePointer { + __storage_pointer_address__: base_address, + __storage_pointer_offset__: current_offset, + }; + IDojoInitSafeDispatcherSubPointers { + contract_address: contract_address_value, + } + } +} +#[derive(Drop, Copy)] +pub struct IDojoInitSafeDispatcherSubPointersMut { + pub contract_address: starknet::storage::StoragePointer>, +} +impl IDojoInitSafeDispatcherSubPointersMutImpl of starknet::storage::SubPointersMut { + type SubPointersType = IDojoInitSafeDispatcherSubPointersMut; + fn sub_pointers_mut(self: starknet::storage::StoragePointer>) -> IDojoInitSafeDispatcherSubPointersMut { + let base_address = self.__storage_pointer_address__; + let mut current_offset = self.__storage_pointer_offset__; + let contract_address_value = starknet::storage::StoragePointer { + __storage_pointer_address__: base_address, + __storage_pointer_offset__: current_offset, + }; + IDojoInitSafeDispatcherSubPointersMut { + contract_address: contract_address_value, + } + } +} +impl StorageStorageBaseDrop of core::traits::Drop::; +impl StorageStorageBaseCopy of core::traits::Copy::; +impl StorageStorageBaseMutDrop of core::traits::Drop::; +impl StorageStorageBaseMutCopy of core::traits::Copy::; +impl IDojoInitDispatcherSubPointersDrop of core::traits::Drop::; +impl IDojoInitDispatcherSubPointersCopy of core::traits::Copy::; +impl IDojoInitDispatcherSubPointersMutDrop of core::traits::Drop::; +impl IDojoInitDispatcherSubPointersMutCopy of core::traits::Copy::; +impl IDojoInitLibraryDispatcherSubPointersDrop of core::traits::Drop::; +impl IDojoInitLibraryDispatcherSubPointersCopy of core::traits::Copy::; +impl IDojoInitLibraryDispatcherSubPointersMutDrop of core::traits::Drop::; +impl IDojoInitLibraryDispatcherSubPointersMutCopy of core::traits::Copy::; +impl IDojoInitSafeLibraryDispatcherSubPointersDrop of core::traits::Drop::; +impl IDojoInitSafeLibraryDispatcherSubPointersCopy of core::traits::Copy::; +impl IDojoInitSafeLibraryDispatcherSubPointersMutDrop of core::traits::Drop::; +impl IDojoInitSafeLibraryDispatcherSubPointersMutCopy of core::traits::Copy::; +impl IDojoInitSafeDispatcherSubPointersDrop of core::traits::Drop::; +impl IDojoInitSafeDispatcherSubPointersCopy of core::traits::Copy::; +impl IDojoInitSafeDispatcherSubPointersMutDrop of core::traits::Drop::; +impl IDojoInitSafeDispatcherSubPointersMutCopy of core::traits::Copy::; + + } + pub trait IEmptyTraitDispatcherTrait { +} + +#[derive(Copy, Drop, starknet::Store, Serde)] + pub struct IEmptyTraitDispatcher { + pub contract_address: starknet::ContractAddress, +} + +impl IEmptyTraitDispatcherImpl of IEmptyTraitDispatcherTrait { + +} + +#[derive(Copy, Drop, starknet::Store, Serde)] + pub struct IEmptyTraitLibraryDispatcher { + pub class_hash: starknet::ClassHash, +} + +impl IEmptyTraitLibraryDispatcherImpl of IEmptyTraitDispatcherTrait { + +} + + pub trait IEmptyTraitSafeDispatcherTrait { +} + +#[derive(Copy, Drop, starknet::Store, Serde)] + pub struct IEmptyTraitSafeLibraryDispatcher { + pub class_hash: starknet::ClassHash, +} + +impl IEmptyTraitSafeLibraryDispatcherImpl of IEmptyTraitSafeDispatcherTrait { + +} + + +#[derive(Copy, Drop, starknet::Store, Serde)] + pub struct IEmptyTraitSafeDispatcher { + pub contract_address: starknet::ContractAddress, +} + +impl IEmptyTraitSafeDispatcherImpl of IEmptyTraitSafeDispatcherTrait { + +} + pub trait IFaultyTraitDispatcherTrait { + fn do_with_attrs(self: T, p1: u8) -> u16; +} + +#[derive(Copy, Drop, starknet::Store, Serde)] + pub struct IFaultyTraitDispatcher { + pub contract_address: starknet::ContractAddress, +} + +impl IFaultyTraitDispatcherImpl of IFaultyTraitDispatcherTrait { + fn do_with_attrs(self: IFaultyTraitDispatcher, p1: u8) -> u16 { + let mut __calldata__ = core::traits::Default::default(); + core::serde::Serde::::serialize(@p1, ref __calldata__); + + let mut __dispatcher_return_data__ = starknet::syscalls::call_contract_syscall( + self.contract_address, + selector!("do_with_attrs"), + core::array::ArrayTrait::span(@__calldata__), + ); + let mut __dispatcher_return_data__ = starknet::SyscallResultTrait::unwrap_syscall(__dispatcher_return_data__); + core::option::OptionTrait::expect( + core::serde::Serde::::deserialize(ref __dispatcher_return_data__), + 'Returned data too short', + ) + } + +} + +#[derive(Copy, Drop, starknet::Store, Serde)] + pub struct IFaultyTraitLibraryDispatcher { + pub class_hash: starknet::ClassHash, +} + +impl IFaultyTraitLibraryDispatcherImpl of IFaultyTraitDispatcherTrait { + fn do_with_attrs(self: IFaultyTraitLibraryDispatcher, p1: u8) -> u16 { + let mut __calldata__ = core::traits::Default::default(); + core::serde::Serde::::serialize(@p1, ref __calldata__); + + let mut __dispatcher_return_data__ = starknet::syscalls::library_call_syscall( + self.class_hash, + selector!("do_with_attrs"), + core::array::ArrayTrait::span(@__calldata__), + ); + let mut __dispatcher_return_data__ = starknet::SyscallResultTrait::unwrap_syscall(__dispatcher_return_data__); + core::option::OptionTrait::expect( + core::serde::Serde::::deserialize(ref __dispatcher_return_data__), + 'Returned data too short', + ) + } + +} + + pub trait IFaultyTraitSafeDispatcherTrait { + #[unstable(feature: "safe_dispatcher")] + fn do_with_attrs(self: T, p1: u8) -> starknet::SyscallResult; +} + +#[derive(Copy, Drop, starknet::Store, Serde)] + pub struct IFaultyTraitSafeLibraryDispatcher { + pub class_hash: starknet::ClassHash, +} + +impl IFaultyTraitSafeLibraryDispatcherImpl of IFaultyTraitSafeDispatcherTrait { + fn do_with_attrs(self: IFaultyTraitSafeLibraryDispatcher, p1: u8) -> starknet::SyscallResult { + let mut __calldata__ = core::traits::Default::default(); + core::serde::Serde::::serialize(@p1, ref __calldata__); + + let mut __dispatcher_return_data__ = starknet::syscalls::library_call_syscall( + self.class_hash, + selector!("do_with_attrs"), + core::array::ArrayTrait::span(@__calldata__), + ); + let mut __dispatcher_return_data__ = __dispatcher_return_data__?; + Result::Ok( + core::option::OptionTrait::expect( + core::serde::Serde::::deserialize(ref __dispatcher_return_data__), + 'Returned data too short', + ) + ) + } + +} + + +#[derive(Copy, Drop, starknet::Store, Serde)] + pub struct IFaultyTraitSafeDispatcher { + pub contract_address: starknet::ContractAddress, +} + +impl IFaultyTraitSafeDispatcherImpl of IFaultyTraitSafeDispatcherTrait { + fn do_with_attrs(self: IFaultyTraitSafeDispatcher, p1: u8) -> starknet::SyscallResult { + let mut __calldata__ = core::traits::Default::default(); + core::serde::Serde::::serialize(@p1, ref __calldata__); + + let mut __dispatcher_return_data__ = starknet::syscalls::call_contract_syscall( + self.contract_address, + selector!("do_with_attrs"), + core::array::ArrayTrait::span(@__calldata__), + ); + let mut __dispatcher_return_data__ = __dispatcher_return_data__?; + Result::Ok( + core::option::OptionTrait::expect( + core::serde::Serde::::deserialize(ref __dispatcher_return_data__), + 'Returned data too short', + ) + ) + } + +} + pub trait INominalTraitDispatcherTrait { + fn do_no_param(self: T) -> felt252; +fn do_no_param_but_world(self: T) -> felt252; +fn do_no_param_but_world_ref(self: T) -> felt252; +fn do_params_no_world(self: T, p1: felt252, p2: u8) -> felt252; +fn do_params_and_world(self: T, p2: u8) -> felt252; +fn do_params_and_world_ref(self: T, p2: u8) -> felt252; +} + +#[derive(Copy, Drop, starknet::Store, Serde)] + pub struct INominalTraitDispatcher { + pub contract_address: starknet::ContractAddress, +} + +impl INominalTraitDispatcherImpl of INominalTraitDispatcherTrait { + fn do_no_param(self: INominalTraitDispatcher) -> felt252 { + let mut __calldata__ = core::traits::Default::default(); + + let mut __dispatcher_return_data__ = starknet::syscalls::call_contract_syscall( + self.contract_address, + selector!("do_no_param"), + core::array::ArrayTrait::span(@__calldata__), + ); + let mut __dispatcher_return_data__ = starknet::SyscallResultTrait::unwrap_syscall(__dispatcher_return_data__); + core::option::OptionTrait::expect( + core::serde::Serde::::deserialize(ref __dispatcher_return_data__), + 'Returned data too short', + ) + } +fn do_no_param_but_world(self: INominalTraitDispatcher) -> felt252 { + let mut __calldata__ = core::traits::Default::default(); + + let mut __dispatcher_return_data__ = starknet::syscalls::call_contract_syscall( + self.contract_address, + selector!("do_no_param_but_world"), + core::array::ArrayTrait::span(@__calldata__), + ); + let mut __dispatcher_return_data__ = starknet::SyscallResultTrait::unwrap_syscall(__dispatcher_return_data__); + core::option::OptionTrait::expect( + core::serde::Serde::::deserialize(ref __dispatcher_return_data__), + 'Returned data too short', + ) + } +fn do_no_param_but_world_ref(self: INominalTraitDispatcher) -> felt252 { + let mut __calldata__ = core::traits::Default::default(); + + let mut __dispatcher_return_data__ = starknet::syscalls::call_contract_syscall( + self.contract_address, + selector!("do_no_param_but_world_ref"), + core::array::ArrayTrait::span(@__calldata__), + ); + let mut __dispatcher_return_data__ = starknet::SyscallResultTrait::unwrap_syscall(__dispatcher_return_data__); + core::option::OptionTrait::expect( + core::serde::Serde::::deserialize(ref __dispatcher_return_data__), + 'Returned data too short', + ) + } +fn do_params_no_world(self: INominalTraitDispatcher, p1: felt252, p2: u8) -> felt252 { + let mut __calldata__ = core::traits::Default::default(); + core::serde::Serde::::serialize(@p1, ref __calldata__); + core::serde::Serde::::serialize(@p2, ref __calldata__); + + let mut __dispatcher_return_data__ = starknet::syscalls::call_contract_syscall( + self.contract_address, + selector!("do_params_no_world"), + core::array::ArrayTrait::span(@__calldata__), + ); + let mut __dispatcher_return_data__ = starknet::SyscallResultTrait::unwrap_syscall(__dispatcher_return_data__); + core::option::OptionTrait::expect( + core::serde::Serde::::deserialize(ref __dispatcher_return_data__), + 'Returned data too short', + ) + } +fn do_params_and_world(self: INominalTraitDispatcher, p2: u8) -> felt252 { + let mut __calldata__ = core::traits::Default::default(); + core::serde::Serde::::serialize(@p2, ref __calldata__); + + let mut __dispatcher_return_data__ = starknet::syscalls::call_contract_syscall( + self.contract_address, + selector!("do_params_and_world"), + core::array::ArrayTrait::span(@__calldata__), + ); + let mut __dispatcher_return_data__ = starknet::SyscallResultTrait::unwrap_syscall(__dispatcher_return_data__); + core::option::OptionTrait::expect( + core::serde::Serde::::deserialize(ref __dispatcher_return_data__), + 'Returned data too short', + ) + } +fn do_params_and_world_ref(self: INominalTraitDispatcher, p2: u8) -> felt252 { + let mut __calldata__ = core::traits::Default::default(); + core::serde::Serde::::serialize(@p2, ref __calldata__); + + let mut __dispatcher_return_data__ = starknet::syscalls::call_contract_syscall( + self.contract_address, + selector!("do_params_and_world_ref"), + core::array::ArrayTrait::span(@__calldata__), + ); + let mut __dispatcher_return_data__ = starknet::SyscallResultTrait::unwrap_syscall(__dispatcher_return_data__); + core::option::OptionTrait::expect( + core::serde::Serde::::deserialize(ref __dispatcher_return_data__), + 'Returned data too short', + ) + } + +} + +#[derive(Copy, Drop, starknet::Store, Serde)] + pub struct INominalTraitLibraryDispatcher { + pub class_hash: starknet::ClassHash, +} + +impl INominalTraitLibraryDispatcherImpl of INominalTraitDispatcherTrait { + fn do_no_param(self: INominalTraitLibraryDispatcher) -> felt252 { + let mut __calldata__ = core::traits::Default::default(); + + let mut __dispatcher_return_data__ = starknet::syscalls::library_call_syscall( + self.class_hash, + selector!("do_no_param"), + core::array::ArrayTrait::span(@__calldata__), + ); + let mut __dispatcher_return_data__ = starknet::SyscallResultTrait::unwrap_syscall(__dispatcher_return_data__); + core::option::OptionTrait::expect( + core::serde::Serde::::deserialize(ref __dispatcher_return_data__), + 'Returned data too short', + ) + } +fn do_no_param_but_world(self: INominalTraitLibraryDispatcher) -> felt252 { + let mut __calldata__ = core::traits::Default::default(); + + let mut __dispatcher_return_data__ = starknet::syscalls::library_call_syscall( + self.class_hash, + selector!("do_no_param_but_world"), + core::array::ArrayTrait::span(@__calldata__), + ); + let mut __dispatcher_return_data__ = starknet::SyscallResultTrait::unwrap_syscall(__dispatcher_return_data__); + core::option::OptionTrait::expect( + core::serde::Serde::::deserialize(ref __dispatcher_return_data__), + 'Returned data too short', + ) + } +fn do_no_param_but_world_ref(self: INominalTraitLibraryDispatcher) -> felt252 { + let mut __calldata__ = core::traits::Default::default(); + + let mut __dispatcher_return_data__ = starknet::syscalls::library_call_syscall( + self.class_hash, + selector!("do_no_param_but_world_ref"), + core::array::ArrayTrait::span(@__calldata__), + ); + let mut __dispatcher_return_data__ = starknet::SyscallResultTrait::unwrap_syscall(__dispatcher_return_data__); + core::option::OptionTrait::expect( + core::serde::Serde::::deserialize(ref __dispatcher_return_data__), + 'Returned data too short', + ) + } +fn do_params_no_world(self: INominalTraitLibraryDispatcher, p1: felt252, p2: u8) -> felt252 { + let mut __calldata__ = core::traits::Default::default(); + core::serde::Serde::::serialize(@p1, ref __calldata__); + core::serde::Serde::::serialize(@p2, ref __calldata__); + + let mut __dispatcher_return_data__ = starknet::syscalls::library_call_syscall( + self.class_hash, + selector!("do_params_no_world"), + core::array::ArrayTrait::span(@__calldata__), + ); + let mut __dispatcher_return_data__ = starknet::SyscallResultTrait::unwrap_syscall(__dispatcher_return_data__); + core::option::OptionTrait::expect( + core::serde::Serde::::deserialize(ref __dispatcher_return_data__), + 'Returned data too short', + ) + } +fn do_params_and_world(self: INominalTraitLibraryDispatcher, p2: u8) -> felt252 { + let mut __calldata__ = core::traits::Default::default(); + core::serde::Serde::::serialize(@p2, ref __calldata__); + + let mut __dispatcher_return_data__ = starknet::syscalls::library_call_syscall( + self.class_hash, + selector!("do_params_and_world"), + core::array::ArrayTrait::span(@__calldata__), + ); + let mut __dispatcher_return_data__ = starknet::SyscallResultTrait::unwrap_syscall(__dispatcher_return_data__); + core::option::OptionTrait::expect( + core::serde::Serde::::deserialize(ref __dispatcher_return_data__), + 'Returned data too short', + ) + } +fn do_params_and_world_ref(self: INominalTraitLibraryDispatcher, p2: u8) -> felt252 { + let mut __calldata__ = core::traits::Default::default(); + core::serde::Serde::::serialize(@p2, ref __calldata__); + + let mut __dispatcher_return_data__ = starknet::syscalls::library_call_syscall( + self.class_hash, + selector!("do_params_and_world_ref"), + core::array::ArrayTrait::span(@__calldata__), + ); + let mut __dispatcher_return_data__ = starknet::SyscallResultTrait::unwrap_syscall(__dispatcher_return_data__); + core::option::OptionTrait::expect( + core::serde::Serde::::deserialize(ref __dispatcher_return_data__), + 'Returned data too short', + ) + } + +} + + pub trait INominalTraitSafeDispatcherTrait { + #[unstable(feature: "safe_dispatcher")] + fn do_no_param(self: T) -> starknet::SyscallResult; + #[unstable(feature: "safe_dispatcher")] +fn do_no_param_but_world(self: T) -> starknet::SyscallResult; + #[unstable(feature: "safe_dispatcher")] +fn do_no_param_but_world_ref(self: T) -> starknet::SyscallResult; + #[unstable(feature: "safe_dispatcher")] +fn do_params_no_world(self: T, p1: felt252, p2: u8) -> starknet::SyscallResult; + #[unstable(feature: "safe_dispatcher")] +fn do_params_and_world(self: T, p2: u8) -> starknet::SyscallResult; + #[unstable(feature: "safe_dispatcher")] +fn do_params_and_world_ref(self: T, p2: u8) -> starknet::SyscallResult; +} + +#[derive(Copy, Drop, starknet::Store, Serde)] + pub struct INominalTraitSafeLibraryDispatcher { + pub class_hash: starknet::ClassHash, +} + +impl INominalTraitSafeLibraryDispatcherImpl of INominalTraitSafeDispatcherTrait { + fn do_no_param(self: INominalTraitSafeLibraryDispatcher) -> starknet::SyscallResult { + let mut __calldata__ = core::traits::Default::default(); + + let mut __dispatcher_return_data__ = starknet::syscalls::library_call_syscall( + self.class_hash, + selector!("do_no_param"), + core::array::ArrayTrait::span(@__calldata__), + ); + let mut __dispatcher_return_data__ = __dispatcher_return_data__?; + Result::Ok( + core::option::OptionTrait::expect( + core::serde::Serde::::deserialize(ref __dispatcher_return_data__), + 'Returned data too short', + ) + ) + } +fn do_no_param_but_world(self: INominalTraitSafeLibraryDispatcher) -> starknet::SyscallResult { + let mut __calldata__ = core::traits::Default::default(); + + let mut __dispatcher_return_data__ = starknet::syscalls::library_call_syscall( + self.class_hash, + selector!("do_no_param_but_world"), + core::array::ArrayTrait::span(@__calldata__), + ); + let mut __dispatcher_return_data__ = __dispatcher_return_data__?; + Result::Ok( + core::option::OptionTrait::expect( + core::serde::Serde::::deserialize(ref __dispatcher_return_data__), + 'Returned data too short', + ) + ) + } +fn do_no_param_but_world_ref(self: INominalTraitSafeLibraryDispatcher) -> starknet::SyscallResult { + let mut __calldata__ = core::traits::Default::default(); + + let mut __dispatcher_return_data__ = starknet::syscalls::library_call_syscall( + self.class_hash, + selector!("do_no_param_but_world_ref"), + core::array::ArrayTrait::span(@__calldata__), + ); + let mut __dispatcher_return_data__ = __dispatcher_return_data__?; + Result::Ok( + core::option::OptionTrait::expect( + core::serde::Serde::::deserialize(ref __dispatcher_return_data__), + 'Returned data too short', + ) + ) + } +fn do_params_no_world(self: INominalTraitSafeLibraryDispatcher, p1: felt252, p2: u8) -> starknet::SyscallResult { + let mut __calldata__ = core::traits::Default::default(); + core::serde::Serde::::serialize(@p1, ref __calldata__); + core::serde::Serde::::serialize(@p2, ref __calldata__); + + let mut __dispatcher_return_data__ = starknet::syscalls::library_call_syscall( + self.class_hash, + selector!("do_params_no_world"), + core::array::ArrayTrait::span(@__calldata__), + ); + let mut __dispatcher_return_data__ = __dispatcher_return_data__?; + Result::Ok( + core::option::OptionTrait::expect( + core::serde::Serde::::deserialize(ref __dispatcher_return_data__), + 'Returned data too short', + ) + ) + } +fn do_params_and_world(self: INominalTraitSafeLibraryDispatcher, p2: u8) -> starknet::SyscallResult { + let mut __calldata__ = core::traits::Default::default(); + core::serde::Serde::::serialize(@p2, ref __calldata__); + + let mut __dispatcher_return_data__ = starknet::syscalls::library_call_syscall( + self.class_hash, + selector!("do_params_and_world"), + core::array::ArrayTrait::span(@__calldata__), + ); + let mut __dispatcher_return_data__ = __dispatcher_return_data__?; + Result::Ok( + core::option::OptionTrait::expect( + core::serde::Serde::::deserialize(ref __dispatcher_return_data__), + 'Returned data too short', + ) + ) + } +fn do_params_and_world_ref(self: INominalTraitSafeLibraryDispatcher, p2: u8) -> starknet::SyscallResult { + let mut __calldata__ = core::traits::Default::default(); + core::serde::Serde::::serialize(@p2, ref __calldata__); + + let mut __dispatcher_return_data__ = starknet::syscalls::library_call_syscall( + self.class_hash, + selector!("do_params_and_world_ref"), + core::array::ArrayTrait::span(@__calldata__), + ); + let mut __dispatcher_return_data__ = __dispatcher_return_data__?; + Result::Ok( + core::option::OptionTrait::expect( + core::serde::Serde::::deserialize(ref __dispatcher_return_data__), + 'Returned data too short', + ) + ) + } + +} + + +#[derive(Copy, Drop, starknet::Store, Serde)] + pub struct INominalTraitSafeDispatcher { + pub contract_address: starknet::ContractAddress, +} + +impl INominalTraitSafeDispatcherImpl of INominalTraitSafeDispatcherTrait { + fn do_no_param(self: INominalTraitSafeDispatcher) -> starknet::SyscallResult { + let mut __calldata__ = core::traits::Default::default(); + + let mut __dispatcher_return_data__ = starknet::syscalls::call_contract_syscall( + self.contract_address, + selector!("do_no_param"), + core::array::ArrayTrait::span(@__calldata__), + ); + let mut __dispatcher_return_data__ = __dispatcher_return_data__?; + Result::Ok( + core::option::OptionTrait::expect( + core::serde::Serde::::deserialize(ref __dispatcher_return_data__), + 'Returned data too short', + ) + ) + } +fn do_no_param_but_world(self: INominalTraitSafeDispatcher) -> starknet::SyscallResult { + let mut __calldata__ = core::traits::Default::default(); + + let mut __dispatcher_return_data__ = starknet::syscalls::call_contract_syscall( + self.contract_address, + selector!("do_no_param_but_world"), + core::array::ArrayTrait::span(@__calldata__), + ); + let mut __dispatcher_return_data__ = __dispatcher_return_data__?; + Result::Ok( + core::option::OptionTrait::expect( + core::serde::Serde::::deserialize(ref __dispatcher_return_data__), + 'Returned data too short', + ) + ) + } +fn do_no_param_but_world_ref(self: INominalTraitSafeDispatcher) -> starknet::SyscallResult { + let mut __calldata__ = core::traits::Default::default(); + + let mut __dispatcher_return_data__ = starknet::syscalls::call_contract_syscall( + self.contract_address, + selector!("do_no_param_but_world_ref"), + core::array::ArrayTrait::span(@__calldata__), + ); + let mut __dispatcher_return_data__ = __dispatcher_return_data__?; + Result::Ok( + core::option::OptionTrait::expect( + core::serde::Serde::::deserialize(ref __dispatcher_return_data__), + 'Returned data too short', + ) + ) + } +fn do_params_no_world(self: INominalTraitSafeDispatcher, p1: felt252, p2: u8) -> starknet::SyscallResult { + let mut __calldata__ = core::traits::Default::default(); + core::serde::Serde::::serialize(@p1, ref __calldata__); + core::serde::Serde::::serialize(@p2, ref __calldata__); + + let mut __dispatcher_return_data__ = starknet::syscalls::call_contract_syscall( + self.contract_address, + selector!("do_params_no_world"), + core::array::ArrayTrait::span(@__calldata__), + ); + let mut __dispatcher_return_data__ = __dispatcher_return_data__?; + Result::Ok( + core::option::OptionTrait::expect( + core::serde::Serde::::deserialize(ref __dispatcher_return_data__), + 'Returned data too short', + ) + ) + } +fn do_params_and_world(self: INominalTraitSafeDispatcher, p2: u8) -> starknet::SyscallResult { + let mut __calldata__ = core::traits::Default::default(); + core::serde::Serde::::serialize(@p2, ref __calldata__); + + let mut __dispatcher_return_data__ = starknet::syscalls::call_contract_syscall( + self.contract_address, + selector!("do_params_and_world"), + core::array::ArrayTrait::span(@__calldata__), + ); + let mut __dispatcher_return_data__ = __dispatcher_return_data__?; + Result::Ok( + core::option::OptionTrait::expect( + core::serde::Serde::::deserialize(ref __dispatcher_return_data__), + 'Returned data too short', + ) + ) + } +fn do_params_and_world_ref(self: INominalTraitSafeDispatcher, p2: u8) -> starknet::SyscallResult { + let mut __calldata__ = core::traits::Default::default(); + core::serde::Serde::::serialize(@p2, ref __calldata__); + + let mut __dispatcher_return_data__ = starknet::syscalls::call_contract_syscall( + self.contract_address, + selector!("do_params_and_world_ref"), + core::array::ArrayTrait::span(@__calldata__), + ); + let mut __dispatcher_return_data__ = __dispatcher_return_data__?; + Result::Ok( + core::option::OptionTrait::expect( + core::serde::Serde::::deserialize(ref __dispatcher_return_data__), + 'Returned data too short', + ) + ) + } + +} + pub trait IFaultyTraitDispatcherTrait { +fn do_with_self_and_world_inv(self: T, self: @ContractState) -> felt252; +fn do_with_world_not_named_world(self: T, another_world: @IWorldDispatcher) -> felt252; +} + +#[derive(Copy, Drop, starknet::Store, Serde)] + pub struct IFaultyTraitDispatcher { + pub contract_address: starknet::ContractAddress, +} + +impl IFaultyTraitDispatcherImpl of IFaultyTraitDispatcherTrait { +fn do_with_self_and_world_inv(self: IFaultyTraitDispatcher, self: @ContractState) -> felt252 { + let mut __calldata__ = core::traits::Default::default(); + core::serde::Serde::<@ContractState>::serialize(@self, ref __calldata__); + + let mut __dispatcher_return_data__ = starknet::syscalls::call_contract_syscall( + self.contract_address, + selector!("do_with_self_and_world_inv"), + core::array::ArrayTrait::span(@__calldata__), + ); + let mut __dispatcher_return_data__ = starknet::SyscallResultTrait::unwrap_syscall(__dispatcher_return_data__); + core::option::OptionTrait::expect( + core::serde::Serde::::deserialize(ref __dispatcher_return_data__), + 'Returned data too short', + ) + } +fn do_with_world_not_named_world(self: IFaultyTraitDispatcher, another_world: @IWorldDispatcher) -> felt252 { + let mut __calldata__ = core::traits::Default::default(); + core::serde::Serde::<@IWorldDispatcher>::serialize(@another_world, ref __calldata__); + + let mut __dispatcher_return_data__ = starknet::syscalls::call_contract_syscall( + self.contract_address, + selector!("do_with_world_not_named_world"), + core::array::ArrayTrait::span(@__calldata__), + ); + let mut __dispatcher_return_data__ = starknet::SyscallResultTrait::unwrap_syscall(__dispatcher_return_data__); + core::option::OptionTrait::expect( + core::serde::Serde::::deserialize(ref __dispatcher_return_data__), + 'Returned data too short', + ) + } + +} + +#[derive(Copy, Drop, starknet::Store, Serde)] + pub struct IFaultyTraitLibraryDispatcher { + pub class_hash: starknet::ClassHash, +} + +impl IFaultyTraitLibraryDispatcherImpl of IFaultyTraitDispatcherTrait { +fn do_with_self_and_world_inv(self: IFaultyTraitLibraryDispatcher, self: @ContractState) -> felt252 { + let mut __calldata__ = core::traits::Default::default(); + core::serde::Serde::<@ContractState>::serialize(@self, ref __calldata__); + + let mut __dispatcher_return_data__ = starknet::syscalls::library_call_syscall( + self.class_hash, + selector!("do_with_self_and_world_inv"), + core::array::ArrayTrait::span(@__calldata__), + ); + let mut __dispatcher_return_data__ = starknet::SyscallResultTrait::unwrap_syscall(__dispatcher_return_data__); + core::option::OptionTrait::expect( + core::serde::Serde::::deserialize(ref __dispatcher_return_data__), + 'Returned data too short', + ) + } +fn do_with_world_not_named_world(self: IFaultyTraitLibraryDispatcher, another_world: @IWorldDispatcher) -> felt252 { + let mut __calldata__ = core::traits::Default::default(); + core::serde::Serde::<@IWorldDispatcher>::serialize(@another_world, ref __calldata__); + + let mut __dispatcher_return_data__ = starknet::syscalls::library_call_syscall( + self.class_hash, + selector!("do_with_world_not_named_world"), + core::array::ArrayTrait::span(@__calldata__), + ); + let mut __dispatcher_return_data__ = starknet::SyscallResultTrait::unwrap_syscall(__dispatcher_return_data__); + core::option::OptionTrait::expect( + core::serde::Serde::::deserialize(ref __dispatcher_return_data__), + 'Returned data too short', + ) + } + +} + + pub trait IFaultyTraitSafeDispatcherTrait { + #[unstable(feature: "safe_dispatcher")] +fn do_with_self_and_world_inv(self: T, self: @ContractState) -> starknet::SyscallResult; + #[unstable(feature: "safe_dispatcher")] +fn do_with_world_not_named_world(self: T, another_world: @IWorldDispatcher) -> starknet::SyscallResult; +} + +#[derive(Copy, Drop, starknet::Store, Serde)] + pub struct IFaultyTraitSafeLibraryDispatcher { + pub class_hash: starknet::ClassHash, +} + +impl IFaultyTraitSafeLibraryDispatcherImpl of IFaultyTraitSafeDispatcherTrait { +fn do_with_self_and_world_inv(self: IFaultyTraitSafeLibraryDispatcher, self: @ContractState) -> starknet::SyscallResult { + let mut __calldata__ = core::traits::Default::default(); + core::serde::Serde::<@ContractState>::serialize(@self, ref __calldata__); + + let mut __dispatcher_return_data__ = starknet::syscalls::library_call_syscall( + self.class_hash, + selector!("do_with_self_and_world_inv"), + core::array::ArrayTrait::span(@__calldata__), + ); + let mut __dispatcher_return_data__ = __dispatcher_return_data__?; + Result::Ok( + core::option::OptionTrait::expect( + core::serde::Serde::::deserialize(ref __dispatcher_return_data__), + 'Returned data too short', + ) + ) + } +fn do_with_world_not_named_world(self: IFaultyTraitSafeLibraryDispatcher, another_world: @IWorldDispatcher) -> starknet::SyscallResult { + let mut __calldata__ = core::traits::Default::default(); + core::serde::Serde::<@IWorldDispatcher>::serialize(@another_world, ref __calldata__); + + let mut __dispatcher_return_data__ = starknet::syscalls::library_call_syscall( + self.class_hash, + selector!("do_with_world_not_named_world"), + core::array::ArrayTrait::span(@__calldata__), + ); + let mut __dispatcher_return_data__ = __dispatcher_return_data__?; + Result::Ok( + core::option::OptionTrait::expect( + core::serde::Serde::::deserialize(ref __dispatcher_return_data__), + 'Returned data too short', + ) + ) + } + +} + + +#[derive(Copy, Drop, starknet::Store, Serde)] + pub struct IFaultyTraitSafeDispatcher { + pub contract_address: starknet::ContractAddress, +} + +impl IFaultyTraitSafeDispatcherImpl of IFaultyTraitSafeDispatcherTrait { +fn do_with_self_and_world_inv(self: IFaultyTraitSafeDispatcher, self: @ContractState) -> starknet::SyscallResult { + let mut __calldata__ = core::traits::Default::default(); + core::serde::Serde::<@ContractState>::serialize(@self, ref __calldata__); + + let mut __dispatcher_return_data__ = starknet::syscalls::call_contract_syscall( + self.contract_address, + selector!("do_with_self_and_world_inv"), + core::array::ArrayTrait::span(@__calldata__), + ); + let mut __dispatcher_return_data__ = __dispatcher_return_data__?; + Result::Ok( + core::option::OptionTrait::expect( + core::serde::Serde::::deserialize(ref __dispatcher_return_data__), + 'Returned data too short', + ) + ) + } +fn do_with_world_not_named_world(self: IFaultyTraitSafeDispatcher, another_world: @IWorldDispatcher) -> starknet::SyscallResult { + let mut __calldata__ = core::traits::Default::default(); + core::serde::Serde::<@IWorldDispatcher>::serialize(@another_world, ref __calldata__); + + let mut __dispatcher_return_data__ = starknet::syscalls::call_contract_syscall( + self.contract_address, + selector!("do_with_world_not_named_world"), + core::array::ArrayTrait::span(@__calldata__), + ); + let mut __dispatcher_return_data__ = __dispatcher_return_data__?; + Result::Ok( + core::option::OptionTrait::expect( + core::serde::Serde::::deserialize(ref __dispatcher_return_data__), + 'Returned data too short', + ) + ) + } + +} +impl IEmptyTraitDispatcherCopy of core::traits::Copy::; +impl IEmptyTraitDispatcherDrop of core::traits::Drop::; +impl IEmptyTraitDispatcherSerde of core::serde::Serde:: { + fn serialize(self: @IEmptyTraitDispatcher, ref output: core::array::Array) { + core::serde::Serde::serialize(self.contract_address, ref output) + } + fn deserialize(ref serialized: core::array::Span) -> core::option::Option { + core::option::Option::Some(IEmptyTraitDispatcher { + contract_address: core::serde::Serde::deserialize(ref serialized)?, + }) + } +} +impl StoreIEmptyTraitDispatcher of starknet::Store:: { + fn read(address_domain: u32, base: starknet::storage_access::StorageBaseAddress) -> starknet::SyscallResult { + let contract_address = starknet::Store::::read(address_domain, base)?; + starknet::SyscallResult::Ok( + IEmptyTraitDispatcher { + contract_address, + } + ) + } + fn write(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, value: IEmptyTraitDispatcher) -> starknet::SyscallResult<()> { + starknet::Store::::write(address_domain, base, value.contract_address)?; + starknet::SyscallResult::Ok(()) + } + fn read_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8) -> starknet::SyscallResult { + let contract_address = starknet::Store::::read_at_offset(address_domain, base, offset)?; + starknet::SyscallResult::Ok( + IEmptyTraitDispatcher { + contract_address, + } + ) + } + #[inline(always)] + fn write_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8, value: IEmptyTraitDispatcher) -> starknet::SyscallResult<()> { + starknet::Store::::write_at_offset(address_domain, base, offset, value.contract_address)?; + starknet::SyscallResult::Ok(()) + } + #[inline(always)] + fn size() -> u8 { + starknet::Store::::size() + } +} + +#[derive(Drop, Copy)] +pub struct IEmptyTraitDispatcherSubPointers { + pub contract_address: starknet::storage::StoragePointer, +} +impl IEmptyTraitDispatcherSubPointersImpl of starknet::storage::SubPointers { + type SubPointersType = IEmptyTraitDispatcherSubPointers; + fn sub_pointers(self: starknet::storage::StoragePointer) -> IEmptyTraitDispatcherSubPointers { + let base_address = self.__storage_pointer_address__; + let mut current_offset = self.__storage_pointer_offset__; + let contract_address_value = starknet::storage::StoragePointer { + __storage_pointer_address__: base_address, + __storage_pointer_offset__: current_offset, + }; + IEmptyTraitDispatcherSubPointers { + contract_address: contract_address_value, + } + } +} +#[derive(Drop, Copy)] +pub struct IEmptyTraitDispatcherSubPointersMut { + pub contract_address: starknet::storage::StoragePointer>, +} +impl IEmptyTraitDispatcherSubPointersMutImpl of starknet::storage::SubPointersMut { + type SubPointersType = IEmptyTraitDispatcherSubPointersMut; + fn sub_pointers_mut(self: starknet::storage::StoragePointer>) -> IEmptyTraitDispatcherSubPointersMut { + let base_address = self.__storage_pointer_address__; + let mut current_offset = self.__storage_pointer_offset__; + let contract_address_value = starknet::storage::StoragePointer { + __storage_pointer_address__: base_address, + __storage_pointer_offset__: current_offset, + }; + IEmptyTraitDispatcherSubPointersMut { + contract_address: contract_address_value, + } + } +} +impl IEmptyTraitLibraryDispatcherCopy of core::traits::Copy::; +impl IEmptyTraitLibraryDispatcherDrop of core::traits::Drop::; +impl IEmptyTraitLibraryDispatcherSerde of core::serde::Serde:: { + fn serialize(self: @IEmptyTraitLibraryDispatcher, ref output: core::array::Array) { + core::serde::Serde::serialize(self.class_hash, ref output) + } + fn deserialize(ref serialized: core::array::Span) -> core::option::Option { + core::option::Option::Some(IEmptyTraitLibraryDispatcher { + class_hash: core::serde::Serde::deserialize(ref serialized)?, + }) + } +} +impl StoreIEmptyTraitLibraryDispatcher of starknet::Store:: { + fn read(address_domain: u32, base: starknet::storage_access::StorageBaseAddress) -> starknet::SyscallResult { + let class_hash = starknet::Store::::read(address_domain, base)?; + starknet::SyscallResult::Ok( + IEmptyTraitLibraryDispatcher { + class_hash, + } + ) + } + fn write(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, value: IEmptyTraitLibraryDispatcher) -> starknet::SyscallResult<()> { + starknet::Store::::write(address_domain, base, value.class_hash)?; + starknet::SyscallResult::Ok(()) + } + fn read_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8) -> starknet::SyscallResult { + let class_hash = starknet::Store::::read_at_offset(address_domain, base, offset)?; + starknet::SyscallResult::Ok( + IEmptyTraitLibraryDispatcher { + class_hash, + } + ) + } + #[inline(always)] + fn write_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8, value: IEmptyTraitLibraryDispatcher) -> starknet::SyscallResult<()> { + starknet::Store::::write_at_offset(address_domain, base, offset, value.class_hash)?; + starknet::SyscallResult::Ok(()) + } + #[inline(always)] + fn size() -> u8 { + starknet::Store::::size() + } +} + +#[derive(Drop, Copy)] +pub struct IEmptyTraitLibraryDispatcherSubPointers { + pub class_hash: starknet::storage::StoragePointer, +} +impl IEmptyTraitLibraryDispatcherSubPointersImpl of starknet::storage::SubPointers { + type SubPointersType = IEmptyTraitLibraryDispatcherSubPointers; + fn sub_pointers(self: starknet::storage::StoragePointer) -> IEmptyTraitLibraryDispatcherSubPointers { + let base_address = self.__storage_pointer_address__; + let mut current_offset = self.__storage_pointer_offset__; + let class_hash_value = starknet::storage::StoragePointer { + __storage_pointer_address__: base_address, + __storage_pointer_offset__: current_offset, + }; + IEmptyTraitLibraryDispatcherSubPointers { + class_hash: class_hash_value, + } + } +} +#[derive(Drop, Copy)] +pub struct IEmptyTraitLibraryDispatcherSubPointersMut { + pub class_hash: starknet::storage::StoragePointer>, +} +impl IEmptyTraitLibraryDispatcherSubPointersMutImpl of starknet::storage::SubPointersMut { + type SubPointersType = IEmptyTraitLibraryDispatcherSubPointersMut; + fn sub_pointers_mut(self: starknet::storage::StoragePointer>) -> IEmptyTraitLibraryDispatcherSubPointersMut { + let base_address = self.__storage_pointer_address__; + let mut current_offset = self.__storage_pointer_offset__; + let class_hash_value = starknet::storage::StoragePointer { + __storage_pointer_address__: base_address, + __storage_pointer_offset__: current_offset, + }; + IEmptyTraitLibraryDispatcherSubPointersMut { + class_hash: class_hash_value, + } + } +} +impl IEmptyTraitSafeLibraryDispatcherCopy of core::traits::Copy::; +impl IEmptyTraitSafeLibraryDispatcherDrop of core::traits::Drop::; +impl IEmptyTraitSafeLibraryDispatcherSerde of core::serde::Serde:: { + fn serialize(self: @IEmptyTraitSafeLibraryDispatcher, ref output: core::array::Array) { + core::serde::Serde::serialize(self.class_hash, ref output) + } + fn deserialize(ref serialized: core::array::Span) -> core::option::Option { + core::option::Option::Some(IEmptyTraitSafeLibraryDispatcher { + class_hash: core::serde::Serde::deserialize(ref serialized)?, + }) + } +} +impl StoreIEmptyTraitSafeLibraryDispatcher of starknet::Store:: { + fn read(address_domain: u32, base: starknet::storage_access::StorageBaseAddress) -> starknet::SyscallResult { + let class_hash = starknet::Store::::read(address_domain, base)?; + starknet::SyscallResult::Ok( + IEmptyTraitSafeLibraryDispatcher { + class_hash, + } + ) + } + fn write(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, value: IEmptyTraitSafeLibraryDispatcher) -> starknet::SyscallResult<()> { + starknet::Store::::write(address_domain, base, value.class_hash)?; + starknet::SyscallResult::Ok(()) + } + fn read_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8) -> starknet::SyscallResult { + let class_hash = starknet::Store::::read_at_offset(address_domain, base, offset)?; + starknet::SyscallResult::Ok( + IEmptyTraitSafeLibraryDispatcher { + class_hash, + } + ) + } + #[inline(always)] + fn write_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8, value: IEmptyTraitSafeLibraryDispatcher) -> starknet::SyscallResult<()> { + starknet::Store::::write_at_offset(address_domain, base, offset, value.class_hash)?; + starknet::SyscallResult::Ok(()) + } + #[inline(always)] + fn size() -> u8 { + starknet::Store::::size() + } +} + +#[derive(Drop, Copy)] +pub struct IEmptyTraitSafeLibraryDispatcherSubPointers { + pub class_hash: starknet::storage::StoragePointer, +} +impl IEmptyTraitSafeLibraryDispatcherSubPointersImpl of starknet::storage::SubPointers { + type SubPointersType = IEmptyTraitSafeLibraryDispatcherSubPointers; + fn sub_pointers(self: starknet::storage::StoragePointer) -> IEmptyTraitSafeLibraryDispatcherSubPointers { + let base_address = self.__storage_pointer_address__; + let mut current_offset = self.__storage_pointer_offset__; + let class_hash_value = starknet::storage::StoragePointer { + __storage_pointer_address__: base_address, + __storage_pointer_offset__: current_offset, + }; + IEmptyTraitSafeLibraryDispatcherSubPointers { + class_hash: class_hash_value, + } + } +} +#[derive(Drop, Copy)] +pub struct IEmptyTraitSafeLibraryDispatcherSubPointersMut { + pub class_hash: starknet::storage::StoragePointer>, +} +impl IEmptyTraitSafeLibraryDispatcherSubPointersMutImpl of starknet::storage::SubPointersMut { + type SubPointersType = IEmptyTraitSafeLibraryDispatcherSubPointersMut; + fn sub_pointers_mut(self: starknet::storage::StoragePointer>) -> IEmptyTraitSafeLibraryDispatcherSubPointersMut { + let base_address = self.__storage_pointer_address__; + let mut current_offset = self.__storage_pointer_offset__; + let class_hash_value = starknet::storage::StoragePointer { + __storage_pointer_address__: base_address, + __storage_pointer_offset__: current_offset, + }; + IEmptyTraitSafeLibraryDispatcherSubPointersMut { + class_hash: class_hash_value, + } + } +} +impl IEmptyTraitSafeDispatcherCopy of core::traits::Copy::; +impl IEmptyTraitSafeDispatcherDrop of core::traits::Drop::; +impl IEmptyTraitSafeDispatcherSerde of core::serde::Serde:: { + fn serialize(self: @IEmptyTraitSafeDispatcher, ref output: core::array::Array) { + core::serde::Serde::serialize(self.contract_address, ref output) + } + fn deserialize(ref serialized: core::array::Span) -> core::option::Option { + core::option::Option::Some(IEmptyTraitSafeDispatcher { + contract_address: core::serde::Serde::deserialize(ref serialized)?, + }) + } +} +impl StoreIEmptyTraitSafeDispatcher of starknet::Store:: { + fn read(address_domain: u32, base: starknet::storage_access::StorageBaseAddress) -> starknet::SyscallResult { + let contract_address = starknet::Store::::read(address_domain, base)?; + starknet::SyscallResult::Ok( + IEmptyTraitSafeDispatcher { + contract_address, + } + ) + } + fn write(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, value: IEmptyTraitSafeDispatcher) -> starknet::SyscallResult<()> { + starknet::Store::::write(address_domain, base, value.contract_address)?; + starknet::SyscallResult::Ok(()) + } + fn read_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8) -> starknet::SyscallResult { + let contract_address = starknet::Store::::read_at_offset(address_domain, base, offset)?; + starknet::SyscallResult::Ok( + IEmptyTraitSafeDispatcher { + contract_address, + } + ) + } + #[inline(always)] + fn write_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8, value: IEmptyTraitSafeDispatcher) -> starknet::SyscallResult<()> { + starknet::Store::::write_at_offset(address_domain, base, offset, value.contract_address)?; + starknet::SyscallResult::Ok(()) + } + #[inline(always)] + fn size() -> u8 { + starknet::Store::::size() + } +} + +#[derive(Drop, Copy)] +pub struct IEmptyTraitSafeDispatcherSubPointers { + pub contract_address: starknet::storage::StoragePointer, +} +impl IEmptyTraitSafeDispatcherSubPointersImpl of starknet::storage::SubPointers { + type SubPointersType = IEmptyTraitSafeDispatcherSubPointers; + fn sub_pointers(self: starknet::storage::StoragePointer) -> IEmptyTraitSafeDispatcherSubPointers { + let base_address = self.__storage_pointer_address__; + let mut current_offset = self.__storage_pointer_offset__; + let contract_address_value = starknet::storage::StoragePointer { + __storage_pointer_address__: base_address, + __storage_pointer_offset__: current_offset, + }; + IEmptyTraitSafeDispatcherSubPointers { + contract_address: contract_address_value, + } + } +} +#[derive(Drop, Copy)] +pub struct IEmptyTraitSafeDispatcherSubPointersMut { + pub contract_address: starknet::storage::StoragePointer>, +} +impl IEmptyTraitSafeDispatcherSubPointersMutImpl of starknet::storage::SubPointersMut { + type SubPointersType = IEmptyTraitSafeDispatcherSubPointersMut; + fn sub_pointers_mut(self: starknet::storage::StoragePointer>) -> IEmptyTraitSafeDispatcherSubPointersMut { + let base_address = self.__storage_pointer_address__; + let mut current_offset = self.__storage_pointer_offset__; + let contract_address_value = starknet::storage::StoragePointer { + __storage_pointer_address__: base_address, + __storage_pointer_offset__: current_offset, + }; + IEmptyTraitSafeDispatcherSubPointersMut { + contract_address: contract_address_value, + } + } +} +impl IFaultyTraitDispatcherCopy of core::traits::Copy::; +impl IFaultyTraitDispatcherDrop of core::traits::Drop::; +impl IFaultyTraitDispatcherSerde of core::serde::Serde:: { + fn serialize(self: @IFaultyTraitDispatcher, ref output: core::array::Array) { + core::serde::Serde::serialize(self.contract_address, ref output) + } + fn deserialize(ref serialized: core::array::Span) -> core::option::Option { + core::option::Option::Some(IFaultyTraitDispatcher { + contract_address: core::serde::Serde::deserialize(ref serialized)?, + }) + } +} +impl StoreIFaultyTraitDispatcher of starknet::Store:: { + fn read(address_domain: u32, base: starknet::storage_access::StorageBaseAddress) -> starknet::SyscallResult { + let contract_address = starknet::Store::::read(address_domain, base)?; + starknet::SyscallResult::Ok( + IFaultyTraitDispatcher { + contract_address, + } + ) + } + fn write(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, value: IFaultyTraitDispatcher) -> starknet::SyscallResult<()> { + starknet::Store::::write(address_domain, base, value.contract_address)?; + starknet::SyscallResult::Ok(()) + } + fn read_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8) -> starknet::SyscallResult { + let contract_address = starknet::Store::::read_at_offset(address_domain, base, offset)?; + starknet::SyscallResult::Ok( + IFaultyTraitDispatcher { + contract_address, + } + ) + } + #[inline(always)] + fn write_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8, value: IFaultyTraitDispatcher) -> starknet::SyscallResult<()> { + starknet::Store::::write_at_offset(address_domain, base, offset, value.contract_address)?; + starknet::SyscallResult::Ok(()) + } + #[inline(always)] + fn size() -> u8 { + starknet::Store::::size() + } +} + +#[derive(Drop, Copy)] +pub struct IFaultyTraitDispatcherSubPointers { + pub contract_address: starknet::storage::StoragePointer, +} +impl IFaultyTraitDispatcherSubPointersImpl of starknet::storage::SubPointers { + type SubPointersType = IFaultyTraitDispatcherSubPointers; + fn sub_pointers(self: starknet::storage::StoragePointer) -> IFaultyTraitDispatcherSubPointers { + let base_address = self.__storage_pointer_address__; + let mut current_offset = self.__storage_pointer_offset__; + let contract_address_value = starknet::storage::StoragePointer { + __storage_pointer_address__: base_address, + __storage_pointer_offset__: current_offset, + }; + IFaultyTraitDispatcherSubPointers { + contract_address: contract_address_value, + } + } +} +#[derive(Drop, Copy)] +pub struct IFaultyTraitDispatcherSubPointersMut { + pub contract_address: starknet::storage::StoragePointer>, +} +impl IFaultyTraitDispatcherSubPointersMutImpl of starknet::storage::SubPointersMut { + type SubPointersType = IFaultyTraitDispatcherSubPointersMut; + fn sub_pointers_mut(self: starknet::storage::StoragePointer>) -> IFaultyTraitDispatcherSubPointersMut { + let base_address = self.__storage_pointer_address__; + let mut current_offset = self.__storage_pointer_offset__; + let contract_address_value = starknet::storage::StoragePointer { + __storage_pointer_address__: base_address, + __storage_pointer_offset__: current_offset, + }; + IFaultyTraitDispatcherSubPointersMut { + contract_address: contract_address_value, + } + } +} +impl IFaultyTraitLibraryDispatcherCopy of core::traits::Copy::; +impl IFaultyTraitLibraryDispatcherDrop of core::traits::Drop::; +impl IFaultyTraitLibraryDispatcherSerde of core::serde::Serde:: { + fn serialize(self: @IFaultyTraitLibraryDispatcher, ref output: core::array::Array) { + core::serde::Serde::serialize(self.class_hash, ref output) + } + fn deserialize(ref serialized: core::array::Span) -> core::option::Option { + core::option::Option::Some(IFaultyTraitLibraryDispatcher { + class_hash: core::serde::Serde::deserialize(ref serialized)?, + }) + } +} +impl StoreIFaultyTraitLibraryDispatcher of starknet::Store:: { + fn read(address_domain: u32, base: starknet::storage_access::StorageBaseAddress) -> starknet::SyscallResult { + let class_hash = starknet::Store::::read(address_domain, base)?; + starknet::SyscallResult::Ok( + IFaultyTraitLibraryDispatcher { + class_hash, + } + ) + } + fn write(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, value: IFaultyTraitLibraryDispatcher) -> starknet::SyscallResult<()> { + starknet::Store::::write(address_domain, base, value.class_hash)?; + starknet::SyscallResult::Ok(()) + } + fn read_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8) -> starknet::SyscallResult { + let class_hash = starknet::Store::::read_at_offset(address_domain, base, offset)?; + starknet::SyscallResult::Ok( + IFaultyTraitLibraryDispatcher { + class_hash, + } + ) + } + #[inline(always)] + fn write_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8, value: IFaultyTraitLibraryDispatcher) -> starknet::SyscallResult<()> { + starknet::Store::::write_at_offset(address_domain, base, offset, value.class_hash)?; + starknet::SyscallResult::Ok(()) + } + #[inline(always)] + fn size() -> u8 { + starknet::Store::::size() + } +} + +#[derive(Drop, Copy)] +pub struct IFaultyTraitLibraryDispatcherSubPointers { + pub class_hash: starknet::storage::StoragePointer, +} +impl IFaultyTraitLibraryDispatcherSubPointersImpl of starknet::storage::SubPointers { + type SubPointersType = IFaultyTraitLibraryDispatcherSubPointers; + fn sub_pointers(self: starknet::storage::StoragePointer) -> IFaultyTraitLibraryDispatcherSubPointers { + let base_address = self.__storage_pointer_address__; + let mut current_offset = self.__storage_pointer_offset__; + let class_hash_value = starknet::storage::StoragePointer { + __storage_pointer_address__: base_address, + __storage_pointer_offset__: current_offset, + }; + IFaultyTraitLibraryDispatcherSubPointers { + class_hash: class_hash_value, + } + } +} +#[derive(Drop, Copy)] +pub struct IFaultyTraitLibraryDispatcherSubPointersMut { + pub class_hash: starknet::storage::StoragePointer>, +} +impl IFaultyTraitLibraryDispatcherSubPointersMutImpl of starknet::storage::SubPointersMut { + type SubPointersType = IFaultyTraitLibraryDispatcherSubPointersMut; + fn sub_pointers_mut(self: starknet::storage::StoragePointer>) -> IFaultyTraitLibraryDispatcherSubPointersMut { + let base_address = self.__storage_pointer_address__; + let mut current_offset = self.__storage_pointer_offset__; + let class_hash_value = starknet::storage::StoragePointer { + __storage_pointer_address__: base_address, + __storage_pointer_offset__: current_offset, + }; + IFaultyTraitLibraryDispatcherSubPointersMut { + class_hash: class_hash_value, + } + } +} +impl IFaultyTraitSafeLibraryDispatcherCopy of core::traits::Copy::; +impl IFaultyTraitSafeLibraryDispatcherDrop of core::traits::Drop::; +impl IFaultyTraitSafeLibraryDispatcherSerde of core::serde::Serde:: { + fn serialize(self: @IFaultyTraitSafeLibraryDispatcher, ref output: core::array::Array) { + core::serde::Serde::serialize(self.class_hash, ref output) + } + fn deserialize(ref serialized: core::array::Span) -> core::option::Option { + core::option::Option::Some(IFaultyTraitSafeLibraryDispatcher { + class_hash: core::serde::Serde::deserialize(ref serialized)?, + }) + } +} +impl StoreIFaultyTraitSafeLibraryDispatcher of starknet::Store:: { + fn read(address_domain: u32, base: starknet::storage_access::StorageBaseAddress) -> starknet::SyscallResult { + let class_hash = starknet::Store::::read(address_domain, base)?; + starknet::SyscallResult::Ok( + IFaultyTraitSafeLibraryDispatcher { + class_hash, + } + ) + } + fn write(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, value: IFaultyTraitSafeLibraryDispatcher) -> starknet::SyscallResult<()> { + starknet::Store::::write(address_domain, base, value.class_hash)?; + starknet::SyscallResult::Ok(()) + } + fn read_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8) -> starknet::SyscallResult { + let class_hash = starknet::Store::::read_at_offset(address_domain, base, offset)?; + starknet::SyscallResult::Ok( + IFaultyTraitSafeLibraryDispatcher { + class_hash, + } + ) + } + #[inline(always)] + fn write_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8, value: IFaultyTraitSafeLibraryDispatcher) -> starknet::SyscallResult<()> { + starknet::Store::::write_at_offset(address_domain, base, offset, value.class_hash)?; + starknet::SyscallResult::Ok(()) + } + #[inline(always)] + fn size() -> u8 { + starknet::Store::::size() + } +} + +#[derive(Drop, Copy)] +pub struct IFaultyTraitSafeLibraryDispatcherSubPointers { + pub class_hash: starknet::storage::StoragePointer, +} +impl IFaultyTraitSafeLibraryDispatcherSubPointersImpl of starknet::storage::SubPointers { + type SubPointersType = IFaultyTraitSafeLibraryDispatcherSubPointers; + fn sub_pointers(self: starknet::storage::StoragePointer) -> IFaultyTraitSafeLibraryDispatcherSubPointers { + let base_address = self.__storage_pointer_address__; + let mut current_offset = self.__storage_pointer_offset__; + let class_hash_value = starknet::storage::StoragePointer { + __storage_pointer_address__: base_address, + __storage_pointer_offset__: current_offset, + }; + IFaultyTraitSafeLibraryDispatcherSubPointers { + class_hash: class_hash_value, + } + } +} +#[derive(Drop, Copy)] +pub struct IFaultyTraitSafeLibraryDispatcherSubPointersMut { + pub class_hash: starknet::storage::StoragePointer>, +} +impl IFaultyTraitSafeLibraryDispatcherSubPointersMutImpl of starknet::storage::SubPointersMut { + type SubPointersType = IFaultyTraitSafeLibraryDispatcherSubPointersMut; + fn sub_pointers_mut(self: starknet::storage::StoragePointer>) -> IFaultyTraitSafeLibraryDispatcherSubPointersMut { + let base_address = self.__storage_pointer_address__; + let mut current_offset = self.__storage_pointer_offset__; + let class_hash_value = starknet::storage::StoragePointer { + __storage_pointer_address__: base_address, + __storage_pointer_offset__: current_offset, + }; + IFaultyTraitSafeLibraryDispatcherSubPointersMut { + class_hash: class_hash_value, + } + } +} +impl IFaultyTraitSafeDispatcherCopy of core::traits::Copy::; +impl IFaultyTraitSafeDispatcherDrop of core::traits::Drop::; +impl IFaultyTraitSafeDispatcherSerde of core::serde::Serde:: { + fn serialize(self: @IFaultyTraitSafeDispatcher, ref output: core::array::Array) { + core::serde::Serde::serialize(self.contract_address, ref output) + } + fn deserialize(ref serialized: core::array::Span) -> core::option::Option { + core::option::Option::Some(IFaultyTraitSafeDispatcher { + contract_address: core::serde::Serde::deserialize(ref serialized)?, + }) + } +} +impl StoreIFaultyTraitSafeDispatcher of starknet::Store:: { + fn read(address_domain: u32, base: starknet::storage_access::StorageBaseAddress) -> starknet::SyscallResult { + let contract_address = starknet::Store::::read(address_domain, base)?; + starknet::SyscallResult::Ok( + IFaultyTraitSafeDispatcher { + contract_address, + } + ) + } + fn write(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, value: IFaultyTraitSafeDispatcher) -> starknet::SyscallResult<()> { + starknet::Store::::write(address_domain, base, value.contract_address)?; + starknet::SyscallResult::Ok(()) + } + fn read_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8) -> starknet::SyscallResult { + let contract_address = starknet::Store::::read_at_offset(address_domain, base, offset)?; + starknet::SyscallResult::Ok( + IFaultyTraitSafeDispatcher { + contract_address, + } + ) + } + #[inline(always)] + fn write_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8, value: IFaultyTraitSafeDispatcher) -> starknet::SyscallResult<()> { + starknet::Store::::write_at_offset(address_domain, base, offset, value.contract_address)?; + starknet::SyscallResult::Ok(()) + } + #[inline(always)] + fn size() -> u8 { + starknet::Store::::size() + } +} + +#[derive(Drop, Copy)] +pub struct IFaultyTraitSafeDispatcherSubPointers { + pub contract_address: starknet::storage::StoragePointer, +} +impl IFaultyTraitSafeDispatcherSubPointersImpl of starknet::storage::SubPointers { + type SubPointersType = IFaultyTraitSafeDispatcherSubPointers; + fn sub_pointers(self: starknet::storage::StoragePointer) -> IFaultyTraitSafeDispatcherSubPointers { + let base_address = self.__storage_pointer_address__; + let mut current_offset = self.__storage_pointer_offset__; + let contract_address_value = starknet::storage::StoragePointer { + __storage_pointer_address__: base_address, + __storage_pointer_offset__: current_offset, + }; + IFaultyTraitSafeDispatcherSubPointers { + contract_address: contract_address_value, + } + } +} +#[derive(Drop, Copy)] +pub struct IFaultyTraitSafeDispatcherSubPointersMut { + pub contract_address: starknet::storage::StoragePointer>, +} +impl IFaultyTraitSafeDispatcherSubPointersMutImpl of starknet::storage::SubPointersMut { + type SubPointersType = IFaultyTraitSafeDispatcherSubPointersMut; + fn sub_pointers_mut(self: starknet::storage::StoragePointer>) -> IFaultyTraitSafeDispatcherSubPointersMut { + let base_address = self.__storage_pointer_address__; + let mut current_offset = self.__storage_pointer_offset__; + let contract_address_value = starknet::storage::StoragePointer { + __storage_pointer_address__: base_address, + __storage_pointer_offset__: current_offset, + }; + IFaultyTraitSafeDispatcherSubPointersMut { + contract_address: contract_address_value, + } + } +} +impl INominalTraitDispatcherCopy of core::traits::Copy::; +impl INominalTraitDispatcherDrop of core::traits::Drop::; +impl INominalTraitDispatcherSerde of core::serde::Serde:: { + fn serialize(self: @INominalTraitDispatcher, ref output: core::array::Array) { + core::serde::Serde::serialize(self.contract_address, ref output) + } + fn deserialize(ref serialized: core::array::Span) -> core::option::Option { + core::option::Option::Some(INominalTraitDispatcher { + contract_address: core::serde::Serde::deserialize(ref serialized)?, + }) + } +} +impl StoreINominalTraitDispatcher of starknet::Store:: { + fn read(address_domain: u32, base: starknet::storage_access::StorageBaseAddress) -> starknet::SyscallResult { + let contract_address = starknet::Store::::read(address_domain, base)?; + starknet::SyscallResult::Ok( + INominalTraitDispatcher { + contract_address, + } + ) + } + fn write(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, value: INominalTraitDispatcher) -> starknet::SyscallResult<()> { + starknet::Store::::write(address_domain, base, value.contract_address)?; + starknet::SyscallResult::Ok(()) + } + fn read_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8) -> starknet::SyscallResult { + let contract_address = starknet::Store::::read_at_offset(address_domain, base, offset)?; + starknet::SyscallResult::Ok( + INominalTraitDispatcher { + contract_address, + } + ) + } + #[inline(always)] + fn write_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8, value: INominalTraitDispatcher) -> starknet::SyscallResult<()> { + starknet::Store::::write_at_offset(address_domain, base, offset, value.contract_address)?; + starknet::SyscallResult::Ok(()) + } + #[inline(always)] + fn size() -> u8 { + starknet::Store::::size() + } +} + +#[derive(Drop, Copy)] +pub struct INominalTraitDispatcherSubPointers { + pub contract_address: starknet::storage::StoragePointer, +} +impl INominalTraitDispatcherSubPointersImpl of starknet::storage::SubPointers { + type SubPointersType = INominalTraitDispatcherSubPointers; + fn sub_pointers(self: starknet::storage::StoragePointer) -> INominalTraitDispatcherSubPointers { + let base_address = self.__storage_pointer_address__; + let mut current_offset = self.__storage_pointer_offset__; + let contract_address_value = starknet::storage::StoragePointer { + __storage_pointer_address__: base_address, + __storage_pointer_offset__: current_offset, + }; + INominalTraitDispatcherSubPointers { + contract_address: contract_address_value, + } + } +} +#[derive(Drop, Copy)] +pub struct INominalTraitDispatcherSubPointersMut { + pub contract_address: starknet::storage::StoragePointer>, +} +impl INominalTraitDispatcherSubPointersMutImpl of starknet::storage::SubPointersMut { + type SubPointersType = INominalTraitDispatcherSubPointersMut; + fn sub_pointers_mut(self: starknet::storage::StoragePointer>) -> INominalTraitDispatcherSubPointersMut { + let base_address = self.__storage_pointer_address__; + let mut current_offset = self.__storage_pointer_offset__; + let contract_address_value = starknet::storage::StoragePointer { + __storage_pointer_address__: base_address, + __storage_pointer_offset__: current_offset, + }; + INominalTraitDispatcherSubPointersMut { + contract_address: contract_address_value, + } + } +} +impl INominalTraitLibraryDispatcherCopy of core::traits::Copy::; +impl INominalTraitLibraryDispatcherDrop of core::traits::Drop::; +impl INominalTraitLibraryDispatcherSerde of core::serde::Serde:: { + fn serialize(self: @INominalTraitLibraryDispatcher, ref output: core::array::Array) { + core::serde::Serde::serialize(self.class_hash, ref output) + } + fn deserialize(ref serialized: core::array::Span) -> core::option::Option { + core::option::Option::Some(INominalTraitLibraryDispatcher { + class_hash: core::serde::Serde::deserialize(ref serialized)?, + }) + } +} +impl StoreINominalTraitLibraryDispatcher of starknet::Store:: { + fn read(address_domain: u32, base: starknet::storage_access::StorageBaseAddress) -> starknet::SyscallResult { + let class_hash = starknet::Store::::read(address_domain, base)?; + starknet::SyscallResult::Ok( + INominalTraitLibraryDispatcher { + class_hash, + } + ) + } + fn write(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, value: INominalTraitLibraryDispatcher) -> starknet::SyscallResult<()> { + starknet::Store::::write(address_domain, base, value.class_hash)?; + starknet::SyscallResult::Ok(()) + } + fn read_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8) -> starknet::SyscallResult { + let class_hash = starknet::Store::::read_at_offset(address_domain, base, offset)?; + starknet::SyscallResult::Ok( + INominalTraitLibraryDispatcher { + class_hash, + } + ) + } + #[inline(always)] + fn write_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8, value: INominalTraitLibraryDispatcher) -> starknet::SyscallResult<()> { + starknet::Store::::write_at_offset(address_domain, base, offset, value.class_hash)?; + starknet::SyscallResult::Ok(()) + } + #[inline(always)] + fn size() -> u8 { + starknet::Store::::size() + } +} + +#[derive(Drop, Copy)] +pub struct INominalTraitLibraryDispatcherSubPointers { + pub class_hash: starknet::storage::StoragePointer, +} +impl INominalTraitLibraryDispatcherSubPointersImpl of starknet::storage::SubPointers { + type SubPointersType = INominalTraitLibraryDispatcherSubPointers; + fn sub_pointers(self: starknet::storage::StoragePointer) -> INominalTraitLibraryDispatcherSubPointers { + let base_address = self.__storage_pointer_address__; + let mut current_offset = self.__storage_pointer_offset__; + let class_hash_value = starknet::storage::StoragePointer { + __storage_pointer_address__: base_address, + __storage_pointer_offset__: current_offset, + }; + INominalTraitLibraryDispatcherSubPointers { + class_hash: class_hash_value, + } + } +} +#[derive(Drop, Copy)] +pub struct INominalTraitLibraryDispatcherSubPointersMut { + pub class_hash: starknet::storage::StoragePointer>, +} +impl INominalTraitLibraryDispatcherSubPointersMutImpl of starknet::storage::SubPointersMut { + type SubPointersType = INominalTraitLibraryDispatcherSubPointersMut; + fn sub_pointers_mut(self: starknet::storage::StoragePointer>) -> INominalTraitLibraryDispatcherSubPointersMut { + let base_address = self.__storage_pointer_address__; + let mut current_offset = self.__storage_pointer_offset__; + let class_hash_value = starknet::storage::StoragePointer { + __storage_pointer_address__: base_address, + __storage_pointer_offset__: current_offset, + }; + INominalTraitLibraryDispatcherSubPointersMut { + class_hash: class_hash_value, + } + } +} +impl INominalTraitSafeLibraryDispatcherCopy of core::traits::Copy::; +impl INominalTraitSafeLibraryDispatcherDrop of core::traits::Drop::; +impl INominalTraitSafeLibraryDispatcherSerde of core::serde::Serde:: { + fn serialize(self: @INominalTraitSafeLibraryDispatcher, ref output: core::array::Array) { + core::serde::Serde::serialize(self.class_hash, ref output) + } + fn deserialize(ref serialized: core::array::Span) -> core::option::Option { + core::option::Option::Some(INominalTraitSafeLibraryDispatcher { + class_hash: core::serde::Serde::deserialize(ref serialized)?, + }) + } +} +impl StoreINominalTraitSafeLibraryDispatcher of starknet::Store:: { + fn read(address_domain: u32, base: starknet::storage_access::StorageBaseAddress) -> starknet::SyscallResult { + let class_hash = starknet::Store::::read(address_domain, base)?; + starknet::SyscallResult::Ok( + INominalTraitSafeLibraryDispatcher { + class_hash, + } + ) + } + fn write(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, value: INominalTraitSafeLibraryDispatcher) -> starknet::SyscallResult<()> { + starknet::Store::::write(address_domain, base, value.class_hash)?; + starknet::SyscallResult::Ok(()) + } + fn read_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8) -> starknet::SyscallResult { + let class_hash = starknet::Store::::read_at_offset(address_domain, base, offset)?; + starknet::SyscallResult::Ok( + INominalTraitSafeLibraryDispatcher { + class_hash, + } + ) + } + #[inline(always)] + fn write_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8, value: INominalTraitSafeLibraryDispatcher) -> starknet::SyscallResult<()> { + starknet::Store::::write_at_offset(address_domain, base, offset, value.class_hash)?; + starknet::SyscallResult::Ok(()) + } + #[inline(always)] + fn size() -> u8 { + starknet::Store::::size() + } +} + +#[derive(Drop, Copy)] +pub struct INominalTraitSafeLibraryDispatcherSubPointers { + pub class_hash: starknet::storage::StoragePointer, +} +impl INominalTraitSafeLibraryDispatcherSubPointersImpl of starknet::storage::SubPointers { + type SubPointersType = INominalTraitSafeLibraryDispatcherSubPointers; + fn sub_pointers(self: starknet::storage::StoragePointer) -> INominalTraitSafeLibraryDispatcherSubPointers { + let base_address = self.__storage_pointer_address__; + let mut current_offset = self.__storage_pointer_offset__; + let class_hash_value = starknet::storage::StoragePointer { + __storage_pointer_address__: base_address, + __storage_pointer_offset__: current_offset, + }; + INominalTraitSafeLibraryDispatcherSubPointers { + class_hash: class_hash_value, + } + } +} +#[derive(Drop, Copy)] +pub struct INominalTraitSafeLibraryDispatcherSubPointersMut { + pub class_hash: starknet::storage::StoragePointer>, +} +impl INominalTraitSafeLibraryDispatcherSubPointersMutImpl of starknet::storage::SubPointersMut { + type SubPointersType = INominalTraitSafeLibraryDispatcherSubPointersMut; + fn sub_pointers_mut(self: starknet::storage::StoragePointer>) -> INominalTraitSafeLibraryDispatcherSubPointersMut { + let base_address = self.__storage_pointer_address__; + let mut current_offset = self.__storage_pointer_offset__; + let class_hash_value = starknet::storage::StoragePointer { + __storage_pointer_address__: base_address, + __storage_pointer_offset__: current_offset, + }; + INominalTraitSafeLibraryDispatcherSubPointersMut { + class_hash: class_hash_value, + } + } +} +impl INominalTraitSafeDispatcherCopy of core::traits::Copy::; +impl INominalTraitSafeDispatcherDrop of core::traits::Drop::; +impl INominalTraitSafeDispatcherSerde of core::serde::Serde:: { + fn serialize(self: @INominalTraitSafeDispatcher, ref output: core::array::Array) { + core::serde::Serde::serialize(self.contract_address, ref output) + } + fn deserialize(ref serialized: core::array::Span) -> core::option::Option { + core::option::Option::Some(INominalTraitSafeDispatcher { + contract_address: core::serde::Serde::deserialize(ref serialized)?, + }) + } +} +impl StoreINominalTraitSafeDispatcher of starknet::Store:: { + fn read(address_domain: u32, base: starknet::storage_access::StorageBaseAddress) -> starknet::SyscallResult { + let contract_address = starknet::Store::::read(address_domain, base)?; + starknet::SyscallResult::Ok( + INominalTraitSafeDispatcher { + contract_address, + } + ) + } + fn write(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, value: INominalTraitSafeDispatcher) -> starknet::SyscallResult<()> { + starknet::Store::::write(address_domain, base, value.contract_address)?; + starknet::SyscallResult::Ok(()) + } + fn read_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8) -> starknet::SyscallResult { + let contract_address = starknet::Store::::read_at_offset(address_domain, base, offset)?; + starknet::SyscallResult::Ok( + INominalTraitSafeDispatcher { + contract_address, + } + ) + } + #[inline(always)] + fn write_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8, value: INominalTraitSafeDispatcher) -> starknet::SyscallResult<()> { + starknet::Store::::write_at_offset(address_domain, base, offset, value.contract_address)?; + starknet::SyscallResult::Ok(()) + } + #[inline(always)] + fn size() -> u8 { + starknet::Store::::size() + } +} + +#[derive(Drop, Copy)] +pub struct INominalTraitSafeDispatcherSubPointers { + pub contract_address: starknet::storage::StoragePointer, +} +impl INominalTraitSafeDispatcherSubPointersImpl of starknet::storage::SubPointers { + type SubPointersType = INominalTraitSafeDispatcherSubPointers; + fn sub_pointers(self: starknet::storage::StoragePointer) -> INominalTraitSafeDispatcherSubPointers { + let base_address = self.__storage_pointer_address__; + let mut current_offset = self.__storage_pointer_offset__; + let contract_address_value = starknet::storage::StoragePointer { + __storage_pointer_address__: base_address, + __storage_pointer_offset__: current_offset, + }; + INominalTraitSafeDispatcherSubPointers { + contract_address: contract_address_value, + } + } +} +#[derive(Drop, Copy)] +pub struct INominalTraitSafeDispatcherSubPointersMut { + pub contract_address: starknet::storage::StoragePointer>, +} +impl INominalTraitSafeDispatcherSubPointersMutImpl of starknet::storage::SubPointersMut { + type SubPointersType = INominalTraitSafeDispatcherSubPointersMut; + fn sub_pointers_mut(self: starknet::storage::StoragePointer>) -> INominalTraitSafeDispatcherSubPointersMut { + let base_address = self.__storage_pointer_address__; + let mut current_offset = self.__storage_pointer_offset__; + let contract_address_value = starknet::storage::StoragePointer { + __storage_pointer_address__: base_address, + __storage_pointer_offset__: current_offset, + }; + INominalTraitSafeDispatcherSubPointersMut { + contract_address: contract_address_value, + } + } +} +impl IFaultyTraitDispatcherCopy of core::traits::Copy::; +impl IFaultyTraitDispatcherDrop of core::traits::Drop::; +impl IFaultyTraitDispatcherSerde of core::serde::Serde:: { + fn serialize(self: @IFaultyTraitDispatcher, ref output: core::array::Array) { + core::serde::Serde::serialize(self.contract_address, ref output) + } + fn deserialize(ref serialized: core::array::Span) -> core::option::Option { + core::option::Option::Some(IFaultyTraitDispatcher { + contract_address: core::serde::Serde::deserialize(ref serialized)?, + }) + } +} +impl StoreIFaultyTraitDispatcher of starknet::Store:: { + fn read(address_domain: u32, base: starknet::storage_access::StorageBaseAddress) -> starknet::SyscallResult { + let contract_address = starknet::Store::::read(address_domain, base)?; + starknet::SyscallResult::Ok( + IFaultyTraitDispatcher { + contract_address, + } + ) + } + fn write(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, value: IFaultyTraitDispatcher) -> starknet::SyscallResult<()> { + starknet::Store::::write(address_domain, base, value.contract_address)?; + starknet::SyscallResult::Ok(()) + } + fn read_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8) -> starknet::SyscallResult { + let contract_address = starknet::Store::::read_at_offset(address_domain, base, offset)?; + starknet::SyscallResult::Ok( + IFaultyTraitDispatcher { + contract_address, + } + ) + } + #[inline(always)] + fn write_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8, value: IFaultyTraitDispatcher) -> starknet::SyscallResult<()> { + starknet::Store::::write_at_offset(address_domain, base, offset, value.contract_address)?; + starknet::SyscallResult::Ok(()) + } + #[inline(always)] + fn size() -> u8 { + starknet::Store::::size() + } +} + +#[derive(Drop, Copy)] +pub struct IFaultyTraitDispatcherSubPointers { + pub contract_address: starknet::storage::StoragePointer, +} +impl IFaultyTraitDispatcherSubPointersImpl of starknet::storage::SubPointers { + type SubPointersType = IFaultyTraitDispatcherSubPointers; + fn sub_pointers(self: starknet::storage::StoragePointer) -> IFaultyTraitDispatcherSubPointers { + let base_address = self.__storage_pointer_address__; + let mut current_offset = self.__storage_pointer_offset__; + let contract_address_value = starknet::storage::StoragePointer { + __storage_pointer_address__: base_address, + __storage_pointer_offset__: current_offset, + }; + IFaultyTraitDispatcherSubPointers { + contract_address: contract_address_value, + } + } +} +#[derive(Drop, Copy)] +pub struct IFaultyTraitDispatcherSubPointersMut { + pub contract_address: starknet::storage::StoragePointer>, +} +impl IFaultyTraitDispatcherSubPointersMutImpl of starknet::storage::SubPointersMut { + type SubPointersType = IFaultyTraitDispatcherSubPointersMut; + fn sub_pointers_mut(self: starknet::storage::StoragePointer>) -> IFaultyTraitDispatcherSubPointersMut { + let base_address = self.__storage_pointer_address__; + let mut current_offset = self.__storage_pointer_offset__; + let contract_address_value = starknet::storage::StoragePointer { + __storage_pointer_address__: base_address, + __storage_pointer_offset__: current_offset, + }; + IFaultyTraitDispatcherSubPointersMut { + contract_address: contract_address_value, + } + } +} +impl IFaultyTraitLibraryDispatcherCopy of core::traits::Copy::; +impl IFaultyTraitLibraryDispatcherDrop of core::traits::Drop::; +impl IFaultyTraitLibraryDispatcherSerde of core::serde::Serde:: { + fn serialize(self: @IFaultyTraitLibraryDispatcher, ref output: core::array::Array) { + core::serde::Serde::serialize(self.class_hash, ref output) + } + fn deserialize(ref serialized: core::array::Span) -> core::option::Option { + core::option::Option::Some(IFaultyTraitLibraryDispatcher { + class_hash: core::serde::Serde::deserialize(ref serialized)?, + }) + } +} +impl StoreIFaultyTraitLibraryDispatcher of starknet::Store:: { + fn read(address_domain: u32, base: starknet::storage_access::StorageBaseAddress) -> starknet::SyscallResult { + let class_hash = starknet::Store::::read(address_domain, base)?; + starknet::SyscallResult::Ok( + IFaultyTraitLibraryDispatcher { + class_hash, + } + ) + } + fn write(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, value: IFaultyTraitLibraryDispatcher) -> starknet::SyscallResult<()> { + starknet::Store::::write(address_domain, base, value.class_hash)?; + starknet::SyscallResult::Ok(()) + } + fn read_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8) -> starknet::SyscallResult { + let class_hash = starknet::Store::::read_at_offset(address_domain, base, offset)?; + starknet::SyscallResult::Ok( + IFaultyTraitLibraryDispatcher { + class_hash, + } + ) + } + #[inline(always)] + fn write_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8, value: IFaultyTraitLibraryDispatcher) -> starknet::SyscallResult<()> { + starknet::Store::::write_at_offset(address_domain, base, offset, value.class_hash)?; + starknet::SyscallResult::Ok(()) + } + #[inline(always)] + fn size() -> u8 { + starknet::Store::::size() + } +} + +#[derive(Drop, Copy)] +pub struct IFaultyTraitLibraryDispatcherSubPointers { + pub class_hash: starknet::storage::StoragePointer, +} +impl IFaultyTraitLibraryDispatcherSubPointersImpl of starknet::storage::SubPointers { + type SubPointersType = IFaultyTraitLibraryDispatcherSubPointers; + fn sub_pointers(self: starknet::storage::StoragePointer) -> IFaultyTraitLibraryDispatcherSubPointers { + let base_address = self.__storage_pointer_address__; + let mut current_offset = self.__storage_pointer_offset__; + let class_hash_value = starknet::storage::StoragePointer { + __storage_pointer_address__: base_address, + __storage_pointer_offset__: current_offset, + }; + IFaultyTraitLibraryDispatcherSubPointers { + class_hash: class_hash_value, + } + } +} +#[derive(Drop, Copy)] +pub struct IFaultyTraitLibraryDispatcherSubPointersMut { + pub class_hash: starknet::storage::StoragePointer>, +} +impl IFaultyTraitLibraryDispatcherSubPointersMutImpl of starknet::storage::SubPointersMut { + type SubPointersType = IFaultyTraitLibraryDispatcherSubPointersMut; + fn sub_pointers_mut(self: starknet::storage::StoragePointer>) -> IFaultyTraitLibraryDispatcherSubPointersMut { + let base_address = self.__storage_pointer_address__; + let mut current_offset = self.__storage_pointer_offset__; + let class_hash_value = starknet::storage::StoragePointer { + __storage_pointer_address__: base_address, + __storage_pointer_offset__: current_offset, + }; + IFaultyTraitLibraryDispatcherSubPointersMut { + class_hash: class_hash_value, + } + } +} +impl IFaultyTraitSafeLibraryDispatcherCopy of core::traits::Copy::; +impl IFaultyTraitSafeLibraryDispatcherDrop of core::traits::Drop::; +impl IFaultyTraitSafeLibraryDispatcherSerde of core::serde::Serde:: { + fn serialize(self: @IFaultyTraitSafeLibraryDispatcher, ref output: core::array::Array) { + core::serde::Serde::serialize(self.class_hash, ref output) + } + fn deserialize(ref serialized: core::array::Span) -> core::option::Option { + core::option::Option::Some(IFaultyTraitSafeLibraryDispatcher { + class_hash: core::serde::Serde::deserialize(ref serialized)?, + }) + } +} +impl StoreIFaultyTraitSafeLibraryDispatcher of starknet::Store:: { + fn read(address_domain: u32, base: starknet::storage_access::StorageBaseAddress) -> starknet::SyscallResult { + let class_hash = starknet::Store::::read(address_domain, base)?; + starknet::SyscallResult::Ok( + IFaultyTraitSafeLibraryDispatcher { + class_hash, + } + ) + } + fn write(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, value: IFaultyTraitSafeLibraryDispatcher) -> starknet::SyscallResult<()> { + starknet::Store::::write(address_domain, base, value.class_hash)?; + starknet::SyscallResult::Ok(()) + } + fn read_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8) -> starknet::SyscallResult { + let class_hash = starknet::Store::::read_at_offset(address_domain, base, offset)?; + starknet::SyscallResult::Ok( + IFaultyTraitSafeLibraryDispatcher { + class_hash, + } + ) + } + #[inline(always)] + fn write_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8, value: IFaultyTraitSafeLibraryDispatcher) -> starknet::SyscallResult<()> { + starknet::Store::::write_at_offset(address_domain, base, offset, value.class_hash)?; + starknet::SyscallResult::Ok(()) + } + #[inline(always)] + fn size() -> u8 { + starknet::Store::::size() + } +} + +#[derive(Drop, Copy)] +pub struct IFaultyTraitSafeLibraryDispatcherSubPointers { + pub class_hash: starknet::storage::StoragePointer, +} +impl IFaultyTraitSafeLibraryDispatcherSubPointersImpl of starknet::storage::SubPointers { + type SubPointersType = IFaultyTraitSafeLibraryDispatcherSubPointers; + fn sub_pointers(self: starknet::storage::StoragePointer) -> IFaultyTraitSafeLibraryDispatcherSubPointers { + let base_address = self.__storage_pointer_address__; + let mut current_offset = self.__storage_pointer_offset__; + let class_hash_value = starknet::storage::StoragePointer { + __storage_pointer_address__: base_address, + __storage_pointer_offset__: current_offset, + }; + IFaultyTraitSafeLibraryDispatcherSubPointers { + class_hash: class_hash_value, + } + } +} +#[derive(Drop, Copy)] +pub struct IFaultyTraitSafeLibraryDispatcherSubPointersMut { + pub class_hash: starknet::storage::StoragePointer>, +} +impl IFaultyTraitSafeLibraryDispatcherSubPointersMutImpl of starknet::storage::SubPointersMut { + type SubPointersType = IFaultyTraitSafeLibraryDispatcherSubPointersMut; + fn sub_pointers_mut(self: starknet::storage::StoragePointer>) -> IFaultyTraitSafeLibraryDispatcherSubPointersMut { + let base_address = self.__storage_pointer_address__; + let mut current_offset = self.__storage_pointer_offset__; + let class_hash_value = starknet::storage::StoragePointer { + __storage_pointer_address__: base_address, + __storage_pointer_offset__: current_offset, + }; + IFaultyTraitSafeLibraryDispatcherSubPointersMut { + class_hash: class_hash_value, + } + } +} +impl IFaultyTraitSafeDispatcherCopy of core::traits::Copy::; +impl IFaultyTraitSafeDispatcherDrop of core::traits::Drop::; +impl IFaultyTraitSafeDispatcherSerde of core::serde::Serde:: { + fn serialize(self: @IFaultyTraitSafeDispatcher, ref output: core::array::Array) { + core::serde::Serde::serialize(self.contract_address, ref output) + } + fn deserialize(ref serialized: core::array::Span) -> core::option::Option { + core::option::Option::Some(IFaultyTraitSafeDispatcher { + contract_address: core::serde::Serde::deserialize(ref serialized)?, + }) + } +} +impl StoreIFaultyTraitSafeDispatcher of starknet::Store:: { + fn read(address_domain: u32, base: starknet::storage_access::StorageBaseAddress) -> starknet::SyscallResult { + let contract_address = starknet::Store::::read(address_domain, base)?; + starknet::SyscallResult::Ok( + IFaultyTraitSafeDispatcher { + contract_address, + } + ) + } + fn write(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, value: IFaultyTraitSafeDispatcher) -> starknet::SyscallResult<()> { + starknet::Store::::write(address_domain, base, value.contract_address)?; + starknet::SyscallResult::Ok(()) + } + fn read_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8) -> starknet::SyscallResult { + let contract_address = starknet::Store::::read_at_offset(address_domain, base, offset)?; + starknet::SyscallResult::Ok( + IFaultyTraitSafeDispatcher { + contract_address, + } + ) + } + #[inline(always)] + fn write_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8, value: IFaultyTraitSafeDispatcher) -> starknet::SyscallResult<()> { + starknet::Store::::write_at_offset(address_domain, base, offset, value.contract_address)?; + starknet::SyscallResult::Ok(()) + } + #[inline(always)] + fn size() -> u8 { + starknet::Store::::size() + } +} + +#[derive(Drop, Copy)] +pub struct IFaultyTraitSafeDispatcherSubPointers { + pub contract_address: starknet::storage::StoragePointer, +} +impl IFaultyTraitSafeDispatcherSubPointersImpl of starknet::storage::SubPointers { + type SubPointersType = IFaultyTraitSafeDispatcherSubPointers; + fn sub_pointers(self: starknet::storage::StoragePointer) -> IFaultyTraitSafeDispatcherSubPointers { + let base_address = self.__storage_pointer_address__; + let mut current_offset = self.__storage_pointer_offset__; + let contract_address_value = starknet::storage::StoragePointer { + __storage_pointer_address__: base_address, + __storage_pointer_offset__: current_offset, + }; + IFaultyTraitSafeDispatcherSubPointers { + contract_address: contract_address_value, + } + } +} +#[derive(Drop, Copy)] +pub struct IFaultyTraitSafeDispatcherSubPointersMut { + pub contract_address: starknet::storage::StoragePointer>, +} +impl IFaultyTraitSafeDispatcherSubPointersMutImpl of starknet::storage::SubPointersMut { + type SubPointersType = IFaultyTraitSafeDispatcherSubPointersMut; + fn sub_pointers_mut(self: starknet::storage::StoragePointer>) -> IFaultyTraitSafeDispatcherSubPointersMut { + let base_address = self.__storage_pointer_address__; + let mut current_offset = self.__storage_pointer_offset__; + let contract_address_value = starknet::storage::StoragePointer { + __storage_pointer_address__: base_address, + __storage_pointer_offset__: current_offset, + }; + IFaultyTraitSafeDispatcherSubPointersMut { + contract_address: contract_address_value, + } + } +} +impl IEmptyTraitDispatcherSubPointersDrop of core::traits::Drop::; +impl IEmptyTraitDispatcherSubPointersCopy of core::traits::Copy::; +impl IEmptyTraitDispatcherSubPointersMutDrop of core::traits::Drop::; +impl IEmptyTraitDispatcherSubPointersMutCopy of core::traits::Copy::; +impl IEmptyTraitLibraryDispatcherSubPointersDrop of core::traits::Drop::; +impl IEmptyTraitLibraryDispatcherSubPointersCopy of core::traits::Copy::; +impl IEmptyTraitLibraryDispatcherSubPointersMutDrop of core::traits::Drop::; +impl IEmptyTraitLibraryDispatcherSubPointersMutCopy of core::traits::Copy::; +impl IEmptyTraitSafeLibraryDispatcherSubPointersDrop of core::traits::Drop::; +impl IEmptyTraitSafeLibraryDispatcherSubPointersCopy of core::traits::Copy::; +impl IEmptyTraitSafeLibraryDispatcherSubPointersMutDrop of core::traits::Drop::; +impl IEmptyTraitSafeLibraryDispatcherSubPointersMutCopy of core::traits::Copy::; +impl IEmptyTraitSafeDispatcherSubPointersDrop of core::traits::Drop::; +impl IEmptyTraitSafeDispatcherSubPointersCopy of core::traits::Copy::; +impl IEmptyTraitSafeDispatcherSubPointersMutDrop of core::traits::Drop::; +impl IEmptyTraitSafeDispatcherSubPointersMutCopy of core::traits::Copy::; +impl IFaultyTraitDispatcherSubPointersDrop of core::traits::Drop::; +impl IFaultyTraitDispatcherSubPointersCopy of core::traits::Copy::; +impl IFaultyTraitDispatcherSubPointersMutDrop of core::traits::Drop::; +impl IFaultyTraitDispatcherSubPointersMutCopy of core::traits::Copy::; +impl IFaultyTraitLibraryDispatcherSubPointersDrop of core::traits::Drop::; +impl IFaultyTraitLibraryDispatcherSubPointersCopy of core::traits::Copy::; +impl IFaultyTraitLibraryDispatcherSubPointersMutDrop of core::traits::Drop::; +impl IFaultyTraitLibraryDispatcherSubPointersMutCopy of core::traits::Copy::; +impl IFaultyTraitSafeLibraryDispatcherSubPointersDrop of core::traits::Drop::; +impl IFaultyTraitSafeLibraryDispatcherSubPointersCopy of core::traits::Copy::; +impl IFaultyTraitSafeLibraryDispatcherSubPointersMutDrop of core::traits::Drop::; +impl IFaultyTraitSafeLibraryDispatcherSubPointersMutCopy of core::traits::Copy::; +impl IFaultyTraitSafeDispatcherSubPointersDrop of core::traits::Drop::; +impl IFaultyTraitSafeDispatcherSubPointersCopy of core::traits::Copy::; +impl IFaultyTraitSafeDispatcherSubPointersMutDrop of core::traits::Drop::; +impl IFaultyTraitSafeDispatcherSubPointersMutCopy of core::traits::Copy::; +impl INominalTraitDispatcherSubPointersDrop of core::traits::Drop::; +impl INominalTraitDispatcherSubPointersCopy of core::traits::Copy::; +impl INominalTraitDispatcherSubPointersMutDrop of core::traits::Drop::; +impl INominalTraitDispatcherSubPointersMutCopy of core::traits::Copy::; +impl INominalTraitLibraryDispatcherSubPointersDrop of core::traits::Drop::; +impl INominalTraitLibraryDispatcherSubPointersCopy of core::traits::Copy::; +impl INominalTraitLibraryDispatcherSubPointersMutDrop of core::traits::Drop::; +impl INominalTraitLibraryDispatcherSubPointersMutCopy of core::traits::Copy::; +impl INominalTraitSafeLibraryDispatcherSubPointersDrop of core::traits::Drop::; +impl INominalTraitSafeLibraryDispatcherSubPointersCopy of core::traits::Copy::; +impl INominalTraitSafeLibraryDispatcherSubPointersMutDrop of core::traits::Drop::; +impl INominalTraitSafeLibraryDispatcherSubPointersMutCopy of core::traits::Copy::; +impl INominalTraitSafeDispatcherSubPointersDrop of core::traits::Drop::; +impl INominalTraitSafeDispatcherSubPointersCopy of core::traits::Copy::; +impl INominalTraitSafeDispatcherSubPointersMutDrop of core::traits::Drop::; +impl INominalTraitSafeDispatcherSubPointersMutCopy of core::traits::Copy::; +impl IFaultyTraitDispatcherSubPointersDrop of core::traits::Drop::; +impl IFaultyTraitDispatcherSubPointersCopy of core::traits::Copy::; +impl IFaultyTraitDispatcherSubPointersMutDrop of core::traits::Drop::; +impl IFaultyTraitDispatcherSubPointersMutCopy of core::traits::Copy::; +impl IFaultyTraitLibraryDispatcherSubPointersDrop of core::traits::Drop::; +impl IFaultyTraitLibraryDispatcherSubPointersCopy of core::traits::Copy::; +impl IFaultyTraitLibraryDispatcherSubPointersMutDrop of core::traits::Drop::; +impl IFaultyTraitLibraryDispatcherSubPointersMutCopy of core::traits::Copy::; +impl IFaultyTraitSafeLibraryDispatcherSubPointersDrop of core::traits::Drop::; +impl IFaultyTraitSafeLibraryDispatcherSubPointersCopy of core::traits::Copy::; +impl IFaultyTraitSafeLibraryDispatcherSubPointersMutDrop of core::traits::Drop::; +impl IFaultyTraitSafeLibraryDispatcherSubPointersMutCopy of core::traits::Copy::; +impl IFaultyTraitSafeDispatcherSubPointersDrop of core::traits::Drop::; +impl IFaultyTraitSafeDispatcherSubPointersCopy of core::traits::Copy::; +impl IFaultyTraitSafeDispatcherSubPointersMutDrop of core::traits::Drop::; +impl IFaultyTraitSafeDispatcherSubPointersMutCopy of core::traits::Copy::; diff --git a/crates/compiler/src/print.rs b/crates/compiler/src/print.rs new file mode 100644 index 0000000..aa45831 --- /dev/null +++ b/crates/compiler/src/print.rs @@ -0,0 +1,99 @@ +use cairo_lang_defs::patcher::RewriteNode; +use cairo_lang_syntax::node::ast::{ItemEnum, ItemStruct, OptionTypeClause}; +use cairo_lang_syntax::node::db::SyntaxGroup; +use cairo_lang_syntax::node::{Terminal, TypedSyntaxNode}; +use cairo_lang_utils::unordered_hash_map::UnorderedHashMap; + +/// Derives PrintTrait for a struct. +/// Parameters: +/// * db: The semantic database. +/// * struct_ast: The AST of the model struct. +/// +/// Returns: +/// * A RewriteNode containing the generated code. +pub fn handle_print_struct(db: &dyn SyntaxGroup, struct_ast: ItemStruct) -> RewriteNode { + let prints: Vec<_> = struct_ast + .members(db) + .elements(db) + .iter() + .map(|m| { + format!( + "core::debug::PrintTrait::print('{}'); core::debug::PrintTrait::print(self.{});", + m.name(db).text(db).to_string(), + m.name(db).text(db).to_string() + ) + }) + .collect(); + + RewriteNode::interpolate_patched( + " +#[cfg(test)] +impl $type_name$StructPrintImpl of core::debug::PrintTrait<$type_name$> { + fn print(self: $type_name$) { + $print$ + } +} +", + &UnorderedHashMap::from([ + ( + "type_name".to_string(), + RewriteNode::new_trimmed(struct_ast.name(db).as_syntax_node()), + ), + ("print".to_string(), RewriteNode::Text(prints.join("\n"))), + ]), + ) +} + +/// Derives PrintTrait for an enum. +/// Parameters: +/// * db: The semantic database. +/// * enum_ast: The AST of the model enum. +/// +/// Returns: +/// * A RewriteNode containing the generated code. +pub fn handle_print_enum(db: &dyn SyntaxGroup, enum_ast: ItemEnum) -> RewriteNode { + let enum_name = enum_ast.name(db).text(db); + let prints: Vec<_> = enum_ast + .variants(db) + .elements(db) + .iter() + .map(|m| { + let variant_name = m.name(db).text(db).to_string(); + match m.type_clause(db) { + OptionTypeClause::Empty(_) => { + format!( + "{enum_name}::{variant_name} => {{ \ + core::debug::PrintTrait::print('{variant_name}'); }}" + ) + } + OptionTypeClause::TypeClause(_) => { + format!( + "{enum_name}::{variant_name}(v) => {{ \ + core::debug::PrintTrait::print('{variant_name}'); \ + core::debug::PrintTrait::print(v); }}" + ) + } + } + }) + .collect(); + + RewriteNode::interpolate_patched( + " +#[cfg(test)] +impl $type_name$EnumPrintImpl of core::debug::PrintTrait<$type_name$> { + fn print(self: $type_name$) { + match self { + $print$ + } + } +} +", + &UnorderedHashMap::from([ + ( + "type_name".to_string(), + RewriteNode::new_trimmed(enum_ast.name(db).as_syntax_node()), + ), + ("print".to_string(), RewriteNode::Text(prints.join(",\n"))), + ]), + ) +} diff --git a/crates/compiler/src/scarb_internal/debug.rs b/crates/compiler/src/scarb_internal/debug.rs new file mode 100644 index 0000000..0a8805a --- /dev/null +++ b/crates/compiler/src/scarb_internal/debug.rs @@ -0,0 +1,180 @@ +use std::collections::HashMap; +use std::env; +use std::sync::Arc; + +use anyhow::{Context, Result}; +use cairo_lang_compiler::db::RootDatabase; +use cairo_lang_diagnostics::ToOption; +use cairo_lang_filesystem::db::{get_originating_location, FilesGroup}; +use cairo_lang_filesystem::ids::{FileId, FileLongId}; +use cairo_lang_filesystem::span::TextSpan; +use cairo_lang_sierra_generator::db::SierraGenGroup; +use cairo_lang_sierra_generator::program_generator::{ + SierraProgramDebugInfo, SierraProgramWithDebug, +}; +use cairo_lang_starknet::compile::{extract_semantic_entrypoints, SemanticEntryPoints}; +use cairo_lang_starknet::contract::ContractDeclaration; +use itertools::{chain, Itertools}; +use serde::Serialize; + +pub fn compile_prepared_db_to_debug_info( + db: &RootDatabase, + contracts: &[&ContractDeclaration], + // mut compiler_config: CompilerConfig<'_>, +) -> Result> { + // compiler_config.diagnostics_reporter.ensure(db)?; + + contracts + .iter() + .map(|contract| compile_contract_with_prepared_and_checked_db_to_debug_info(db, contract)) + .try_collect() +} + +/// Compile declared Starknet contract. +/// +/// The `contract` value **must** come from `db`, for example as a result of calling +/// [`find_contracts`]. Does not check diagnostics, it is expected that they are checked by caller +/// of this function. +fn compile_contract_with_prepared_and_checked_db_to_debug_info( + db: &RootDatabase, + contract: &ContractDeclaration, +) -> Result { + let SemanticEntryPoints { + external, + l1_handler, + constructor, + } = extract_semantic_entrypoints(db, contract)?; + let SierraProgramWithDebug { + program: _sierra_program, + debug_info, + } = Arc::unwrap_or_clone( + db.get_sierra_program_for_functions( + chain!(&external, &l1_handler, &constructor) + .map(|f| f.value) + .collect(), + ) + .to_option() + .with_context(|| "Compilation failed without any diagnostics.")?, + ); + + Ok(debug_info) +} + +#[derive(Debug, Clone, Serialize)] +pub struct SierraToCairoDebugInfo { + pub sierra_statements_to_cairo_info: HashMap, +} + +/// Human readable position inside a file, in lines and characters. +#[derive(Debug, Serialize, Clone)] +pub struct TextPosition { + /// Line index, 0 based. + pub line: usize, + /// Character index inside the line, 0 based. + pub col: usize, +} + +#[derive(Debug, Serialize, Clone)] +pub struct Location { + pub start: TextPosition, + pub end: TextPosition, + pub file_path: String, +} + +#[derive(Debug, Clone, Serialize)] +pub struct SierraStatementToCairoDebugInfo { + pub cairo_locations: Vec, +} + +/// Returns a map from Sierra statement indexes to Cairo function names. +pub fn get_sierra_to_cairo_debug_info( + sierra_program_debug_info: &SierraProgramDebugInfo, + compiler_db: &RootDatabase, +) -> SierraToCairoDebugInfo { + let mut sierra_statements_to_cairo_info: HashMap = + HashMap::new(); + + for (statement_idx, locations) in sierra_program_debug_info + .statements_locations + .locations + .iter_sorted() + { + let mut cairo_locations: Vec = Vec::new(); + for location in locations { + let syntax_node = location.syntax_node(compiler_db); + let file_id = syntax_node.stable_ptr().file_id(compiler_db); + let _file_name = file_id.file_name(compiler_db); + let syntax_node_location_span = syntax_node.span_without_trivia(compiler_db); + + let (originating_file_id, originating_text_span) = + get_originating_location(compiler_db, file_id, syntax_node_location_span); + let cairo_location = get_location_from_text_span( + originating_text_span, + originating_file_id, + compiler_db, + ); + if let Some(cl) = cairo_location { + cairo_locations.push(cl); + } + } + sierra_statements_to_cairo_info.insert( + statement_idx.0, + SierraStatementToCairoDebugInfo { cairo_locations }, + ); + } + + SierraToCairoDebugInfo { + sierra_statements_to_cairo_info, + } +} + +pub fn get_location_from_text_span( + text_span: TextSpan, + file_id: FileId, + compiler_db: &RootDatabase, +) -> Option { + let current_dir = env::current_dir().expect("Failed to get current directory"); + // dbg!(¤t_dir); + // let file_path = match compiler_db.lookup_intern_file(file_id) { + // FileLongId::OnDisk(path) => { + // path.strip_prefix(current_dir).expect("Failed to get relative + // path").to_path_buf().to_str().unwrap_or("").to_string() }, + // FileLongId::Virtual(_) => file_id.full_path(compiler_db), + // }; + let file_path = match compiler_db.lookup_intern_file(file_id) { + FileLongId::OnDisk(path) => match path.strip_prefix(¤t_dir) { + Ok(relative_path) => relative_path.to_str().unwrap_or("").to_string(), + Err(_) => { + return None; + } + }, + FileLongId::Virtual(_) => { + return None; + } + }; + + // let file_path = file_id.full_path(compiler_db); + + let start: Option = + text_span + .start + .position_in_file(compiler_db, file_id) + .map(|s| TextPosition { + line: s.line, + col: s.col, + }); + + let end = text_span + .end + .position_in_file(compiler_db, file_id) + .map(|e| TextPosition { + line: e.line, + col: e.col, + }); + + start.zip(end).map(|(start, end)| Location { + start, + end, + file_path, + }) +} diff --git a/crates/compiler/src/scarb_internal/mod.rs b/crates/compiler/src/scarb_internal/mod.rs new file mode 100644 index 0000000..ca68b93 --- /dev/null +++ b/crates/compiler/src/scarb_internal/mod.rs @@ -0,0 +1,311 @@ +// I have copied source code from https://github.com/software-mansion/scarb/blob/main/scarb/src/compiler/db.rs +// since build_scarb_root_database is not public. +// +// NOTE: This files needs to be updated whenever scarb version is updated. +// NOTE: This file was moved here from `sozo` as we need to compile here too, +// and `sozo` has `dojo-lang` as dependency. +use anyhow::Result; +use cairo_lang_compiler::db::RootDatabase; +use cairo_lang_compiler::project::{ProjectConfig, ProjectConfigContent}; +use cairo_lang_filesystem::cfg::{Cfg, CfgSet}; +use cairo_lang_filesystem::db::{CrateSettings, ExperimentalFeaturesConfig}; +use cairo_lang_filesystem::ids::Directory; +use cairo_lang_project::AllCratesConfig; +use cairo_lang_starknet::starknet_plugin_suite; +use cairo_lang_test_plugin::test_plugin_suite; +use cairo_lang_utils::ordered_hash_map::OrderedHashMap; +use camino::Utf8PathBuf; +use regex::Regex; +use scarb::compiler::{ + CairoCompilationUnit, CompilationUnit, CompilationUnitAttributes, CompilationUnitComponent, +}; +use scarb::core::{Config, PackageId, Workspace}; +use scarb::ops::CompileOpts; +use scarb_ui::Ui; +use smol_str::SmolStr; +use tracing::trace; + +use crate::compiler::config::{CompilerConfig, DojoConfigLoader}; +use crate::namespace_config::{ + NamespaceConfig, DEFAULT_NAMESPACE_CFG_KEY, DOJO_MANIFESTS_DIR_CFG_KEY, NAMESPACE_CFG_PREFIX, +}; +use crate::plugin::dojo_plugin_suite; + +pub(crate) const LOG_TARGET: &str = "dojo_lang::scarb_internal"; +pub mod debug; + +/// Compilation information of all the units found in the workspace. +#[derive(Debug, Default)] +pub struct CompileInfo { + /// The name of the profile used to compile. + pub profile_name: String, + /// The path to the manifest file. + pub manifest_path: Utf8PathBuf, + /// The path to the target directory. + pub target_dir: Utf8PathBuf, + /// The name of the root package. + pub root_package_name: Option, + /// The list of units that failed to compile. + pub compile_error_units: Vec, +} + +pub fn crates_config_for_compilation_unit(unit: &CairoCompilationUnit) -> AllCratesConfig { + let crates_config: OrderedHashMap = unit + .components() + .iter() + .map(|component| { + // Ensure experimental features are only enable if required. + let experimental_features = component.package.manifest.experimental_features.clone(); + let experimental_features = experimental_features.unwrap_or_default(); + + ( + component.cairo_package_name(), + CrateSettings { + edition: component.package.manifest.edition, + experimental_features: ExperimentalFeaturesConfig { + negative_impls: experimental_features + .contains(&SmolStr::new_inline("negative_impls")), + coupons: experimental_features.contains(&SmolStr::new_inline("coupons")), + }, + cfg_set: component.cfg_set.clone(), + version: Some(component.package.id.version.clone()), + }, + ) + }) + .collect(); + + AllCratesConfig { + override_map: crates_config, + ..Default::default() + } +} + +/// Builds the scarb root database injecting the dojo plugin suite, additionaly to the +/// default Starknet and Test suites. +pub fn build_scarb_root_database(unit: &CairoCompilationUnit) -> Result { + let mut b = RootDatabase::builder(); + b.with_project_config(build_project_config(unit)?); + b.with_cfg(unit.cfg_set.clone()); + + b.with_plugin_suite(test_plugin_suite()); + b.with_plugin_suite(dojo_plugin_suite()); + b.with_plugin_suite(starknet_plugin_suite()); + + b.build() +} + +/// This function is an alternative to `ops::compile`, it's doing the same job. +/// However, we can control the injection of the plugins, required to have dojo plugin present +/// for each compilation. +pub fn compile_workspace( + config: &Config, + opts: CompileOpts, + packages: Vec, +) -> Result { + let ws = scarb::ops::read_workspace(config.manifest_path(), config)?; + let resolve = scarb::ops::resolve_workspace(&ws)?; + let ui = config.ui(); + + let compilation_units = scarb::ops::generate_compilation_units(&resolve, &opts.features, &ws)? + .into_iter() + .filter(|cu| { + !opts + .exclude_target_kinds + .contains(&cu.main_component().target_kind()) + }) + .filter(|cu| { + opts.include_target_kinds.is_empty() + || opts + .include_target_kinds + .contains(&cu.main_component().target_kind()) + }) + .filter(|cu| packages.contains(&cu.main_package_id())) + .collect::>(); + + let mut compile_error_units = vec![]; + + for unit in compilation_units { + trace!(target: LOG_TARGET, unit_name = %unit.name(), target_kind = %unit.main_component().target_kind(), "Compiling unit."); + + // Proc macro are not supported yet on Dojo, hence we only consider processing Cairo + // compilation units. + if let CompilationUnit::Cairo(mut unit) = unit { + let unit_name = unit.name(); + let re = Regex::new(r"\s*\([^()]*\)$").unwrap(); + let unit_name_no_path = re.replace(&unit_name, ""); + + ui.print(format!("compiling {}", unit_name_no_path)); + ui.verbose(format!( + "target kind: {}", + unit.main_component().target_kind() + )); + + let compiler_config: CompilerConfig = + DojoConfigLoader::from_package(&unit.components[0].package, &ws).unwrap(); + + // let root_package_data = + // PackageData::from_scarb_package(&unit.components[0].package)?; + + ui.verbose(compiler_config.namespace.display_mappings()); + + // For each component in the compilation unit (namely, the dependencies being + // compiled) we inject into the `CfgSet` the component name and + // namespace configuration. Doing this here ensures the parsing of + // of the manifest is done once at compile time, and not everytime + // the plugin is called. + for c in unit.components.iter_mut() { + c.cfg_set = Some(cfg_set_from_component( + c, + &compiler_config.namespace, + &ui, + &ws, + )?); + } + + let mut db = build_scarb_root_database(&unit).unwrap(); + if let Err(err) = ws + .config() + .compilers() + .compile(unit.clone(), &mut (db), &ws) + { + ws.config().ui().anyhow(&err); + compile_error_units.push(unit.name()); + } + } + } + + let manifest_path = ws.manifest_path().into(); + let target_dir = ws.target_dir().path_existent().unwrap(); + let target_dir = target_dir.join(ws.config().profile().as_str()); + + // The root package may be non existent in a scarb project/workspace. + // Please refer here: + let root_package_name = if let Some(package) = ws.root_package() { + Some(package.id.name.to_string()) + } else { + None + }; + + let profile_name = if let Ok(p) = ws.current_profile() { + p.to_string() + } else { + "NO_PROFILE".to_string() + }; + + Ok(CompileInfo { + manifest_path, + target_dir, + root_package_name, + profile_name, + compile_error_units, + }) +} + +fn build_project_config(unit: &CairoCompilationUnit) -> Result { + let crate_roots = unit + .components() + .iter() + .filter(|model| !model.package.id.is_core()) + // NOTE: We're taking the first target of each compilation unit, which should always be the + // main package source root due to the order maintained by scarb. + .map(|model| { + ( + model.cairo_package_name(), + model.targets[0].source_root().into(), + ) + }) + .collect(); + + let corelib = + // NOTE: We're taking the first target of the corelib, which should always be the + // main package source root due to the order maintained by scarb. + unit.core_package_component().map(|c| Directory::Real(c.targets[0].source_root().into())); + + let content = ProjectConfigContent { + crate_roots, + crates_config: crates_config_for_compilation_unit(unit), + }; + + let project_config = ProjectConfig { + base_path: unit.main_component().package.root().into(), + corelib, + content, + }; + + trace!(target: LOG_TARGET, ?project_config); + + Ok(project_config) +} + +pub fn cfg_set_from_component( + c: &CompilationUnitComponent, + root_package_namespace: &NamespaceConfig, + ui: &Ui, + ws: &Workspace<'_>, +) -> Result { + let cname = c.cairo_package_name().clone(); + let package_compiler_config: CompilerConfig = DojoConfigLoader::from_package(&c.package, ws)?; + + let dojo_manifests_dir = ws + .config() + .manifest_path() + .parent() + .expect("Scarb.toml manifest should always have parent") + .join("manifests") + .join( + ws.current_profile() + .expect("profile should be set") + .to_string(), + ); + + ui.verbose(format!( + "component: {} ({})", + cname, + c.package.manifest_path() + )); + + tracing::debug!(target: LOG_TARGET, ?c, ?package_compiler_config); + + let component_cfg = Cfg { + key: "component_name".into(), + value: Some(cname), + }; + + let mut cfg_set = CfgSet::new(); + + // Keep orinigal cfg set of the component. + if let Some(component_cfg_set) = c.cfg_set.clone() { + for cfg in component_cfg_set.into_iter() { + cfg_set.insert(cfg); + } + } + + // Add it's name for debugging on the plugin side. + cfg_set.insert(component_cfg); + + cfg_set.insert(Cfg { + key: DOJO_MANIFESTS_DIR_CFG_KEY.into(), + value: Some(dojo_manifests_dir.to_string().into()), + }); + + cfg_set.insert(Cfg { + key: DEFAULT_NAMESPACE_CFG_KEY.into(), + value: Some(package_compiler_config.namespace.default.into()), + }); + + // We ignore mappings for dependencies as the [[target.dojo]] package is + // defining them. + + // Inject the mapping from the root package with [[target.dojo]] to + // all dependencies to ensure correct namespace mappings. + if let Some(mappings) = &root_package_namespace.mappings { + for (k, v) in mappings.iter() { + cfg_set.insert(Cfg { + key: format!("{}{}", NAMESPACE_CFG_PREFIX, k).into(), + value: Some(v.into()), + }); + } + } + + Ok(cfg_set) +} diff --git a/crates/compiler/src/semantics/mod.rs b/crates/compiler/src/semantics/mod.rs new file mode 100644 index 0000000..4570554 --- /dev/null +++ b/crates/compiler/src/semantics/mod.rs @@ -0,0 +1,7 @@ +pub mod utils; + +#[cfg(test)] +pub mod test_utils; + +#[cfg(test)] +pub mod tests; diff --git a/crates/compiler/src/semantics/test_data/get b/crates/compiler/src/semantics/test_data/get new file mode 100644 index 0000000..e64ef5f --- /dev/null +++ b/crates/compiler/src/semantics/test_data/get @@ -0,0 +1,237 @@ +//! > Test no params + +//! > test_runner_name +test_semantics + +//! > setup_code +use array::ArrayTrait; +use dojo::world::{IWorldDispatcher, IWorldDispatcherTrait}; + +#[derive(Copy, Drop, Serde, Introspect)] +struct Health { + #[key] + id: u32, + health: u16, +} + +//! > function_code +let key: felt252 = 0xb0b; +let world = IWorldDispatcher{contract_address: 0x0.try_into().unwrap()}; + +//! > expression +get!() + +//! > expected +Missing( + ExprMissing { + ty: , + }, +) + +//! > semantic_diagnostics +error: Plugin diagnostic: Invalid arguments. Expected "get!(world, keys, (models,))" + --> lib.cairo:12:1 +get!() +^****^ + +warning[E0001]: Unused variable. Consider ignoring by prefixing with `_`. + --> lib.cairo:10:22 +fn test_func() { let key: felt252 = 0xb0b; + ^*^ + +warning[E0001]: Unused variable. Consider ignoring by prefixing with `_`. + --> lib.cairo:11:5 +let world = IWorldDispatcher{contract_address: 0x0.try_into().unwrap()}; { + ^***^ + +//! > ========================================================================== + +//! > Test wrong params + +//! > test_runner_name +test_semantics + +//! > setup_code +use array::ArrayTrait; +use dojo::world::{IWorldDispatcher, IWorldDispatcherTrait}; + +#[derive(Copy, Drop, Serde, Introspect)] +struct Health { + #[key] + id: u32, + health: u16, +} + +//! > function_code +let key: felt252 = 0xb0b; +let world = IWorldDispatcher{contract_address: 0x0.try_into().unwrap()}; + +//! > expression +get!(world) + +//! > expected +Missing( + ExprMissing { + ty: , + }, +) + +//! > semantic_diagnostics +error: Plugin diagnostic: Invalid arguments. Expected "get!(world, keys, (models,))" + --> lib.cairo:12:1 +get!(world) +^*********^ + +warning[E0001]: Unused variable. Consider ignoring by prefixing with `_`. + --> lib.cairo:10:22 +fn test_func() { let key: felt252 = 0xb0b; + ^*^ + +warning[E0001]: Unused variable. Consider ignoring by prefixing with `_`. + --> lib.cairo:11:5 +let world = IWorldDispatcher{contract_address: 0x0.try_into().unwrap()}; { + ^***^ + +//! > ========================================================================== + +//! > Test world and keys + +//! > no_diagnostics +true + +//! > dojo_semantic +get_success + +//! > test_runner_name +test_semantics + +//! > setup_code +use array::ArrayTrait; +use dojo::world::{IWorldDispatcher, IWorldDispatcherTrait}; + +#[derive(Copy, Drop, Serde, Introspect)] +struct Health { + #[key] + id: u32, + health: u16, +} + +//! > function_code +let key: felt252 = 0xb0b; +let world = IWorldDispatcher{contract_address: 0x0.try_into().unwrap()}; + +//! > expression +get!(world, key, (Health)) + +//! > expected +Block( + ExprBlock { + statements: [ + Let( + StatementLet { + pattern: Variable( + __get_macro_keys__, + ), + expr: FunctionCall( + ExprFunctionCall { + function: core::array::ArrayImpl::::new, + args: [], + coupon_arg: None, + ty: core::array::Array::, + }, + ), + }, + ), + Expr( + StatementExpr { + expr: FunctionCall( + ExprFunctionCall { + function: core::Felt252Serde::serialize, + args: [ + Value( + Snapshot( + ExprSnapshot { + inner: Var( + LocalVarId(test::key), + ), + ty: @core::felt252, + }, + ), + ), + Reference( + LocalVarId(test::__get_macro_keys__), + ), + ], + coupon_arg: None, + ty: (), + }, + ), + }, + ), + Let( + StatementLet { + pattern: Variable( + __get_macro_keys__, + ), + expr: FunctionCall( + ExprFunctionCall { + function: core::array::ArrayImpl::::span, + args: [ + Value( + Snapshot( + ExprSnapshot { + inner: Var( + LocalVarId(test::__get_macro_keys__), + ), + ty: @core::array::Array::, + }, + ), + ), + ], + coupon_arg: None, + ty: core::array::Span::, + }, + ), + }, + ), + Let( + StatementLet { + pattern: Variable( + __Health, + ), + expr: FunctionCall( + ExprFunctionCall { + function: ?7::get, + args: [ + Value( + Var( + LocalVarId(test::world), + ), + ), + Value( + Var( + LocalVarId(test::__get_macro_keys__), + ), + ), + ], + coupon_arg: None, + ty: test::Health, + }, + ), + }, + ), + ], + tail: Some( + Var( + LocalVarId(test::__Health), + ), + ), + ty: test::Health, + }, +) + +//! > semantic_diagnostics +error: Trait has no implementation in context: dojo::model::model::Model::. + --> lib.cairo:12:1 +get!(world, key, (Health)) +^************************^ diff --git a/crates/compiler/src/semantics/test_data/get_models_test_class_hashes b/crates/compiler/src/semantics/test_data/get_models_test_class_hashes new file mode 100644 index 0000000..b70f7b8 --- /dev/null +++ b/crates/compiler/src/semantics/test_data/get_models_test_class_hashes @@ -0,0 +1,89 @@ +//! > Test ok empty (expected to fail due to missing dojo_manifests_dir) + +//! > test_runner_name +test_semantics + +//! > expression +get_models_test_class_hashes!() + +//! > expected +Missing( + ExprMissing { + ty: , + }, +) + +//! > semantic_diagnostics +error: Plugin diagnostic: Failed to load models and namespaces, ensure you have run `sozo build` first. + --> lib.cairo:2:1 +get_models_test_class_hashes!() +^*****************************^ + +//! > ========================================================================== + +//! > Test bad params + +//! > test_runner_name +test_semantics + +//! > expression +get_models_test_class_hashes!("ns1") + +//! > expected +Missing( + ExprMissing { + ty: , + }, +) + +//! > semantic_diagnostics +error: Plugin diagnostic: The list of namespaces should be a fixed size array of strings. + --> lib.cairo:2:31 +get_models_test_class_hashes!("ns1") + ^***^ + +//! > ========================================================================== + +//! > Test too much params + +//! > test_runner_name +test_semantics + +//! > expression +get_models_test_class_hashes!("ns1", ["ns2"]) + +//! > expected +Missing( + ExprMissing { + ty: , + }, +) + +//! > semantic_diagnostics +error: Plugin diagnostic: Invalid arguments. Expected "get_models_test_class_hashes!(["ns1", "ns2")]" or "get_models_test_class_hashes!()". + --> lib.cairo:2:1 +get_models_test_class_hashes!("ns1", ["ns2"]) +^*******************************************^ + +//! > ========================================================================== + +//! > Test ok array (expected to fail due to missing dojo_manifests_dir) + +//! > test_runner_name +test_semantics + +//! > expression +get_models_test_class_hashes!(["ns1", "ns2"]) + +//! > expected +Missing( + ExprMissing { + ty: , + }, +) + +//! > semantic_diagnostics +error: Plugin diagnostic: Failed to load models and namespaces, ensure you have run `sozo build` first. + --> lib.cairo:2:1 +get_models_test_class_hashes!(["ns1", "ns2"]) +^*******************************************^ diff --git a/crates/compiler/src/semantics/test_data/selector_from_tag b/crates/compiler/src/semantics/test_data/selector_from_tag new file mode 100644 index 0000000..a569460 --- /dev/null +++ b/crates/compiler/src/semantics/test_data/selector_from_tag @@ -0,0 +1,86 @@ +//! > Test ok + +//! > test_runner_name +test_semantics + +//! > expression +selector_from_tag!("dojo-test_contract") + +//! > expected +Literal( + ExprLiteral { + value: 2368393732245529956313345237151518608283468650081902115301417183793437311044, + ty: core::felt252, + }, +) + +//! > semantic_diagnostics + +//! > ========================================================================== + +//! > Test no params + +//! > test_runner_name +test_semantics + +//! > expression +selector_from_tag!() + +//! > expected +Missing( + ExprMissing { + ty: , + }, +) + +//! > semantic_diagnostics +error: Plugin diagnostic: Invalid arguments. Expected "selector_from_tag!("tag")" + --> lib.cairo:2:1 +selector_from_tag!() +^******************^ + +//! > ========================================================================== + +//! > Test invalid tag + +//! > test_runner_name +test_semantics + +//! > expression +selector_from_tag!("invalid tag") + +//! > expected +Missing( + ExprMissing { + ty: , + }, +) + +//! > semantic_diagnostics +error: Plugin diagnostic: Invalid tag. Tag must be in the format of `namespace-name`. + --> lib.cairo:2:1 +selector_from_tag!("invalid tag") +^*******************************^ + +//! > ========================================================================== + +//! > Test wrong param + +//! > test_runner_name +test_semantics + +//! > expression +selector_from_tag!("name", "namespace") + +//! > expected +Missing( + ExprMissing { + ty: , + }, +) + +//! > semantic_diagnostics +error: Plugin diagnostic: Invalid arguments. Expected "selector_from_tag!("tag")" + --> lib.cairo:2:1 +selector_from_tag!("name", "namespace") +^*************************************^ diff --git a/crates/compiler/src/semantics/test_data/set b/crates/compiler/src/semantics/test_data/set new file mode 100644 index 0000000..ddbd0b8 --- /dev/null +++ b/crates/compiler/src/semantics/test_data/set @@ -0,0 +1,167 @@ +//! > no params + +//! > test_runner_name +test_semantics + +//! > setup_code + +//! > function_code + +//! > expression +set!() + +//! > expected +Missing( + ExprMissing { + ty: , + }, +) + +//! > semantic_diagnostics +error: Plugin diagnostic: Invalid arguments. Expected "(world, (models,))" + --> lib.cairo:2:6 +set!() + ^ + +//! > ========================================================================== + +//! > incorrect args + +//! > test_runner_name +test_semantics + +//! > setup_code + +//! > function_code + +//! > expression +set!(world) + +//! > expected +Missing( + ExprMissing { + ty: , + }, +) + +//! > semantic_diagnostics +error: Plugin diagnostic: Invalid arguments. Expected "(world, (models,))" + --> lib.cairo:2:6 +set!(world) + ^***^ + +//! > ========================================================================== + +//! > set successful expansion + +//! > no_diagnostics +true + +//! > test_runner_name +test_semantics + +//! > setup_code +use dojo::world::{IWorldDispatcher, IWorldDispatcherTrait}; + +#[derive(Copy, Drop, Serde)] +#[dojo::model] +struct Health { + #[key] + id: u32, + health: u16, +} + +//! > function_code +let key: felt252 = 0xb0b; +let world = IWorldDispatcher{contract_address: 0x0.try_into().unwrap()}; + +//! > expression +set!(world, (Health{id: 0xb0b, health: 79})) + +//! > expected +Block( + ExprBlock { + statements: [ + Let( + StatementLet { + pattern: Variable( + __set_model_instance__, + ), + expr: StructCtor( + ExprStructCtor { + concrete_struct_id: test::Health, + members: [ + ( + MemberId(test::id), + Literal( + ExprLiteral { + value: 2827, + ty: core::integer::u32, + }, + ), + ), + ( + MemberId(test::health), + Literal( + ExprLiteral { + value: 79, + ty: core::integer::u16, + }, + ), + ), + ], + base_struct: None, + ty: test::Health, + }, + ), + }, + ), + Expr( + StatementExpr { + expr: FunctionCall( + ExprFunctionCall { + function: ?6::set_model, + args: [ + Value( + Snapshot( + ExprSnapshot { + inner: Var( + LocalVarId(test::__set_model_instance__), + ), + ty: @test::Health, + }, + ), + ), + Value( + Var( + LocalVarId(test::world), + ), + ), + ], + coupon_arg: None, + ty: (), + }, + ), + }, + ), + ], + tail: None, + ty: (), + }, +) + +//! > semantic_diagnostics +error: Plugin diagnostic: The namespace '' can only contain characters (a-z/A-Z), digits (0-9) and underscore (_). + --> lib.cairo:5:8 +struct Health { + ^****^ + +warning[E0001]: Unused variable. Consider ignoring by prefixing with `_`. + --> lib.cairo:10:22 +fn test_func() { let key: felt252 = 0xb0b; + ^*^ + +error: Trait has no implementation in context: dojo::model::model::Model::. + --> lib.cairo:12:1 +set!(world, (Health{id: 0xb0b, health: 79})) +^******************************************^ diff --git a/crates/compiler/src/semantics/test_data/spawn_test_world b/crates/compiler/src/semantics/test_data/spawn_test_world new file mode 100644 index 0000000..70149dc --- /dev/null +++ b/crates/compiler/src/semantics/test_data/spawn_test_world @@ -0,0 +1,66 @@ +//! > Test ok empty (expected to fail due to missing dojo_manifests_dir) + +//! > test_runner_name +test_semantics + +//! > expression +spawn_test_world!() + +//! > expected +Missing( + ExprMissing { + ty: , + }, +) + +//! > semantic_diagnostics +error: Plugin diagnostic: Failed to load models and namespaces, ensure you have run `sozo build` first. + --> lib.cairo:2:1 +spawn_test_world!() +^*****************^ + +//! > ========================================================================== + +//! > Test bad params + +//! > test_runner_name +test_semantics + +//! > expression +spawn_test_world!("ns1", "ns2") + +//! > expected +Missing( + ExprMissing { + ty: , + }, +) + +//! > semantic_diagnostics +error: Plugin diagnostic: Invalid arguments. Expected "spawn_test_world!()" or "spawn_test_world!(["ns1"]) + --> lib.cairo:2:1 +spawn_test_world!("ns1", "ns2") +^*****************************^ + +//! > ========================================================================== + +//! > Test ok namespaces + +//! > test_runner_name +test_semantics + +//! > expression +spawn_test_world!(["ns1", "ns2"]) + +//! > expected +Missing( + ExprMissing { + ty: , + }, +) + +//! > semantic_diagnostics +error: Plugin diagnostic: Failed to load models and namespaces, ensure you have run `sozo build` first. + --> lib.cairo:2:1 +spawn_test_world!(["ns1", "ns2"]) +^*******************************^ diff --git a/crates/compiler/src/semantics/test_utils.rs b/crates/compiler/src/semantics/test_utils.rs new file mode 100644 index 0000000..9aad43b --- /dev/null +++ b/crates/compiler/src/semantics/test_utils.rs @@ -0,0 +1,368 @@ +use std::collections::BTreeMap; +use std::path::PathBuf; +use std::sync::{Arc, Mutex}; + +use cairo_lang_defs::db::{DefsDatabase, DefsGroup}; +use cairo_lang_defs::ids::{FunctionWithBodyId, ModuleId}; +use cairo_lang_diagnostics::{Diagnostics, DiagnosticsBuilder}; +use cairo_lang_filesystem::db::{ + init_dev_corelib, init_files_group, AsFilesGroupMut, CrateConfiguration, FilesDatabase, + FilesGroup, FilesGroupEx, +}; +use cairo_lang_filesystem::ids::{ + CrateId, CrateLongId, Directory, FileKind, FileLongId, VirtualFile, +}; +use cairo_lang_parser::db::{ParserDatabase, ParserGroup}; +use cairo_lang_semantic::db::{SemanticDatabase, SemanticGroup}; +use cairo_lang_semantic::inline_macros::get_default_plugin_suite; +use cairo_lang_semantic::items::functions::GenericFunctionId; +use cairo_lang_semantic::{ConcreteFunctionWithBodyId, SemanticDiagnostic}; +use cairo_lang_starknet::starknet_plugin_suite; +use cairo_lang_syntax::node::db::{SyntaxDatabase, SyntaxGroup}; +use cairo_lang_utils::ordered_hash_map::OrderedHashMap; +use cairo_lang_utils::{extract_matches, OptionFrom, Upcast}; +use camino::Utf8PathBuf; +use once_cell::sync::Lazy; + +use crate::compiler::test_utils::corelib; +use crate::plugin::dojo_plugin_suite; + +#[salsa::database( + SemanticDatabase, + DefsDatabase, + ParserDatabase, + SyntaxDatabase, + FilesDatabase +)] +#[allow(missing_debug_implementations)] +pub struct DojoSemanticDatabase { + storage: salsa::Storage, +} +impl salsa::Database for DojoSemanticDatabase {} +impl salsa::ParallelDatabase for DojoSemanticDatabase { + fn snapshot(&self) -> salsa::Snapshot { + salsa::Snapshot::new(DojoSemanticDatabase { + storage: self.storage.snapshot(), + }) + } +} + +impl DojoSemanticDatabase { + pub fn new_empty() -> Self { + let mut db = DojoSemanticDatabase { + storage: Default::default(), + }; + init_files_group(&mut db); + + let mut suite = get_default_plugin_suite(); + suite.add(starknet_plugin_suite()); + suite.add(dojo_plugin_suite()); + + db.set_macro_plugins(suite.plugins); + db.set_inline_macro_plugins(suite.inline_macro_plugins.into()); + db.set_analyzer_plugins(suite.analyzer_plugins); + + let dojo_path = Utf8PathBuf::from_path_buf("../../crates/dojo-core/src".into()).unwrap(); + let dojo_path: PathBuf = dojo_path.canonicalize_utf8().unwrap().into(); + let core_crate = db.intern_crate(CrateLongId::Real("dojo".into())); + let core_root_dir = Directory::Real(dojo_path); + + // Ensure the crate[0] is dojo, to enable parsing of the Scarb.toml. + db.set_crate_config( + core_crate, + Some(CrateConfiguration::default_for_root(core_root_dir)), + ); + + init_dev_corelib(&mut db, corelib()); + + db + } + /// Snapshots the db for read only. + pub fn snapshot(&self) -> DojoSemanticDatabase { + DojoSemanticDatabase { + storage: self.storage.snapshot(), + } + } +} + +pub static SHARED_DB: Lazy> = + Lazy::new(|| Mutex::new(DojoSemanticDatabase::new_empty())); + +impl Default for DojoSemanticDatabase { + fn default() -> Self { + SHARED_DB.lock().unwrap().snapshot() + } +} +impl AsFilesGroupMut for DojoSemanticDatabase { + fn as_files_group_mut(&mut self) -> &mut (dyn FilesGroup + 'static) { + self + } +} +impl Upcast for DojoSemanticDatabase { + fn upcast(&self) -> &(dyn FilesGroup + 'static) { + self + } +} +impl Upcast for DojoSemanticDatabase { + fn upcast(&self) -> &(dyn SyntaxGroup + 'static) { + self + } +} +impl Upcast for DojoSemanticDatabase { + fn upcast(&self) -> &(dyn DefsGroup + 'static) { + self + } +} +impl Upcast for DojoSemanticDatabase { + fn upcast(&self) -> &(dyn SemanticGroup + 'static) { + self + } +} +impl Upcast for DojoSemanticDatabase { + fn upcast(&self) -> &(dyn ParserGroup + 'static) { + self + } +} + +#[derive(Debug)] +pub struct WithStringDiagnostics { + value: T, + diagnostics: String, +} +impl WithStringDiagnostics { + /// Verifies that there are no diagnostics (fails otherwise), and returns the inner value. + pub fn unwrap(self) -> T { + assert!( + self.diagnostics.is_empty(), + "Unexpected diagnostics:\n{}", + self.diagnostics + ); + self.value + } + + /// Returns the inner value and the diagnostics (as a string). + pub fn split(self) -> (T, String) { + (self.value, self.diagnostics) + } + + /// Returns the diagnostics (as a string). + pub fn get_diagnostics(self) -> String { + self.diagnostics + } +} + +/// Helper struct for the return value of [setup_test_module]. +#[derive(Debug)] +pub struct TestModule { + pub crate_id: CrateId, + pub module_id: ModuleId, +} + +/// Sets up a crate with given content, and returns its crate id. +pub fn setup_test_crate(db: &dyn SemanticGroup, content: &str) -> CrateId { + let file_id = db.intern_file(FileLongId::Virtual(VirtualFile { + parent: None, + name: "lib.cairo".into(), + content: content.into(), + code_mappings: Arc::new([]), + kind: FileKind::Module, + })); + + db.intern_crate(CrateLongId::Virtual { + name: "test".into(), + config: CrateConfiguration::default_for_root(Directory::Virtual { + files: BTreeMap::from([("lib.cairo".into(), file_id)]), + dirs: Default::default(), + }), + }) +} + +/// Sets up a module with given content, and returns its module id. +pub fn setup_test_module( + db: &(dyn SemanticGroup + 'static), + content: &str, +) -> WithStringDiagnostics { + let crate_id = setup_test_crate(db, content); + let module_id = ModuleId::CrateRoot(crate_id); + let file_id = db.module_main_file(module_id).unwrap(); + + let syntax_diagnostics = db + .file_syntax_diagnostics(file_id) + .format(Upcast::upcast(db)); + let semantic_diagnostics = db + .module_semantic_diagnostics(module_id) + .unwrap() + .format(db); + + WithStringDiagnostics { + value: TestModule { + crate_id, + module_id, + }, + diagnostics: format!("{syntax_diagnostics}{semantic_diagnostics}"), + } +} + +/// Helper struct for the return value of [setup_test_function]. +#[derive(Debug)] +pub struct TestFunction { + pub module_id: ModuleId, + pub function_id: FunctionWithBodyId, + pub concrete_function_id: ConcreteFunctionWithBodyId, + pub signature: cairo_lang_semantic::Signature, + pub body: cairo_lang_semantic::ExprId, +} + +/// Returns the semantic model of a given function. +/// function_name - name of the function. +/// module_code - extra setup code in the module context. +pub fn setup_test_function( + db: &(dyn SemanticGroup + 'static), + function_code: &str, + function_name: &str, + module_code: &str, +) -> WithStringDiagnostics { + let content = if module_code.is_empty() { + function_code.to_string() + } else { + format!("{module_code}\n{function_code}") + }; + let (test_module, diagnostics) = setup_test_module(db, &content).split(); + let generic_function_id = db + .module_item_by_name(test_module.module_id, function_name.into()) + .expect("Failed to load module") + .and_then(GenericFunctionId::option_from) + .unwrap_or_else(|| panic!("Function '{function_name}' was not found.")); + let free_function_id = extract_matches!(generic_function_id, GenericFunctionId::Free); + let function_id = FunctionWithBodyId::Free(free_function_id); + WithStringDiagnostics { + value: TestFunction { + module_id: test_module.module_id, + function_id, + concrete_function_id: ConcreteFunctionWithBodyId::from_no_generics_free( + db, + free_function_id, + ) + .unwrap(), + signature: db.function_with_body_signature(function_id).unwrap(), + body: db.function_body_expr(function_id).unwrap(), + }, + diagnostics, + } +} + +/// Helper struct for the return value of [setup_test_expr] and [setup_test_block]. +#[derive(Debug)] +pub struct TestExpr { + pub module_id: ModuleId, + pub function_id: FunctionWithBodyId, + pub signature: cairo_lang_semantic::Signature, + pub body: cairo_lang_semantic::ExprId, + pub expr_id: cairo_lang_semantic::ExprId, +} + +/// Returns the semantic model of a given expression. +/// module_code - extra setup code in the module context. +/// function_body - extra setup code in the function context. +pub fn setup_test_expr( + db: &(dyn SemanticGroup + 'static), + expr_code: &str, + module_code: &str, + function_body: &str, +) -> WithStringDiagnostics { + let function_code = format!("fn test_func() {{ {function_body} {{\n{expr_code}\n}}; }}"); + let (test_function, diagnostics) = + setup_test_function(db, &function_code, "test_func", module_code).split(); + let cairo_lang_semantic::ExprBlock { statements, .. } = extract_matches!( + db.expr_semantic(test_function.function_id, test_function.body), + cairo_lang_semantic::Expr::Block + ); + let statement_expr = extract_matches!( + db.statement_semantic(test_function.function_id, *statements.last().unwrap()), + cairo_lang_semantic::Statement::Expr + ); + let cairo_lang_semantic::ExprBlock { + statements, tail, .. + } = extract_matches!( + db.expr_semantic(test_function.function_id, statement_expr.expr), + cairo_lang_semantic::Expr::Block + ); + assert!( + statements.is_empty(), + "expr_code is not a valid expression. Consider using setup_test_block()." + ); + WithStringDiagnostics { + value: TestExpr { + module_id: test_function.module_id, + function_id: test_function.function_id, + signature: test_function.signature, + body: test_function.body, + expr_id: tail.unwrap(), + }, + diagnostics, + } +} + +/// Returns the semantic model of a given block expression. +/// module_code - extra setup code in the module context. +/// function_body - extra setup code in the function context. +pub fn setup_test_block( + db: &(dyn SemanticGroup + 'static), + expr_code: &str, + module_code: &str, + function_body: &str, +) -> WithStringDiagnostics { + setup_test_expr( + db, + &format!("{{ \n{expr_code}\n }}"), + module_code, + function_body, + ) +} + +pub fn test_expr_diagnostics( + inputs: &OrderedHashMap, + _args: &OrderedHashMap, +) -> Result, String> { + let db = &DojoSemanticDatabase::default(); + Ok(OrderedHashMap::from([( + "expected_diagnostics".into(), + setup_test_expr( + db, + inputs["expr_code"].as_str(), + inputs["module_code"].as_str(), + inputs["function_body"].as_str(), + ) + .get_diagnostics(), + )])) +} + +pub fn test_function_diagnostics( + inputs: &OrderedHashMap, + _args: &OrderedHashMap, +) -> Result, String> { + let db = &DojoSemanticDatabase::default(); + Ok(OrderedHashMap::from([( + "expected_diagnostics".into(), + setup_test_function( + db, + inputs["function"].as_str(), + inputs["function_name"].as_str(), + inputs["module_code"].as_str(), + ) + .get_diagnostics(), + )])) +} + +/// Gets the diagnostics for all the modules (including nested) in the given crate. +pub fn get_crate_semantic_diagnostics( + db: &dyn SemanticGroup, + crate_id: CrateId, +) -> Diagnostics { + let submodules = db.crate_modules(crate_id); + let mut diagnostics = DiagnosticsBuilder::default(); + for submodule_id in submodules.iter() { + diagnostics.extend(db.module_semantic_diagnostics(*submodule_id).unwrap()); + } + diagnostics.build() +} diff --git a/crates/compiler/src/semantics/tests.rs b/crates/compiler/src/semantics/tests.rs new file mode 100644 index 0000000..5cd4fab --- /dev/null +++ b/crates/compiler/src/semantics/tests.rs @@ -0,0 +1,66 @@ +use cairo_lang_debug::DebugWithDb; +use cairo_lang_semantic::db::SemanticGroup; +use cairo_lang_semantic::expr::fmt::ExprFormatter; +use cairo_lang_semantic::test_utils::setup_test_expr; +use cairo_lang_semantic::Expr; +use cairo_lang_test_utils::parse_test_file::TestRunnerResult; +use cairo_lang_test_utils::test_file_test; +use cairo_lang_utils::ordered_hash_map::OrderedHashMap; + +use crate::semantics::test_utils::DojoSemanticDatabase; + +test_file_test!( + dojo_semantics, + "src/semantics/test_data", + { + get: "get", + + set: "set", + + selector_from_tag: "selector_from_tag", + + get_models_test_class_hashes: "get_models_test_class_hashes", + + spawn_test_world: "spawn_test_world", + }, + test_semantics +); + +pub fn test_semantics( + inputs: &OrderedHashMap, + _args: &OrderedHashMap, +) -> TestRunnerResult { + let mut db = DojoSemanticDatabase::default(); + let (expr, diagnostics, expr_formatter) = semantics_test_setup(inputs, &mut db); + + TestRunnerResult::success(OrderedHashMap::from([ + ( + "expected".into(), + format!("{:#?}", expr.debug(&expr_formatter)), + ), + ("semantic_diagnostics".into(), diagnostics), + ])) +} + +pub fn semantics_test_setup<'a>( + inputs: &OrderedHashMap, + db: &'a mut DojoSemanticDatabase, +) -> (Expr, String, ExprFormatter<'a>) { + let (test_expr, diagnostics) = setup_test_expr( + db, + inputs["expression"].as_str(), + inputs.get("setup_code").map(|s| s.as_str()).unwrap_or(""), + inputs + .get("function_code") + .map(|s| s.as_str()) + .unwrap_or(""), + ) + .split(); + let expr = db.expr_semantic(test_expr.function_id, test_expr.expr_id); + let expr_formatter = ExprFormatter { + db, + function_id: test_expr.function_id, + }; + + (expr, diagnostics, expr_formatter) +} diff --git a/crates/compiler/src/semantics/utils.rs b/crates/compiler/src/semantics/utils.rs new file mode 100644 index 0000000..4e712fe --- /dev/null +++ b/crates/compiler/src/semantics/utils.rs @@ -0,0 +1,24 @@ +use cairo_lang_defs::ids::FunctionWithBodyId; +use cairo_lang_semantic as semantic; +use cairo_lang_syntax::node::{ast, SyntaxNode, TypedSyntaxNode}; +use semantic::db::SemanticGroup; +use semantic::items::function_with_body::SemanticExprLookup; + +/// Returns the semantic expression for the current node. +pub fn nearest_semantic_expr( + db: &dyn SemanticGroup, + mut node: SyntaxNode, + function_id: FunctionWithBodyId, +) -> Option { + loop { + let syntax_db = db.upcast(); + if ast::Expr::is_variant(node.kind(syntax_db)) { + let expr_node = ast::Expr::from_syntax_node(syntax_db, node.clone()); + if let Ok(expr_id) = db.lookup_expr_by_ptr(function_id, expr_node.stable_ptr()) { + let semantic_expr = db.expr_semantic(function_id, expr_id); + return Some(semantic_expr); + } + } + node = node.parent()?; + } +} diff --git a/crates/compiler/src/syntax/mod.rs b/crates/compiler/src/syntax/mod.rs new file mode 100644 index 0000000..cfd4071 --- /dev/null +++ b/crates/compiler/src/syntax/mod.rs @@ -0,0 +1,3 @@ +pub mod self_param; +pub mod utils; +pub mod world_param; diff --git a/crates/compiler/src/syntax/self_param.rs b/crates/compiler/src/syntax/self_param.rs new file mode 100644 index 0000000..aaf3593 --- /dev/null +++ b/crates/compiler/src/syntax/self_param.rs @@ -0,0 +1,30 @@ +use cairo_lang_syntax::node::ast; +use cairo_lang_syntax::node::db::SyntaxGroup; + +use crate::syntax::utils as syntax_utils; + +pub const SELF_PARAM_NAME: &str = "self"; + +/// Checks if the given function parameter is using `self` instead of `world` param. +/// Adds diagnostic if that case. +/// +/// # Arguments +/// +/// - `db` - The syntax group. +/// - `param_list` - The parameter list of the function. +/// - `fn_diagnostic_item` - The diagnostic item of the function. +/// - `diagnostics` - The diagnostics vector. +/// +/// # Returns +/// +/// - `true` if the function first parameter is `self`. +pub fn check_parameter(db: &dyn SyntaxGroup, param_list: &ast::ParamList) -> bool { + if param_list.elements(db).is_empty() { + return false; + } + + let param_0 = param_list.elements(db)[0].clone(); + let (name, _, _) = syntax_utils::get_parameter_info(db, param_0.clone()); + + name.eq(SELF_PARAM_NAME) +} diff --git a/crates/compiler/src/syntax/utils.rs b/crates/compiler/src/syntax/utils.rs new file mode 100644 index 0000000..349597e --- /dev/null +++ b/crates/compiler/src/syntax/utils.rs @@ -0,0 +1,32 @@ +use cairo_lang_syntax::node::db::SyntaxGroup; +use cairo_lang_syntax::node::{ast, Terminal, TypedSyntaxNode}; + +/// Gets the name, modifiers and type of a function parameter. +/// +/// # Arguments +/// +/// * `db` - The syntax group. +/// * `param` - The parameter. +/// +/// # Returns +/// +/// * A tuple containing the name, modifiers and type of the parameter. +pub fn get_parameter_info(db: &dyn SyntaxGroup, param: ast::Param) -> (String, String, String) { + let name = param.name(db).text(db).trim().to_string(); + let modifiers = param + .modifiers(db) + .as_syntax_node() + .get_text(db) + .trim() + .to_string(); + + let param_type = param + .type_clause(db) + .ty(db) + .as_syntax_node() + .get_text(db) + .trim() + .to_string(); + + (name, modifiers, param_type) +} diff --git a/crates/compiler/src/syntax/world_param.rs b/crates/compiler/src/syntax/world_param.rs new file mode 100644 index 0000000..3b5a7b3 --- /dev/null +++ b/crates/compiler/src/syntax/world_param.rs @@ -0,0 +1,106 @@ +use cairo_lang_defs::plugin::PluginDiagnostic; +use cairo_lang_diagnostics::Severity; +use cairo_lang_syntax::node::db::SyntaxGroup; +use cairo_lang_syntax::node::{ast, ids}; + +use super::utils as syntax_utils; + +const WORLD_PARAM_NAME: &str = "world"; +const WORLD_PARAM_TYPE: &str = "IWorldDispatcher"; +const WORLD_PARAM_TYPE_SNAPSHOT: &str = "@IWorldDispatcher"; + +#[derive(Debug, PartialEq, Eq)] +pub enum WorldParamInjectionKind { + None, + View, + External, +} + +/// Checks if the given parameter is the `world` parameter. +/// +/// The `world` must be named `world`, and be placed first in the argument list. +pub fn is_world_param(param_name: &str, param_type: &str) -> bool { + param_name == WORLD_PARAM_NAME + && (param_type == WORLD_PARAM_TYPE || param_type == WORLD_PARAM_TYPE_SNAPSHOT) +} + +/// Extracts the state mutability of a function from the `world` parameter. +/// +/// Checks if the function has only one `world` parameter (or None). +/// The `world` must be named `world`, and be placed first in the argument list. +/// +/// `fn func1(ref world)` // would be external. +/// `fn func2(world)` // would be view. +/// `fn func3()` // would be view. +/// +/// Returns +/// * The [`WorldParamInjectionKind`] determined from the function's params list. +pub fn parse_world_injection( + db: &dyn SyntaxGroup, + param_list: ast::ParamList, + fn_diagnostic_item: ids::SyntaxStablePtrId, + diagnostics: &mut Vec, +) -> WorldParamInjectionKind { + let mut has_world_injected = false; + let mut injection_kind = WorldParamInjectionKind::None; + + param_list + .elements(db) + .iter() + .enumerate() + .for_each(|(idx, param)| { + let (name, modifiers, param_type) = syntax_utils::get_parameter_info(db, param.clone()); + + if !is_world_param(&name, ¶m_type) { + if name.eq(super::self_param::SELF_PARAM_NAME) && has_world_injected { + diagnostics.push(PluginDiagnostic { + stable_ptr: fn_diagnostic_item, + message: "You cannot use `self` and `world` parameters together." + .to_string(), + severity: Severity::Error, + }); + } + + return; + } + + if has_world_injected { + diagnostics.push(PluginDiagnostic { + stable_ptr: fn_diagnostic_item, + message: "Only one world parameter is allowed".to_string(), + severity: Severity::Error, + }); + + return; + } else { + has_world_injected = true; + } + + if idx != 0 { + diagnostics.push(PluginDiagnostic { + stable_ptr: fn_diagnostic_item, + message: "World parameter must be the first parameter.".to_string(), + severity: Severity::Error, + }); + + return; + } + + if modifiers.contains(&"ref".to_string()) { + injection_kind = WorldParamInjectionKind::External; + } else { + injection_kind = WorldParamInjectionKind::View; + + if param_type == WORLD_PARAM_TYPE { + diagnostics.push(PluginDiagnostic { + stable_ptr: fn_diagnostic_item, + message: "World parameter must be a snapshot if `ref` is not used." + .to_string(), + severity: Severity::Error, + }); + } + } + }); + + injection_kind +} diff --git a/crates/compiler/src/utils.rs b/crates/compiler/src/utils.rs new file mode 100644 index 0000000..6869555 --- /dev/null +++ b/crates/compiler/src/utils.rs @@ -0,0 +1,111 @@ +use std::fs; + +use anyhow::Result; +use cairo_lang_filesystem::ids::Directory; +use cairo_lang_syntax::node::db::SyntaxGroup; +use regex::Regex; +use toml::Table; + +use crate::namespace_config::NamespaceConfig; + +/// Check if the provided name follows the format rules. +pub fn is_name_valid(name: &str) -> bool { + Regex::new(r"^[a-zA-Z0-9_]+$").unwrap().is_match(name) +} + +/// Get the namespace configuration from the workspace. +// TODO: Ask to Scarb team to expose this information with the new macro system. +pub fn get_namespace_config(db: &dyn SyntaxGroup) -> Result { + // Super verbose print, but useful to get the CfgSet. + // debug!(cfg_set = ?db.cfg_set(), crates = ?db.crates(), "Retrieving namespace + // configuration."); + + let crates = db.crates(); + + if crates.is_empty() { + return Err(anyhow::anyhow!( + "No crates found in the workspace, hence no namespace configuration." + )); + } + + // Crates[0] is always the root crate that triggered the build origin. + // In case of a library, crates[0] refers to the lib itself if compiled directly, + // or the crate using the library otherwise. + let configuration = match db.crate_config( + *crates + .first() + .expect("No root crate found in the workspace."), + ) { + Option::Some(cfg) => cfg, + Option::None => { + return Err(anyhow::anyhow!( + "No configuration found for the root crate." + )) + } + }; + + if let Directory::Real(ref path) = configuration.root { + let config_path = path.parent().unwrap().join("Scarb.toml"); + + // Very verbose. + // tracing::debug!(config_path = %config_path.to_string_lossy(), "Reading Scarb.toml file + // for namespace config."); + + let config_content = match fs::read_to_string(&config_path) { + Ok(x) => x, + Err(e) => return Err(anyhow::anyhow!("Failed to read Scarb.toml file: {e}.")), + }; + let config = match config_content.parse::
() { + Ok(x) => x, + Err(e) => return Err(anyhow::anyhow!("Failed to parse Scarb.toml file: {e}.")), + }; + + if let Some(tool) = config.get("tool").and_then(|t| t.as_table()) { + if let Some(dojo) = tool.get("dojo").and_then(|d| d.as_table()) { + if let Some(world) = dojo.get("world").and_then(|w| w.as_table()) { + if let Some(namespace_config) = + world.get("namespace").and_then(|n| n.as_table()) + { + match toml::from_str::(&namespace_config.to_string()) { + Ok(config) => return config.validate(), + Err(e) => { + return Err(anyhow::anyhow!( + "Failed to parse namespace configuration of {}: {}", + config_path.to_string_lossy().to_string(), + e + )); + } + } + } + } + } + } + } + + // If no namespace is found, we return a default one as it's surely a crate that doesn't + // need it. This only concern the tests. + Ok(NamespaceConfig { + default: "__NO_NAMESPACE__".into(), + mappings: None, + }) +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn test_is_name_valid() { + assert!(is_name_valid("valid_name")); + assert!(is_name_valid("ValidName")); + assert!(is_name_valid("valid123")); + assert!(is_name_valid("_valid")); + assert!(is_name_valid("valid_")); + + assert!(!is_name_valid("")); + assert!(!is_name_valid("invalid-name")); + assert!(!is_name_valid("invalid name")); + assert!(!is_name_valid("invalid!name")); + assert!(!is_name_valid("invalid.name")); + } +} diff --git a/crates/compiler/src/version.rs b/crates/compiler/src/version.rs new file mode 100644 index 0000000..1a1c023 --- /dev/null +++ b/crates/compiler/src/version.rs @@ -0,0 +1,31 @@ +use anyhow::Result; +use semver::Version; + +pub trait ToVersion { + fn to_version(self) -> Result; +} + +impl ToVersion for Version { + fn to_version(self) -> Result { + Ok(self) + } +} + +impl<'a> ToVersion for &'a str { + fn to_version(self) -> Result { + Version::parse(self.trim()) + .map_err(|_| anyhow::format_err!("cannot parse '{}' as a semver", self)) + } +} + +impl<'a> ToVersion for &'a String { + fn to_version(self) -> Result { + (**self).to_version() + } +} + +impl<'a> ToVersion for &'a Version { + fn to_version(self) -> Result { + Ok(self.clone()) + } +} diff --git a/crates/contracts/Scarb.toml b/crates/contracts/Scarb.toml index 411ae82..a0792ac 100644 --- a/crates/contracts/Scarb.toml +++ b/crates/contracts/Scarb.toml @@ -1,11 +1,11 @@ [package] -cairo-version = "2.7.0" +cairo-version = "=2.7.1" edition = "2024_07" description = "The Dojo Core library for autonomous worlds." name = "dojo" version = "1.0.0-rc.1" [dependencies] -starknet = "=2.7.0" +starknet = "=2.7.1" [lib] diff --git a/crates/contracts/src/contract/contract.cairo b/crates/contracts/src/contract/contract.cairo index 1c0c713..0f358d2 100644 --- a/crates/contracts/src/contract/contract.cairo +++ b/crates/contracts/src/contract/contract.cairo @@ -1,6 +1,6 @@ #[starknet::interface] pub trait IContract { - fn contract_name(self: @T) -> ByteArray; + fn name(self: @T) -> ByteArray; fn namespace(self: @T) -> ByteArray; fn tag(self: @T) -> ByteArray; diff --git a/crates/contracts/src/tests/world/resources.cairo b/crates/contracts/src/tests/world/resources.cairo index 94702f0..f553085 100644 --- a/crates/contracts/src/tests/world/resources.cairo +++ b/crates/contracts/src/tests/world/resources.cairo @@ -354,7 +354,7 @@ fn test_deploy_contract_for_namespace_owner() { let event = event.unwrap(); assert(event.salt == 'salt1', 'bad event salt'); assert(event.class_hash == class_hash, 'bad class_hash'); - assert(event.name == dispatcher.contract_name(), 'bad contract name'); + assert(event.name == dispatcher.name(), 'bad contract name'); assert(event.namespace == dispatcher.namespace(), 'bad namespace'); assert( event.address != core::num::traits::Zero::::zero(), 'bad contract address' diff --git a/crates/contracts/src/world/world_contract.cairo b/crates/contracts/src/world/world_contract.cairo index c43cea5..de60bbd 100644 --- a/crates/contracts/src/world/world_contract.cairo +++ b/crates/contracts/src/world/world_contract.cairo @@ -632,7 +632,7 @@ pub mod world { let dispatcher = IContractDispatcher { contract_address }; let namespace = dispatcher.namespace(); - let name = dispatcher.contract_name(); + let name = dispatcher.name(); let namespace_hash = dispatcher.namespace_hash(); if !self.is_namespace_registered(namespace_hash) { diff --git a/crates/types/Cargo.toml b/crates/types/Cargo.toml index d8b7016..3e30c6a 100644 --- a/crates/types/Cargo.toml +++ b/crates/types/Cargo.toml @@ -8,14 +8,17 @@ version.workspace = true # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html [dependencies] +anyhow.workspace = true cainome.workspace = true crypto-bigint.workspace = true hex.workspace = true itertools.workspace = true num-traits.workspace = true +regex.workspace = true serde.workspace = true serde_json.workspace = true starknet.workspace = true +starknet-crypto.workspace = true strum.workspace = true strum_macros.workspace = true thiserror.workspace = true diff --git a/crates/types/src/lib.rs b/crates/types/src/lib.rs index e6e0ca1..9bad929 100644 --- a/crates/types/src/lib.rs +++ b/crates/types/src/lib.rs @@ -1,6 +1,7 @@ //! Types for Dojo core contracts. -//! +//! pub mod model; +pub mod naming; pub mod packing; pub mod world; diff --git a/crates/types/src/model.rs b/crates/types/src/model.rs index 59ccaef..8d522a6 100644 --- a/crates/types/src/model.rs +++ b/crates/types/src/model.rs @@ -16,9 +16,7 @@ impl ModelContract { Self { address, account, - block_id: starknet::core::types::BlockId::Tag( - starknet::core::types::BlockTag::Pending, - ), + block_id: starknet::core::types::BlockId::Tag(starknet::core::types::BlockTag::Pending), } } pub fn set_contract_address(&mut self, address: starknet::core::types::Felt) { @@ -45,9 +43,7 @@ impl ModelContractReader

{ Self { address, provider, - block_id: starknet::core::types::BlockId::Tag( - starknet::core::types::BlockTag::Pending, - ), + block_id: starknet::core::types::BlockId::Tag(starknet::core::types::BlockTag::Pending), } } pub fn set_contract_address(&mut self, address: starknet::core::types::Felt) { @@ -76,24 +72,19 @@ impl cainome::cairo_serde::CairoSerde for Enum { fn cairo_serialized_size(__rust: &Self::RustType) -> usize { let mut __size = 0; __size += starknet::core::types::Felt::cairo_serialized_size(&__rust.name); - __size - += Vec::::cairo_serialized_size(&__rust.attrs); - __size - += Vec::< - (starknet::core::types::Felt, Ty), - >::cairo_serialized_size(&__rust.children); + __size += Vec::::cairo_serialized_size(&__rust.attrs); + __size += Vec::<(starknet::core::types::Felt, Ty)>::cairo_serialized_size(&__rust.children); __size } fn cairo_serialize(__rust: &Self::RustType) -> Vec { let mut __out: Vec = vec![]; __out.extend(starknet::core::types::Felt::cairo_serialize(&__rust.name)); - __out.extend(Vec::::cairo_serialize(&__rust.attrs)); - __out - .extend( - Vec::< - (starknet::core::types::Felt, Ty), - >::cairo_serialize(&__rust.children), - ); + __out.extend(Vec::::cairo_serialize( + &__rust.attrs, + )); + __out.extend(Vec::<(starknet::core::types::Felt, Ty)>::cairo_serialize( + &__rust.children, + )); __out } fn cairo_deserialize( @@ -103,18 +94,16 @@ impl cainome::cairo_serde::CairoSerde for Enum { let mut __offset = __offset; let name = starknet::core::types::Felt::cairo_deserialize(__felts, __offset)?; __offset += starknet::core::types::Felt::cairo_serialized_size(&name); - let attrs = Vec::< - starknet::core::types::Felt, - >::cairo_deserialize(__felts, __offset)?; + let attrs = Vec::::cairo_deserialize(__felts, __offset)?; __offset += Vec::::cairo_serialized_size(&attrs); - let children = Vec::< - (starknet::core::types::Felt, Ty), - >::cairo_deserialize(__felts, __offset)?; - __offset - += Vec::< - (starknet::core::types::Felt, Ty), - >::cairo_serialized_size(&children); - Ok(Enum { name, attrs, children }) + let children = + Vec::<(starknet::core::types::Felt, Ty)>::cairo_deserialize(__felts, __offset)?; + __offset += Vec::<(starknet::core::types::Felt, Ty)>::cairo_serialized_size(&children); + Ok(Enum { + name, + attrs, + children, + }) } } #[derive(Clone, serde::Serialize, serde::Deserialize, PartialEq, Debug)] @@ -134,7 +123,9 @@ impl cainome::cairo_serde::CairoSerde for FieldLayout { } fn cairo_serialize(__rust: &Self::RustType) -> Vec { let mut __out: Vec = vec![]; - __out.extend(starknet::core::types::Felt::cairo_serialize(&__rust.selector)); + __out.extend(starknet::core::types::Felt::cairo_serialize( + &__rust.selector, + )); __out.extend(Layout::cairo_serialize(&__rust.layout)); __out } @@ -143,10 +134,7 @@ impl cainome::cairo_serde::CairoSerde for FieldLayout { __offset: usize, ) -> cainome::cairo_serde::Result { let mut __offset = __offset; - let selector = starknet::core::types::Felt::cairo_deserialize( - __felts, - __offset, - )?; + let selector = starknet::core::types::Felt::cairo_deserialize(__felts, __offset)?; __offset += starknet::core::types::Felt::cairo_serialized_size(&selector); let layout = Layout::cairo_deserialize(__felts, __offset)?; __offset += Layout::cairo_serialized_size(&layout); @@ -166,15 +154,16 @@ impl cainome::cairo_serde::CairoSerde for Member { fn cairo_serialized_size(__rust: &Self::RustType) -> usize { let mut __size = 0; __size += starknet::core::types::Felt::cairo_serialized_size(&__rust.name); - __size - += Vec::::cairo_serialized_size(&__rust.attrs); + __size += Vec::::cairo_serialized_size(&__rust.attrs); __size += Ty::cairo_serialized_size(&__rust.ty); __size } fn cairo_serialize(__rust: &Self::RustType) -> Vec { let mut __out: Vec = vec![]; __out.extend(starknet::core::types::Felt::cairo_serialize(&__rust.name)); - __out.extend(Vec::::cairo_serialize(&__rust.attrs)); + __out.extend(Vec::::cairo_serialize( + &__rust.attrs, + )); __out.extend(Ty::cairo_serialize(&__rust.ty)); __out } @@ -185,9 +174,7 @@ impl cainome::cairo_serde::CairoSerde for Member { let mut __offset = __offset; let name = starknet::core::types::Felt::cairo_deserialize(__felts, __offset)?; __offset += starknet::core::types::Felt::cairo_serialized_size(&name); - let attrs = Vec::< - starknet::core::types::Felt, - >::cairo_deserialize(__felts, __offset)?; + let attrs = Vec::::cairo_deserialize(__felts, __offset)?; __offset += Vec::::cairo_serialized_size(&attrs); let ty = Ty::cairo_deserialize(__felts, __offset)?; __offset += Ty::cairo_serialized_size(&ty); @@ -205,21 +192,18 @@ impl cainome::cairo_serde::CairoSerde for ResourceMetadata { #[inline] fn cairo_serialized_size(__rust: &Self::RustType) -> usize { let mut __size = 0; - __size - += starknet::core::types::Felt::cairo_serialized_size(&__rust.resource_id); - __size - += cainome::cairo_serde::ByteArray::cairo_serialized_size( - &__rust.metadata_uri, - ); + __size += starknet::core::types::Felt::cairo_serialized_size(&__rust.resource_id); + __size += cainome::cairo_serde::ByteArray::cairo_serialized_size(&__rust.metadata_uri); __size } fn cairo_serialize(__rust: &Self::RustType) -> Vec { let mut __out: Vec = vec![]; - __out.extend(starknet::core::types::Felt::cairo_serialize(&__rust.resource_id)); - __out - .extend( - cainome::cairo_serde::ByteArray::cairo_serialize(&__rust.metadata_uri), - ); + __out.extend(starknet::core::types::Felt::cairo_serialize( + &__rust.resource_id, + )); + __out.extend(cainome::cairo_serde::ByteArray::cairo_serialize( + &__rust.metadata_uri, + )); __out } fn cairo_deserialize( @@ -227,17 +211,10 @@ impl cainome::cairo_serde::CairoSerde for ResourceMetadata { __offset: usize, ) -> cainome::cairo_serde::Result { let mut __offset = __offset; - let resource_id = starknet::core::types::Felt::cairo_deserialize( - __felts, - __offset, - )?; + let resource_id = starknet::core::types::Felt::cairo_deserialize(__felts, __offset)?; __offset += starknet::core::types::Felt::cairo_serialized_size(&resource_id); - let metadata_uri = cainome::cairo_serde::ByteArray::cairo_deserialize( - __felts, - __offset, - )?; - __offset - += cainome::cairo_serde::ByteArray::cairo_serialized_size(&metadata_uri); + let metadata_uri = cainome::cairo_serde::ByteArray::cairo_deserialize(__felts, __offset)?; + __offset += cainome::cairo_serde::ByteArray::cairo_serialized_size(&metadata_uri); Ok(ResourceMetadata { resource_id, metadata_uri, @@ -257,15 +234,16 @@ impl cainome::cairo_serde::CairoSerde for Struct { fn cairo_serialized_size(__rust: &Self::RustType) -> usize { let mut __size = 0; __size += starknet::core::types::Felt::cairo_serialized_size(&__rust.name); - __size - += Vec::::cairo_serialized_size(&__rust.attrs); + __size += Vec::::cairo_serialized_size(&__rust.attrs); __size += Vec::::cairo_serialized_size(&__rust.children); __size } fn cairo_serialize(__rust: &Self::RustType) -> Vec { let mut __out: Vec = vec![]; __out.extend(starknet::core::types::Felt::cairo_serialize(&__rust.name)); - __out.extend(Vec::::cairo_serialize(&__rust.attrs)); + __out.extend(Vec::::cairo_serialize( + &__rust.attrs, + )); __out.extend(Vec::::cairo_serialize(&__rust.children)); __out } @@ -276,13 +254,15 @@ impl cainome::cairo_serde::CairoSerde for Struct { let mut __offset = __offset; let name = starknet::core::types::Felt::cairo_deserialize(__felts, __offset)?; __offset += starknet::core::types::Felt::cairo_serialized_size(&name); - let attrs = Vec::< - starknet::core::types::Felt, - >::cairo_deserialize(__felts, __offset)?; + let attrs = Vec::::cairo_deserialize(__felts, __offset)?; __offset += Vec::::cairo_serialized_size(&attrs); let children = Vec::::cairo_deserialize(__felts, __offset)?; __offset += Vec::::cairo_serialized_size(&children); - Ok(Struct { name, attrs, children }) + Ok(Struct { + name, + attrs, + children, + }) } } #[derive(Clone, serde::Serialize, serde::Deserialize, PartialEq, Debug)] @@ -309,25 +289,25 @@ impl cainome::cairo_serde::CairoSerde for Event { let __index = u128::from_be_bytes(__f.to_bytes_be()[16..].try_into().unwrap()); match __index as usize { _ => { - return Err( - cainome::cairo_serde::Error::Deserialize( - format!("Index not handle for enum {}", "Event"), - ), - ); + return Err(cainome::cairo_serde::Error::Deserialize(format!( + "Index not handle for enum {}", + "Event" + ))); } } } } impl TryFrom for Event { type Error = String; - fn try_from( - event: starknet::core::types::EmittedEvent, - ) -> Result { + fn try_from(event: starknet::core::types::EmittedEvent) -> Result { use cainome::cairo_serde::CairoSerde; if event.keys.is_empty() { return Err("Event has no key".to_string()); } - Err(format!("Could not match any event from keys {:?}", event.keys)) + Err(format!( + "Could not match any event from keys {:?}", + event.keys + )) } } #[derive(Clone, serde::Serialize, serde::Deserialize, PartialEq, Debug)] @@ -397,44 +377,32 @@ impl cainome::cairo_serde::CairoSerde for Layout { let __f = __felts[__offset]; let __index = u128::from_be_bytes(__f.to_bytes_be()[16..].try_into().unwrap()); match __index as usize { - 0usize => { - Ok(Layout::Fixed(Vec::::cairo_deserialize(__felts, __offset + 1)?)) - } - 1usize => { - Ok( - Layout::Struct( - Vec::::cairo_deserialize(__felts, __offset + 1)?, - ), - ) - } - 2usize => { - Ok( - Layout::Tuple( - Vec::::cairo_deserialize(__felts, __offset + 1)?, - ), - ) - } - 3usize => { - Ok( - Layout::Array( - Vec::::cairo_deserialize(__felts, __offset + 1)?, - ), - ) - } + 0usize => Ok(Layout::Fixed(Vec::::cairo_deserialize( + __felts, + __offset + 1, + )?)), + 1usize => Ok(Layout::Struct(Vec::::cairo_deserialize( + __felts, + __offset + 1, + )?)), + 2usize => Ok(Layout::Tuple(Vec::::cairo_deserialize( + __felts, + __offset + 1, + )?)), + 3usize => Ok(Layout::Array(Vec::::cairo_deserialize( + __felts, + __offset + 1, + )?)), 4usize => Ok(Layout::ByteArray), - 5usize => { - Ok( - Layout::Enum( - Vec::::cairo_deserialize(__felts, __offset + 1)?, - ), - ) - } + 5usize => Ok(Layout::Enum(Vec::::cairo_deserialize( + __felts, + __offset + 1, + )?)), _ => { - return Err( - cainome::cairo_serde::Error::Deserialize( - format!("Index not handle for enum {}", "Layout"), - ), - ); + return Err(cainome::cairo_serde::Error::Deserialize(format!( + "Index not handle for enum {}", + "Layout" + ))); } } } @@ -454,9 +422,7 @@ impl cainome::cairo_serde::CairoSerde for Ty { #[inline] fn cairo_serialized_size(__rust: &Self::RustType) -> usize { match __rust { - Ty::Primitive(val) => { - starknet::core::types::Felt::cairo_serialized_size(val) + 1 - } + Ty::Primitive(val) => starknet::core::types::Felt::cairo_serialized_size(val) + 1, Ty::Struct(val) => Struct::cairo_serialized_size(val) + 1, Ty::Enum(val) => Enum::cairo_serialized_size(val) + 1, Ty::Tuple(val) => Vec::::cairo_serialized_size(val) + 1, @@ -508,27 +474,28 @@ impl cainome::cairo_serde::CairoSerde for Ty { let __f = __felts[__offset]; let __index = u128::from_be_bytes(__f.to_bytes_be()[16..].try_into().unwrap()); match __index as usize { - 0usize => { - Ok( - Ty::Primitive( - starknet::core::types::Felt::cairo_deserialize( - __felts, - __offset + 1, - )?, - ), - ) - } - 1usize => Ok(Ty::Struct(Struct::cairo_deserialize(__felts, __offset + 1)?)), + 0usize => Ok(Ty::Primitive( + starknet::core::types::Felt::cairo_deserialize(__felts, __offset + 1)?, + )), + 1usize => Ok(Ty::Struct(Struct::cairo_deserialize( + __felts, + __offset + 1, + )?)), 2usize => Ok(Ty::Enum(Enum::cairo_deserialize(__felts, __offset + 1)?)), - 3usize => Ok(Ty::Tuple(Vec::::cairo_deserialize(__felts, __offset + 1)?)), - 4usize => Ok(Ty::Array(Vec::::cairo_deserialize(__felts, __offset + 1)?)), + 3usize => Ok(Ty::Tuple(Vec::::cairo_deserialize( + __felts, + __offset + 1, + )?)), + 4usize => Ok(Ty::Array(Vec::::cairo_deserialize( + __felts, + __offset + 1, + )?)), 5usize => Ok(Ty::ByteArray), _ => { - return Err( - cainome::cairo_serde::Error::Deserialize( - format!("Index not handle for enum {}", "Ty"), - ), - ); + return Err(cainome::cairo_serde::Error::Deserialize(format!( + "Index not handle for enum {}", + "Ty" + ))); } } } @@ -564,9 +531,7 @@ impl ModelContract { } #[allow(clippy::ptr_arg)] #[allow(clippy::too_many_arguments)] - pub fn packed_size( - &self, - ) -> cainome::cairo_serde::call::FCall> { + pub fn packed_size(&self) -> cainome::cairo_serde::call::FCall> { use cainome::cairo_serde::CairoSerde; let mut __calldata = vec![]; let __call = starknet::core::types::FunctionCall { @@ -604,9 +569,7 @@ impl ModelContract { } #[allow(clippy::ptr_arg)] #[allow(clippy::too_many_arguments)] - pub fn unpacked_size( - &self, - ) -> cainome::cairo_serde::call::FCall> { + pub fn unpacked_size(&self) -> cainome::cairo_serde::call::FCall> { use cainome::cairo_serde::CairoSerde; let mut __calldata = vec![]; let __call = starknet::core::types::FunctionCall { @@ -620,10 +583,7 @@ impl ModelContract { impl ModelContractReader

{ #[allow(clippy::ptr_arg)] #[allow(clippy::too_many_arguments)] - pub fn ensure_abi( - &self, - model: &ResourceMetadata, - ) -> cainome::cairo_serde::call::FCall { + pub fn ensure_abi(&self, model: &ResourceMetadata) -> cainome::cairo_serde::call::FCall { use cainome::cairo_serde::CairoSerde; let mut __calldata = vec![]; __calldata.extend(ResourceMetadata::cairo_serialize(model)); @@ -672,9 +632,7 @@ impl ModelContractReader

{ } #[allow(clippy::ptr_arg)] #[allow(clippy::too_many_arguments)] - pub fn selector( - &self, - ) -> cainome::cairo_serde::call::FCall { + pub fn selector(&self) -> cainome::cairo_serde::call::FCall { use cainome::cairo_serde::CairoSerde; let mut __calldata = vec![]; let __call = starknet::core::types::FunctionCall { diff --git a/crates/types/src/naming.rs b/crates/types/src/naming.rs new file mode 100644 index 0000000..23326b2 --- /dev/null +++ b/crates/types/src/naming.rs @@ -0,0 +1,196 @@ +use anyhow::{anyhow, Result}; +use cainome::cairo_serde::{ByteArray, CairoSerde}; +use starknet::core::types::Felt; +use starknet_crypto::poseidon_hash_many; + +pub const CONTRACT_NAME_SEPARATOR: &str = "::"; +pub const TAG_SEPARATOR: char = '-'; +pub const SELECTOR_CHUNK_SIZE: usize = 8; + +pub fn capitalize(s: &str) -> String { + let mut c = s.chars(); + match c.next() { + None => String::new(), + Some(f) => f.to_uppercase().collect::() + c.as_str(), + } +} + +pub fn get_name_from_tag(tag: &str) -> String { + let parts: Vec<&str> = tag.split(TAG_SEPARATOR).collect(); + parts.last().unwrap().to_string() +} + +pub fn get_namespace_from_tag(tag: &str) -> String { + let parts: Vec<&str> = tag.split(TAG_SEPARATOR).collect(); + parts.first().unwrap().to_string() +} + +pub fn get_tag(namespace: &str, name: &str) -> String { + format!("{namespace}{TAG_SEPARATOR}{name}") +} + +pub fn is_valid_tag(tag: &str) -> bool { + let (namespace, name) = match split_tag(tag) { + Ok((nm, n)) => (nm, n), + Err(_) => return false, + }; + + let re = regex::Regex::new(r"^[a-zA-Z0-9_]+$").unwrap(); + + re.is_match(&namespace) && re.is_match(&name) +} + +/// Get the namespace and the name of a world element from its tag. +pub fn split_tag(tag: &str) -> Result<(String, String)> { + let parts: Vec<&str> = tag.split(TAG_SEPARATOR).collect(); + match parts.len() { + 2 => Ok((parts[0].to_string(), parts[1].to_string())), + _ => Err(anyhow!( + "Unexpected tag. Expected format: {TAG_SEPARATOR} or " + )), + } +} + +pub fn ensure_namespace(tag: &str, default_namespace: &str) -> String { + if tag.contains(TAG_SEPARATOR) { + tag.to_string() + } else { + get_tag(default_namespace, tag) + } +} + +pub fn get_filename_from_tag(tag: &str) -> String { + if [ + format!("dojo{TAG_SEPARATOR}world").as_str(), + format!("dojo{TAG_SEPARATOR}base").as_str(), + ] + .contains(&tag) + { + return tag.to_string(); + } + + let mut selector = format!("{:x}", compute_selector_from_tag(tag)); + selector.truncate(SELECTOR_CHUNK_SIZE); + + format!("{tag}{TAG_SEPARATOR}{selector}") +} + +pub fn get_tag_from_filename(filename: &str) -> Result { + let parts: Vec<&str> = filename.split(TAG_SEPARATOR).collect(); + if parts.len() != 3 { + return Err(anyhow!( + "Unexpected filename. Expected format: \ + {TAG_SEPARATOR}{TAG_SEPARATOR}" + )); + } + + Ok(format!("{}{TAG_SEPARATOR}{}", parts[0], parts[1])) +} + +pub fn compute_bytearray_hash(value: &str) -> Felt { + let ba = ByteArray::from_string(value).unwrap_or_else(|_| panic!("Invalid ByteArray: {value}")); + poseidon_hash_many(&ByteArray::cairo_serialize(&ba)) +} + +pub fn compute_selector_from_tag(tag: &str) -> Felt { + let (namespace, name) = + split_tag(tag).unwrap_or_else(|_| panic!("Invalid tag to split: {tag}")); + compute_selector_from_names(&namespace, &name) +} + +pub fn compute_selector_from_names(namespace: &str, name: &str) -> Felt { + compute_selector_from_hashes( + compute_bytearray_hash(namespace), + compute_bytearray_hash(name), + ) +} + +pub fn compute_selector_from_hashes(namespace_hash: Felt, model_hash: Felt) -> Felt { + poseidon_hash_many(&[namespace_hash, model_hash]) +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn test_split_tag_success() { + assert_eq!( + split_tag("namespace-name").unwrap(), + ("namespace".to_string(), "name".to_string()) + ); + } + + #[test] + fn test_split_tag_invalid_chars() { + assert!(split_tag("invalid:namespace").is_err()); + assert!(split_tag("invalid namespace").is_err()); + assert!(split_tag("inv-alid-namespace").is_err()); + } + + #[test] + fn test_ensure_namespace_success() { + assert_eq!( + ensure_namespace("namespace-name", "default"), + "namespace-name" + ); + assert_eq!(ensure_namespace("name", "default"), "default-name"); + } + + #[test] + fn test_get_filename_from_tag_success() { + assert_eq!(get_filename_from_tag("dojo-world"), "dojo-world"); + assert_eq!(get_filename_from_tag("dojo-base"), "dojo-base"); + + let tag = "namespace-model"; + let filename = get_filename_from_tag(tag); + assert!(filename.starts_with(tag)); + assert_eq!(filename.split(TAG_SEPARATOR).count(), 3); + } + + #[test] + fn test_compute_bytearray_hash_success() { + let hash = compute_bytearray_hash("test"); + assert_eq!( + hash, + Felt::from_hex("0x2ca96bf6e71766195fa290b97c50f073b218d4e8c6948c899e3b07d754d6760") + .unwrap() + ); + } + + #[test] + fn test_compute_selector_from_tag_success() { + let selector = compute_selector_from_tag("namespace-model"); + assert_eq!( + selector, + Felt::from_hex("0x6cfe11a346c1bb31de8f454d65880454952e22d9adc2374fe67734196e0cbcb") + .unwrap() + ); + } + + #[test] + fn test_compute_selector_from_names_success() { + let selector = compute_selector_from_names("namespace", "model"); + assert_eq!( + selector, + Felt::from_hex("0x6cfe11a346c1bb31de8f454d65880454952e22d9adc2374fe67734196e0cbcb") + .unwrap() + ); + } + + #[test] + fn test_is_valid_tag_success() { + assert!(is_valid_tag("namespace-model")); + assert!(is_valid_tag("dojo-world")); + assert!(is_valid_tag("dojo_examples-base_test")); + } + + #[test] + fn test_is_valid_tag_failure() { + assert!(!is_valid_tag("invalid tag")); + assert!(!is_valid_tag("invalid@tag")); + assert!(!is_valid_tag("invalid-")); + assert!(!is_valid_tag("-invalid")); + assert!(!is_valid_tag("")); + } +} diff --git a/crates/types/src/packing.rs b/crates/types/src/packing.rs index e6aa8b6..c64fa92 100644 --- a/crates/types/src/packing.rs +++ b/crates/types/src/packing.rs @@ -10,10 +10,7 @@ pub enum ParseError { #[error("Invalid schema: {0}")] InvalidSchema(String), #[error("Value out of range")] - ValueOutOfRange { - r#type: String, - value: Felt, - }, + ValueOutOfRange { r#type: String, value: Felt }, #[error("Error when parsing felt: {0}")] FromStr(#[from] FromStrError), #[error(transparent)] @@ -62,12 +59,10 @@ pub fn unpack(mut packed: Vec, layout: Vec) -> Result, Pac let mut offset = 0; // Iterate over the layout. for size in layout { - let size: u8 = size - .to_u8() - .ok_or_else(|| ParseError::ValueOutOfRange { - r#type: type_name::().to_string(), - value: size, - })?; + let size: u8 = size.to_u8().ok_or_else(|| ParseError::ValueOutOfRange { + r#type: type_name::().to_string(), + value: size, + })?; let size: usize = size.into(); let remaining_bits = 251 - offset; diff --git a/crates/types/src/world.rs b/crates/types/src/world.rs index f4a325c..a63083a 100644 --- a/crates/types/src/world.rs +++ b/crates/types/src/world.rs @@ -16,9 +16,7 @@ impl WorldContract { Self { address, account, - block_id: starknet::core::types::BlockId::Tag( - starknet::core::types::BlockTag::Pending, - ), + block_id: starknet::core::types::BlockId::Tag(starknet::core::types::BlockTag::Pending), } } pub fn set_contract_address(&mut self, address: starknet::core::types::Felt) { @@ -45,9 +43,7 @@ impl WorldContractReader

{ Self { address, provider, - block_id: starknet::core::types::BlockId::Tag( - starknet::core::types::BlockTag::Pending, - ), + block_id: starknet::core::types::BlockId::Tag(starknet::core::types::BlockTag::Pending), } } pub fn set_contract_address(&mut self, address: starknet::core::types::Felt) { @@ -78,33 +74,27 @@ impl cainome::cairo_serde::CairoSerde for ContractDeployed { fn cairo_serialized_size(__rust: &Self::RustType) -> usize { let mut __size = 0; __size += starknet::core::types::Felt::cairo_serialized_size(&__rust.salt); - __size - += cainome::cairo_serde::ClassHash::cairo_serialized_size( - &__rust.class_hash, - ); - __size - += cainome::cairo_serde::ContractAddress::cairo_serialized_size( - &__rust.address, - ); - __size - += cainome::cairo_serde::ByteArray::cairo_serialized_size(&__rust.namespace); + __size += cainome::cairo_serde::ClassHash::cairo_serialized_size(&__rust.class_hash); + __size += cainome::cairo_serde::ContractAddress::cairo_serialized_size(&__rust.address); + __size += cainome::cairo_serde::ByteArray::cairo_serialized_size(&__rust.namespace); __size += cainome::cairo_serde::ByteArray::cairo_serialized_size(&__rust.name); __size } fn cairo_serialize(__rust: &Self::RustType) -> Vec { let mut __out: Vec = vec![]; __out.extend(starknet::core::types::Felt::cairo_serialize(&__rust.salt)); - __out - .extend( - cainome::cairo_serde::ClassHash::cairo_serialize(&__rust.class_hash), - ); - __out - .extend( - cainome::cairo_serde::ContractAddress::cairo_serialize(&__rust.address), - ); - __out - .extend(cainome::cairo_serde::ByteArray::cairo_serialize(&__rust.namespace)); - __out.extend(cainome::cairo_serde::ByteArray::cairo_serialize(&__rust.name)); + __out.extend(cainome::cairo_serde::ClassHash::cairo_serialize( + &__rust.class_hash, + )); + __out.extend(cainome::cairo_serde::ContractAddress::cairo_serialize( + &__rust.address, + )); + __out.extend(cainome::cairo_serde::ByteArray::cairo_serialize( + &__rust.namespace, + )); + __out.extend(cainome::cairo_serde::ByteArray::cairo_serialize( + &__rust.name, + )); __out } fn cairo_deserialize( @@ -114,26 +104,13 @@ impl cainome::cairo_serde::CairoSerde for ContractDeployed { let mut __offset = __offset; let salt = starknet::core::types::Felt::cairo_deserialize(__felts, __offset)?; __offset += starknet::core::types::Felt::cairo_serialized_size(&salt); - let class_hash = cainome::cairo_serde::ClassHash::cairo_deserialize( - __felts, - __offset, - )?; + let class_hash = cainome::cairo_serde::ClassHash::cairo_deserialize(__felts, __offset)?; __offset += cainome::cairo_serde::ClassHash::cairo_serialized_size(&class_hash); - let address = cainome::cairo_serde::ContractAddress::cairo_deserialize( - __felts, - __offset, - )?; - __offset - += cainome::cairo_serde::ContractAddress::cairo_serialized_size(&address); - let namespace = cainome::cairo_serde::ByteArray::cairo_deserialize( - __felts, - __offset, - )?; + let address = cainome::cairo_serde::ContractAddress::cairo_deserialize(__felts, __offset)?; + __offset += cainome::cairo_serde::ContractAddress::cairo_serialized_size(&address); + let namespace = cainome::cairo_serde::ByteArray::cairo_deserialize(__felts, __offset)?; __offset += cainome::cairo_serde::ByteArray::cairo_serialized_size(&namespace); - let name = cainome::cairo_serde::ByteArray::cairo_deserialize( - __felts, - __offset, - )?; + let name = cainome::cairo_serde::ByteArray::cairo_deserialize(__felts, __offset)?; __offset += cainome::cairo_serde::ByteArray::cairo_serialized_size(&name); Ok(ContractDeployed { salt, @@ -156,21 +133,17 @@ impl cainome::cairo_serde::CairoSerde for ContractInitialized { fn cairo_serialized_size(__rust: &Self::RustType) -> usize { let mut __size = 0; __size += starknet::core::types::Felt::cairo_serialized_size(&__rust.selector); - __size - += Vec::< - starknet::core::types::Felt, - >::cairo_serialized_size(&__rust.init_calldata); + __size += Vec::::cairo_serialized_size(&__rust.init_calldata); __size } fn cairo_serialize(__rust: &Self::RustType) -> Vec { let mut __out: Vec = vec![]; - __out.extend(starknet::core::types::Felt::cairo_serialize(&__rust.selector)); - __out - .extend( - Vec::< - starknet::core::types::Felt, - >::cairo_serialize(&__rust.init_calldata), - ); + __out.extend(starknet::core::types::Felt::cairo_serialize( + &__rust.selector, + )); + __out.extend(Vec::::cairo_serialize( + &__rust.init_calldata, + )); __out } fn cairo_deserialize( @@ -178,16 +151,11 @@ impl cainome::cairo_serde::CairoSerde for ContractInitialized { __offset: usize, ) -> cainome::cairo_serde::Result { let mut __offset = __offset; - let selector = starknet::core::types::Felt::cairo_deserialize( - __felts, - __offset, - )?; + let selector = starknet::core::types::Felt::cairo_deserialize(__felts, __offset)?; __offset += starknet::core::types::Felt::cairo_serialized_size(&selector); - let init_calldata = Vec::< - starknet::core::types::Felt, - >::cairo_deserialize(__felts, __offset)?; - __offset - += Vec::::cairo_serialized_size(&init_calldata); + let init_calldata = + Vec::::cairo_deserialize(__felts, __offset)?; + __offset += Vec::::cairo_serialized_size(&init_calldata); Ok(ContractInitialized { selector, init_calldata, @@ -205,26 +173,18 @@ impl cainome::cairo_serde::CairoSerde for ContractUpgraded { #[inline] fn cairo_serialized_size(__rust: &Self::RustType) -> usize { let mut __size = 0; - __size - += cainome::cairo_serde::ClassHash::cairo_serialized_size( - &__rust.class_hash, - ); - __size - += cainome::cairo_serde::ContractAddress::cairo_serialized_size( - &__rust.address, - ); + __size += cainome::cairo_serde::ClassHash::cairo_serialized_size(&__rust.class_hash); + __size += cainome::cairo_serde::ContractAddress::cairo_serialized_size(&__rust.address); __size } fn cairo_serialize(__rust: &Self::RustType) -> Vec { let mut __out: Vec = vec![]; - __out - .extend( - cainome::cairo_serde::ClassHash::cairo_serialize(&__rust.class_hash), - ); - __out - .extend( - cainome::cairo_serde::ContractAddress::cairo_serialize(&__rust.address), - ); + __out.extend(cainome::cairo_serde::ClassHash::cairo_serialize( + &__rust.class_hash, + )); + __out.extend(cainome::cairo_serde::ContractAddress::cairo_serialize( + &__rust.address, + )); __out } fn cairo_deserialize( @@ -232,17 +192,10 @@ impl cainome::cairo_serde::CairoSerde for ContractUpgraded { __offset: usize, ) -> cainome::cairo_serde::Result { let mut __offset = __offset; - let class_hash = cainome::cairo_serde::ClassHash::cairo_deserialize( - __felts, - __offset, - )?; + let class_hash = cainome::cairo_serde::ClassHash::cairo_deserialize(__felts, __offset)?; __offset += cainome::cairo_serde::ClassHash::cairo_serialized_size(&class_hash); - let address = cainome::cairo_serde::ContractAddress::cairo_deserialize( - __felts, - __offset, - )?; - __offset - += cainome::cairo_serde::ContractAddress::cairo_serialized_size(&address); + let address = cainome::cairo_serde::ContractAddress::cairo_deserialize(__felts, __offset)?; + __offset += cainome::cairo_serde::ContractAddress::cairo_serialized_size(&address); Ok(ContractUpgraded { class_hash, address, @@ -259,13 +212,14 @@ impl cainome::cairo_serde::CairoSerde for DifferProgramHashUpdate { #[inline] fn cairo_serialized_size(__rust: &Self::RustType) -> usize { let mut __size = 0; - __size - += starknet::core::types::Felt::cairo_serialized_size(&__rust.program_hash); + __size += starknet::core::types::Felt::cairo_serialized_size(&__rust.program_hash); __size } fn cairo_serialize(__rust: &Self::RustType) -> Vec { let mut __out: Vec = vec![]; - __out.extend(starknet::core::types::Felt::cairo_serialize(&__rust.program_hash)); + __out.extend(starknet::core::types::Felt::cairo_serialize( + &__rust.program_hash, + )); __out } fn cairo_deserialize( @@ -273,14 +227,9 @@ impl cainome::cairo_serde::CairoSerde for DifferProgramHashUpdate { __offset: usize, ) -> cainome::cairo_serde::Result { let mut __offset = __offset; - let program_hash = starknet::core::types::Felt::cairo_deserialize( - __felts, - __offset, - )?; + let program_hash = starknet::core::types::Felt::cairo_deserialize(__felts, __offset)?; __offset += starknet::core::types::Felt::cairo_serialized_size(&program_hash); - Ok(DifferProgramHashUpdate { - program_hash, - }) + Ok(DifferProgramHashUpdate { program_hash }) } } #[derive(Clone, serde::Serialize, serde::Deserialize, PartialEq, Debug)] @@ -293,18 +242,14 @@ impl cainome::cairo_serde::CairoSerde for FactsRegistryUpdate { #[inline] fn cairo_serialized_size(__rust: &Self::RustType) -> usize { let mut __size = 0; - __size - += cainome::cairo_serde::ContractAddress::cairo_serialized_size( - &__rust.address, - ); + __size += cainome::cairo_serde::ContractAddress::cairo_serialized_size(&__rust.address); __size } fn cairo_serialize(__rust: &Self::RustType) -> Vec { let mut __out: Vec = vec![]; - __out - .extend( - cainome::cairo_serde::ContractAddress::cairo_serialize(&__rust.address), - ); + __out.extend(cainome::cairo_serde::ContractAddress::cairo_serialize( + &__rust.address, + )); __out } fn cairo_deserialize( @@ -312,12 +257,8 @@ impl cainome::cairo_serde::CairoSerde for FactsRegistryUpdate { __offset: usize, ) -> cainome::cairo_serde::Result { let mut __offset = __offset; - let address = cainome::cairo_serde::ContractAddress::cairo_deserialize( - __felts, - __offset, - )?; - __offset - += cainome::cairo_serde::ContractAddress::cairo_serialized_size(&address); + let address = cainome::cairo_serde::ContractAddress::cairo_deserialize(__felts, __offset)?; + __offset += cainome::cairo_serde::ContractAddress::cairo_serialized_size(&address); Ok(FactsRegistryUpdate { address }) } } @@ -338,7 +279,9 @@ impl cainome::cairo_serde::CairoSerde for FieldLayout { } fn cairo_serialize(__rust: &Self::RustType) -> Vec { let mut __out: Vec = vec![]; - __out.extend(starknet::core::types::Felt::cairo_serialize(&__rust.selector)); + __out.extend(starknet::core::types::Felt::cairo_serialize( + &__rust.selector, + )); __out.extend(Layout::cairo_serialize(&__rust.layout)); __out } @@ -347,10 +290,7 @@ impl cainome::cairo_serde::CairoSerde for FieldLayout { __offset: usize, ) -> cainome::cairo_serde::Result { let mut __offset = __offset; - let selector = starknet::core::types::Felt::cairo_deserialize( - __felts, - __offset, - )?; + let selector = starknet::core::types::Felt::cairo_deserialize(__felts, __offset)?; __offset += starknet::core::types::Felt::cairo_serialized_size(&selector); let layout = Layout::cairo_deserialize(__felts, __offset)?; __offset += Layout::cairo_serialized_size(&layout); @@ -367,13 +307,14 @@ impl cainome::cairo_serde::CairoSerde for MergerProgramHashUpdate { #[inline] fn cairo_serialized_size(__rust: &Self::RustType) -> usize { let mut __size = 0; - __size - += starknet::core::types::Felt::cairo_serialized_size(&__rust.program_hash); + __size += starknet::core::types::Felt::cairo_serialized_size(&__rust.program_hash); __size } fn cairo_serialize(__rust: &Self::RustType) -> Vec { let mut __out: Vec = vec![]; - __out.extend(starknet::core::types::Felt::cairo_serialize(&__rust.program_hash)); + __out.extend(starknet::core::types::Felt::cairo_serialize( + &__rust.program_hash, + )); __out } fn cairo_deserialize( @@ -381,14 +322,9 @@ impl cainome::cairo_serde::CairoSerde for MergerProgramHashUpdate { __offset: usize, ) -> cainome::cairo_serde::Result { let mut __offset = __offset; - let program_hash = starknet::core::types::Felt::cairo_deserialize( - __felts, - __offset, - )?; + let program_hash = starknet::core::types::Felt::cairo_deserialize(__felts, __offset)?; __offset += starknet::core::types::Felt::cairo_serialized_size(&program_hash); - Ok(MergerProgramHashUpdate { - program_hash, - }) + Ok(MergerProgramHashUpdate { program_hash }) } } #[derive(Clone, serde::Serialize, serde::Deserialize, PartialEq, Debug)] @@ -408,8 +344,12 @@ impl cainome::cairo_serde::CairoSerde for MetadataUpdate { } fn cairo_serialize(__rust: &Self::RustType) -> Vec { let mut __out: Vec = vec![]; - __out.extend(starknet::core::types::Felt::cairo_serialize(&__rust.resource)); - __out.extend(cainome::cairo_serde::ByteArray::cairo_serialize(&__rust.uri)); + __out.extend(starknet::core::types::Felt::cairo_serialize( + &__rust.resource, + )); + __out.extend(cainome::cairo_serde::ByteArray::cairo_serialize( + &__rust.uri, + )); __out } fn cairo_deserialize( @@ -417,10 +357,7 @@ impl cainome::cairo_serde::CairoSerde for MetadataUpdate { __offset: usize, ) -> cainome::cairo_serde::Result { let mut __offset = __offset; - let resource = starknet::core::types::Felt::cairo_deserialize( - __felts, - __offset, - )?; + let resource = starknet::core::types::Felt::cairo_deserialize(__felts, __offset)?; __offset += starknet::core::types::Felt::cairo_serialized_size(&resource); let uri = cainome::cairo_serde::ByteArray::cairo_deserialize(__felts, __offset)?; __offset += cainome::cairo_serde::ByteArray::cairo_serialized_size(&uri); @@ -441,31 +378,25 @@ impl cainome::cairo_serde::CairoSerde for ModelRegistered { fn cairo_serialized_size(__rust: &Self::RustType) -> usize { let mut __size = 0; __size += cainome::cairo_serde::ByteArray::cairo_serialized_size(&__rust.name); - __size - += cainome::cairo_serde::ByteArray::cairo_serialized_size(&__rust.namespace); - __size - += cainome::cairo_serde::ClassHash::cairo_serialized_size( - &__rust.class_hash, - ); - __size - += cainome::cairo_serde::ContractAddress::cairo_serialized_size( - &__rust.address, - ); + __size += cainome::cairo_serde::ByteArray::cairo_serialized_size(&__rust.namespace); + __size += cainome::cairo_serde::ClassHash::cairo_serialized_size(&__rust.class_hash); + __size += cainome::cairo_serde::ContractAddress::cairo_serialized_size(&__rust.address); __size } fn cairo_serialize(__rust: &Self::RustType) -> Vec { let mut __out: Vec = vec![]; - __out.extend(cainome::cairo_serde::ByteArray::cairo_serialize(&__rust.name)); - __out - .extend(cainome::cairo_serde::ByteArray::cairo_serialize(&__rust.namespace)); - __out - .extend( - cainome::cairo_serde::ClassHash::cairo_serialize(&__rust.class_hash), - ); - __out - .extend( - cainome::cairo_serde::ContractAddress::cairo_serialize(&__rust.address), - ); + __out.extend(cainome::cairo_serde::ByteArray::cairo_serialize( + &__rust.name, + )); + __out.extend(cainome::cairo_serde::ByteArray::cairo_serialize( + &__rust.namespace, + )); + __out.extend(cainome::cairo_serde::ClassHash::cairo_serialize( + &__rust.class_hash, + )); + __out.extend(cainome::cairo_serde::ContractAddress::cairo_serialize( + &__rust.address, + )); __out } fn cairo_deserialize( @@ -473,27 +404,14 @@ impl cainome::cairo_serde::CairoSerde for ModelRegistered { __offset: usize, ) -> cainome::cairo_serde::Result { let mut __offset = __offset; - let name = cainome::cairo_serde::ByteArray::cairo_deserialize( - __felts, - __offset, - )?; + let name = cainome::cairo_serde::ByteArray::cairo_deserialize(__felts, __offset)?; __offset += cainome::cairo_serde::ByteArray::cairo_serialized_size(&name); - let namespace = cainome::cairo_serde::ByteArray::cairo_deserialize( - __felts, - __offset, - )?; + let namespace = cainome::cairo_serde::ByteArray::cairo_deserialize(__felts, __offset)?; __offset += cainome::cairo_serde::ByteArray::cairo_serialized_size(&namespace); - let class_hash = cainome::cairo_serde::ClassHash::cairo_deserialize( - __felts, - __offset, - )?; + let class_hash = cainome::cairo_serde::ClassHash::cairo_deserialize(__felts, __offset)?; __offset += cainome::cairo_serde::ClassHash::cairo_serialized_size(&class_hash); - let address = cainome::cairo_serde::ContractAddress::cairo_deserialize( - __felts, - __offset, - )?; - __offset - += cainome::cairo_serde::ContractAddress::cairo_serialized_size(&address); + let address = cainome::cairo_serde::ContractAddress::cairo_deserialize(__felts, __offset)?; + __offset += cainome::cairo_serde::ContractAddress::cairo_serialized_size(&address); Ok(ModelRegistered { name, namespace, @@ -518,49 +436,34 @@ impl cainome::cairo_serde::CairoSerde for ModelUpgraded { fn cairo_serialized_size(__rust: &Self::RustType) -> usize { let mut __size = 0; __size += cainome::cairo_serde::ByteArray::cairo_serialized_size(&__rust.name); - __size - += cainome::cairo_serde::ByteArray::cairo_serialized_size(&__rust.namespace); - __size - += cainome::cairo_serde::ClassHash::cairo_serialized_size( - &__rust.class_hash, - ); - __size - += cainome::cairo_serde::ClassHash::cairo_serialized_size( - &__rust.prev_class_hash, - ); - __size - += cainome::cairo_serde::ContractAddress::cairo_serialized_size( - &__rust.address, - ); - __size - += cainome::cairo_serde::ContractAddress::cairo_serialized_size( - &__rust.prev_address, - ); + __size += cainome::cairo_serde::ByteArray::cairo_serialized_size(&__rust.namespace); + __size += cainome::cairo_serde::ClassHash::cairo_serialized_size(&__rust.class_hash); + __size += cainome::cairo_serde::ClassHash::cairo_serialized_size(&__rust.prev_class_hash); + __size += cainome::cairo_serde::ContractAddress::cairo_serialized_size(&__rust.address); + __size += + cainome::cairo_serde::ContractAddress::cairo_serialized_size(&__rust.prev_address); __size } fn cairo_serialize(__rust: &Self::RustType) -> Vec { let mut __out: Vec = vec![]; - __out.extend(cainome::cairo_serde::ByteArray::cairo_serialize(&__rust.name)); - __out - .extend(cainome::cairo_serde::ByteArray::cairo_serialize(&__rust.namespace)); - __out - .extend( - cainome::cairo_serde::ClassHash::cairo_serialize(&__rust.class_hash), - ); - __out - .extend( - cainome::cairo_serde::ClassHash::cairo_serialize(&__rust.prev_class_hash), - ); - __out - .extend( - cainome::cairo_serde::ContractAddress::cairo_serialize(&__rust.address), - ); - __out - .extend( - cainome::cairo_serde::ContractAddress::cairo_serialize( - &__rust.prev_address, - ), - ); + __out.extend(cainome::cairo_serde::ByteArray::cairo_serialize( + &__rust.name, + )); + __out.extend(cainome::cairo_serde::ByteArray::cairo_serialize( + &__rust.namespace, + )); + __out.extend(cainome::cairo_serde::ClassHash::cairo_serialize( + &__rust.class_hash, + )); + __out.extend(cainome::cairo_serde::ClassHash::cairo_serialize( + &__rust.prev_class_hash, + )); + __out.extend(cainome::cairo_serde::ContractAddress::cairo_serialize( + &__rust.address, + )); + __out.extend(cainome::cairo_serde::ContractAddress::cairo_serialize( + &__rust.prev_address, + )); __out } fn cairo_deserialize( @@ -568,41 +471,20 @@ impl cainome::cairo_serde::CairoSerde for ModelUpgraded { __offset: usize, ) -> cainome::cairo_serde::Result { let mut __offset = __offset; - let name = cainome::cairo_serde::ByteArray::cairo_deserialize( - __felts, - __offset, - )?; + let name = cainome::cairo_serde::ByteArray::cairo_deserialize(__felts, __offset)?; __offset += cainome::cairo_serde::ByteArray::cairo_serialized_size(&name); - let namespace = cainome::cairo_serde::ByteArray::cairo_deserialize( - __felts, - __offset, - )?; + let namespace = cainome::cairo_serde::ByteArray::cairo_deserialize(__felts, __offset)?; __offset += cainome::cairo_serde::ByteArray::cairo_serialized_size(&namespace); - let class_hash = cainome::cairo_serde::ClassHash::cairo_deserialize( - __felts, - __offset, - )?; + let class_hash = cainome::cairo_serde::ClassHash::cairo_deserialize(__felts, __offset)?; __offset += cainome::cairo_serde::ClassHash::cairo_serialized_size(&class_hash); - let prev_class_hash = cainome::cairo_serde::ClassHash::cairo_deserialize( - __felts, - __offset, - )?; - __offset - += cainome::cairo_serde::ClassHash::cairo_serialized_size(&prev_class_hash); - let address = cainome::cairo_serde::ContractAddress::cairo_deserialize( - __felts, - __offset, - )?; - __offset - += cainome::cairo_serde::ContractAddress::cairo_serialized_size(&address); - let prev_address = cainome::cairo_serde::ContractAddress::cairo_deserialize( - __felts, - __offset, - )?; - __offset - += cainome::cairo_serde::ContractAddress::cairo_serialized_size( - &prev_address, - ); + let prev_class_hash = + cainome::cairo_serde::ClassHash::cairo_deserialize(__felts, __offset)?; + __offset += cainome::cairo_serde::ClassHash::cairo_serialized_size(&prev_class_hash); + let address = cainome::cairo_serde::ContractAddress::cairo_deserialize(__felts, __offset)?; + __offset += cainome::cairo_serde::ContractAddress::cairo_serialized_size(&address); + let prev_address = + cainome::cairo_serde::ContractAddress::cairo_deserialize(__felts, __offset)?; + __offset += cainome::cairo_serde::ContractAddress::cairo_serialized_size(&prev_address); Ok(ModelUpgraded { name, namespace, @@ -624,15 +506,15 @@ impl cainome::cairo_serde::CairoSerde for NamespaceRegistered { #[inline] fn cairo_serialized_size(__rust: &Self::RustType) -> usize { let mut __size = 0; - __size - += cainome::cairo_serde::ByteArray::cairo_serialized_size(&__rust.namespace); + __size += cainome::cairo_serde::ByteArray::cairo_serialized_size(&__rust.namespace); __size += starknet::core::types::Felt::cairo_serialized_size(&__rust.hash); __size } fn cairo_serialize(__rust: &Self::RustType) -> Vec { let mut __out: Vec = vec![]; - __out - .extend(cainome::cairo_serde::ByteArray::cairo_serialize(&__rust.namespace)); + __out.extend(cainome::cairo_serde::ByteArray::cairo_serialize( + &__rust.namespace, + )); __out.extend(starknet::core::types::Felt::cairo_serialize(&__rust.hash)); __out } @@ -641,17 +523,11 @@ impl cainome::cairo_serde::CairoSerde for NamespaceRegistered { __offset: usize, ) -> cainome::cairo_serde::Result { let mut __offset = __offset; - let namespace = cainome::cairo_serde::ByteArray::cairo_deserialize( - __felts, - __offset, - )?; + let namespace = cainome::cairo_serde::ByteArray::cairo_deserialize(__felts, __offset)?; __offset += cainome::cairo_serde::ByteArray::cairo_serialized_size(&namespace); let hash = starknet::core::types::Felt::cairo_deserialize(__felts, __offset)?; __offset += starknet::core::types::Felt::cairo_serialized_size(&hash); - Ok(NamespaceRegistered { - namespace, - hash, - }) + Ok(NamespaceRegistered { namespace, hash }) } } #[derive(Clone, serde::Serialize, serde::Deserialize, PartialEq, Debug)] @@ -666,21 +542,19 @@ impl cainome::cairo_serde::CairoSerde for OwnerUpdated { #[inline] fn cairo_serialized_size(__rust: &Self::RustType) -> usize { let mut __size = 0; - __size - += cainome::cairo_serde::ContractAddress::cairo_serialized_size( - &__rust.address, - ); + __size += cainome::cairo_serde::ContractAddress::cairo_serialized_size(&__rust.address); __size += starknet::core::types::Felt::cairo_serialized_size(&__rust.resource); __size += bool::cairo_serialized_size(&__rust.value); __size } fn cairo_serialize(__rust: &Self::RustType) -> Vec { let mut __out: Vec = vec![]; - __out - .extend( - cainome::cairo_serde::ContractAddress::cairo_serialize(&__rust.address), - ); - __out.extend(starknet::core::types::Felt::cairo_serialize(&__rust.resource)); + __out.extend(cainome::cairo_serde::ContractAddress::cairo_serialize( + &__rust.address, + )); + __out.extend(starknet::core::types::Felt::cairo_serialize( + &__rust.resource, + )); __out.extend(bool::cairo_serialize(&__rust.value)); __out } @@ -689,16 +563,9 @@ impl cainome::cairo_serde::CairoSerde for OwnerUpdated { __offset: usize, ) -> cainome::cairo_serde::Result { let mut __offset = __offset; - let address = cainome::cairo_serde::ContractAddress::cairo_deserialize( - __felts, - __offset, - )?; - __offset - += cainome::cairo_serde::ContractAddress::cairo_serialized_size(&address); - let resource = starknet::core::types::Felt::cairo_deserialize( - __felts, - __offset, - )?; + let address = cainome::cairo_serde::ContractAddress::cairo_deserialize(__felts, __offset)?; + __offset += cainome::cairo_serde::ContractAddress::cairo_serialized_size(&address); + let resource = starknet::core::types::Felt::cairo_deserialize(__felts, __offset)?; __offset += starknet::core::types::Felt::cairo_serialized_size(&resource); let value = bool::cairo_deserialize(__felts, __offset)?; __offset += bool::cairo_serialized_size(&value); @@ -726,58 +593,46 @@ impl cainome::cairo_serde::CairoSerde for ProgramOutput { #[inline] fn cairo_serialized_size(__rust: &Self::RustType) -> usize { let mut __size = 0; - __size - += starknet::core::types::Felt::cairo_serialized_size( - &__rust.prev_state_root, - ); - __size - += starknet::core::types::Felt::cairo_serialized_size( - &__rust.new_state_root, - ); - __size - += starknet::core::types::Felt::cairo_serialized_size(&__rust.block_number); + __size += starknet::core::types::Felt::cairo_serialized_size(&__rust.prev_state_root); + __size += starknet::core::types::Felt::cairo_serialized_size(&__rust.new_state_root); + __size += starknet::core::types::Felt::cairo_serialized_size(&__rust.block_number); __size += starknet::core::types::Felt::cairo_serialized_size(&__rust.block_hash); - __size - += starknet::core::types::Felt::cairo_serialized_size(&__rust.config_hash); - __size - += starknet::core::types::Felt::cairo_serialized_size(&__rust.world_da_hash); - __size - += Vec::< - starknet::core::types::Felt, - >::cairo_serialized_size(&__rust.message_to_starknet_segment); - __size - += Vec::< - starknet::core::types::Felt, - >::cairo_serialized_size(&__rust.message_to_appchain_segment); + __size += starknet::core::types::Felt::cairo_serialized_size(&__rust.config_hash); + __size += starknet::core::types::Felt::cairo_serialized_size(&__rust.world_da_hash); + __size += Vec::::cairo_serialized_size( + &__rust.message_to_starknet_segment, + ); + __size += Vec::::cairo_serialized_size( + &__rust.message_to_appchain_segment, + ); __size } fn cairo_serialize(__rust: &Self::RustType) -> Vec { let mut __out: Vec = vec![]; - __out - .extend( - starknet::core::types::Felt::cairo_serialize(&__rust.prev_state_root), - ); - __out - .extend( - starknet::core::types::Felt::cairo_serialize(&__rust.new_state_root), - ); - __out.extend(starknet::core::types::Felt::cairo_serialize(&__rust.block_number)); - __out.extend(starknet::core::types::Felt::cairo_serialize(&__rust.block_hash)); - __out.extend(starknet::core::types::Felt::cairo_serialize(&__rust.config_hash)); - __out - .extend(starknet::core::types::Felt::cairo_serialize(&__rust.world_da_hash)); - __out - .extend( - Vec::< - starknet::core::types::Felt, - >::cairo_serialize(&__rust.message_to_starknet_segment), - ); - __out - .extend( - Vec::< - starknet::core::types::Felt, - >::cairo_serialize(&__rust.message_to_appchain_segment), - ); + __out.extend(starknet::core::types::Felt::cairo_serialize( + &__rust.prev_state_root, + )); + __out.extend(starknet::core::types::Felt::cairo_serialize( + &__rust.new_state_root, + )); + __out.extend(starknet::core::types::Felt::cairo_serialize( + &__rust.block_number, + )); + __out.extend(starknet::core::types::Felt::cairo_serialize( + &__rust.block_hash, + )); + __out.extend(starknet::core::types::Felt::cairo_serialize( + &__rust.config_hash, + )); + __out.extend(starknet::core::types::Felt::cairo_serialize( + &__rust.world_da_hash, + )); + __out.extend(Vec::::cairo_serialize( + &__rust.message_to_starknet_segment, + )); + __out.extend(Vec::::cairo_serialize( + &__rust.message_to_appchain_segment, + )); __out } fn cairo_deserialize( @@ -785,50 +640,26 @@ impl cainome::cairo_serde::CairoSerde for ProgramOutput { __offset: usize, ) -> cainome::cairo_serde::Result { let mut __offset = __offset; - let prev_state_root = starknet::core::types::Felt::cairo_deserialize( - __felts, - __offset, - )?; + let prev_state_root = starknet::core::types::Felt::cairo_deserialize(__felts, __offset)?; __offset += starknet::core::types::Felt::cairo_serialized_size(&prev_state_root); - let new_state_root = starknet::core::types::Felt::cairo_deserialize( - __felts, - __offset, - )?; + let new_state_root = starknet::core::types::Felt::cairo_deserialize(__felts, __offset)?; __offset += starknet::core::types::Felt::cairo_serialized_size(&new_state_root); - let block_number = starknet::core::types::Felt::cairo_deserialize( - __felts, - __offset, - )?; + let block_number = starknet::core::types::Felt::cairo_deserialize(__felts, __offset)?; __offset += starknet::core::types::Felt::cairo_serialized_size(&block_number); - let block_hash = starknet::core::types::Felt::cairo_deserialize( - __felts, - __offset, - )?; + let block_hash = starknet::core::types::Felt::cairo_deserialize(__felts, __offset)?; __offset += starknet::core::types::Felt::cairo_serialized_size(&block_hash); - let config_hash = starknet::core::types::Felt::cairo_deserialize( - __felts, - __offset, - )?; + let config_hash = starknet::core::types::Felt::cairo_deserialize(__felts, __offset)?; __offset += starknet::core::types::Felt::cairo_serialized_size(&config_hash); - let world_da_hash = starknet::core::types::Felt::cairo_deserialize( - __felts, - __offset, - )?; + let world_da_hash = starknet::core::types::Felt::cairo_deserialize(__felts, __offset)?; __offset += starknet::core::types::Felt::cairo_serialized_size(&world_da_hash); - let message_to_starknet_segment = Vec::< - starknet::core::types::Felt, - >::cairo_deserialize(__felts, __offset)?; - __offset - += Vec::< - starknet::core::types::Felt, - >::cairo_serialized_size(&message_to_starknet_segment); - let message_to_appchain_segment = Vec::< - starknet::core::types::Felt, - >::cairo_deserialize(__felts, __offset)?; - __offset - += Vec::< - starknet::core::types::Felt, - >::cairo_serialized_size(&message_to_appchain_segment); + let message_to_starknet_segment = + Vec::::cairo_deserialize(__felts, __offset)?; + __offset += + Vec::::cairo_serialized_size(&message_to_starknet_segment); + let message_to_appchain_segment = + Vec::::cairo_deserialize(__felts, __offset)?; + __offset += + Vec::::cairo_serialized_size(&message_to_appchain_segment); Ok(ProgramOutput { prev_state_root, new_state_root, @@ -852,21 +683,18 @@ impl cainome::cairo_serde::CairoSerde for ResourceMetadata { #[inline] fn cairo_serialized_size(__rust: &Self::RustType) -> usize { let mut __size = 0; - __size - += starknet::core::types::Felt::cairo_serialized_size(&__rust.resource_id); - __size - += cainome::cairo_serde::ByteArray::cairo_serialized_size( - &__rust.metadata_uri, - ); + __size += starknet::core::types::Felt::cairo_serialized_size(&__rust.resource_id); + __size += cainome::cairo_serde::ByteArray::cairo_serialized_size(&__rust.metadata_uri); __size } fn cairo_serialize(__rust: &Self::RustType) -> Vec { let mut __out: Vec = vec![]; - __out.extend(starknet::core::types::Felt::cairo_serialize(&__rust.resource_id)); - __out - .extend( - cainome::cairo_serde::ByteArray::cairo_serialize(&__rust.metadata_uri), - ); + __out.extend(starknet::core::types::Felt::cairo_serialize( + &__rust.resource_id, + )); + __out.extend(cainome::cairo_serde::ByteArray::cairo_serialize( + &__rust.metadata_uri, + )); __out } fn cairo_deserialize( @@ -874,17 +702,10 @@ impl cainome::cairo_serde::CairoSerde for ResourceMetadata { __offset: usize, ) -> cainome::cairo_serde::Result { let mut __offset = __offset; - let resource_id = starknet::core::types::Felt::cairo_deserialize( - __felts, - __offset, - )?; + let resource_id = starknet::core::types::Felt::cairo_deserialize(__felts, __offset)?; __offset += starknet::core::types::Felt::cairo_serialized_size(&resource_id); - let metadata_uri = cainome::cairo_serde::ByteArray::cairo_deserialize( - __felts, - __offset, - )?; - __offset - += cainome::cairo_serde::ByteArray::cairo_serialized_size(&metadata_uri); + let metadata_uri = cainome::cairo_serde::ByteArray::cairo_deserialize(__felts, __offset)?; + __offset += cainome::cairo_serde::ByteArray::cairo_serialized_size(&metadata_uri); Ok(ResourceMetadata { resource_id, metadata_uri, @@ -906,7 +727,9 @@ impl cainome::cairo_serde::CairoSerde for StateUpdated { } fn cairo_serialize(__rust: &Self::RustType) -> Vec { let mut __out: Vec = vec![]; - __out.extend(starknet::core::types::Felt::cairo_serialize(&__rust.da_hash)); + __out.extend(starknet::core::types::Felt::cairo_serialize( + &__rust.da_hash, + )); __out } fn cairo_deserialize( @@ -970,7 +793,9 @@ impl cainome::cairo_serde::CairoSerde for StoreDelRecord { fn cairo_serialize(__rust: &Self::RustType) -> Vec { let mut __out: Vec = vec![]; __out.extend(starknet::core::types::Felt::cairo_serialize(&__rust.table)); - __out.extend(starknet::core::types::Felt::cairo_serialize(&__rust.entity_id)); + __out.extend(starknet::core::types::Felt::cairo_serialize( + &__rust.entity_id, + )); __out } fn cairo_deserialize( @@ -980,10 +805,7 @@ impl cainome::cairo_serde::CairoSerde for StoreDelRecord { let mut __offset = __offset; let table = starknet::core::types::Felt::cairo_deserialize(__felts, __offset)?; __offset += starknet::core::types::Felt::cairo_serialized_size(&table); - let entity_id = starknet::core::types::Felt::cairo_deserialize( - __felts, - __offset, - )?; + let entity_id = starknet::core::types::Felt::cairo_deserialize(__felts, __offset)?; __offset += starknet::core::types::Felt::cairo_serialized_size(&entity_id); Ok(StoreDelRecord { table, entity_id }) } @@ -1003,19 +825,22 @@ impl cainome::cairo_serde::CairoSerde for StoreSetRecord { let mut __size = 0; __size += starknet::core::types::Felt::cairo_serialized_size(&__rust.table); __size += starknet::core::types::Felt::cairo_serialized_size(&__rust.entity_id); - __size - += Vec::::cairo_serialized_size(&__rust.keys); - __size - += Vec::::cairo_serialized_size(&__rust.values); + __size += Vec::::cairo_serialized_size(&__rust.keys); + __size += Vec::::cairo_serialized_size(&__rust.values); __size } fn cairo_serialize(__rust: &Self::RustType) -> Vec { let mut __out: Vec = vec![]; __out.extend(starknet::core::types::Felt::cairo_serialize(&__rust.table)); - __out.extend(starknet::core::types::Felt::cairo_serialize(&__rust.entity_id)); - __out.extend(Vec::::cairo_serialize(&__rust.keys)); - __out - .extend(Vec::::cairo_serialize(&__rust.values)); + __out.extend(starknet::core::types::Felt::cairo_serialize( + &__rust.entity_id, + )); + __out.extend(Vec::::cairo_serialize( + &__rust.keys, + )); + __out.extend(Vec::::cairo_serialize( + &__rust.values, + )); __out } fn cairo_deserialize( @@ -1025,18 +850,11 @@ impl cainome::cairo_serde::CairoSerde for StoreSetRecord { let mut __offset = __offset; let table = starknet::core::types::Felt::cairo_deserialize(__felts, __offset)?; __offset += starknet::core::types::Felt::cairo_serialized_size(&table); - let entity_id = starknet::core::types::Felt::cairo_deserialize( - __felts, - __offset, - )?; + let entity_id = starknet::core::types::Felt::cairo_deserialize(__felts, __offset)?; __offset += starknet::core::types::Felt::cairo_serialized_size(&entity_id); - let keys = Vec::< - starknet::core::types::Felt, - >::cairo_deserialize(__felts, __offset)?; + let keys = Vec::::cairo_deserialize(__felts, __offset)?; __offset += Vec::::cairo_serialized_size(&keys); - let values = Vec::< - starknet::core::types::Felt, - >::cairo_deserialize(__felts, __offset)?; + let values = Vec::::cairo_deserialize(__felts, __offset)?; __offset += Vec::::cairo_serialized_size(&values); Ok(StoreSetRecord { table, @@ -1061,24 +879,22 @@ impl cainome::cairo_serde::CairoSerde for StoreUpdateMember { let mut __size = 0; __size += starknet::core::types::Felt::cairo_serialized_size(&__rust.table); __size += starknet::core::types::Felt::cairo_serialized_size(&__rust.entity_id); - __size - += starknet::core::types::Felt::cairo_serialized_size( - &__rust.member_selector, - ); - __size - += Vec::::cairo_serialized_size(&__rust.values); + __size += starknet::core::types::Felt::cairo_serialized_size(&__rust.member_selector); + __size += Vec::::cairo_serialized_size(&__rust.values); __size } fn cairo_serialize(__rust: &Self::RustType) -> Vec { let mut __out: Vec = vec![]; __out.extend(starknet::core::types::Felt::cairo_serialize(&__rust.table)); - __out.extend(starknet::core::types::Felt::cairo_serialize(&__rust.entity_id)); - __out - .extend( - starknet::core::types::Felt::cairo_serialize(&__rust.member_selector), - ); - __out - .extend(Vec::::cairo_serialize(&__rust.values)); + __out.extend(starknet::core::types::Felt::cairo_serialize( + &__rust.entity_id, + )); + __out.extend(starknet::core::types::Felt::cairo_serialize( + &__rust.member_selector, + )); + __out.extend(Vec::::cairo_serialize( + &__rust.values, + )); __out } fn cairo_deserialize( @@ -1088,19 +904,11 @@ impl cainome::cairo_serde::CairoSerde for StoreUpdateMember { let mut __offset = __offset; let table = starknet::core::types::Felt::cairo_deserialize(__felts, __offset)?; __offset += starknet::core::types::Felt::cairo_serialized_size(&table); - let entity_id = starknet::core::types::Felt::cairo_deserialize( - __felts, - __offset, - )?; + let entity_id = starknet::core::types::Felt::cairo_deserialize(__felts, __offset)?; __offset += starknet::core::types::Felt::cairo_serialized_size(&entity_id); - let member_selector = starknet::core::types::Felt::cairo_deserialize( - __felts, - __offset, - )?; + let member_selector = starknet::core::types::Felt::cairo_deserialize(__felts, __offset)?; __offset += starknet::core::types::Felt::cairo_serialized_size(&member_selector); - let values = Vec::< - starknet::core::types::Felt, - >::cairo_deserialize(__felts, __offset)?; + let values = Vec::::cairo_deserialize(__felts, __offset)?; __offset += Vec::::cairo_serialized_size(&values); Ok(StoreUpdateMember { table, @@ -1124,16 +932,18 @@ impl cainome::cairo_serde::CairoSerde for StoreUpdateRecord { let mut __size = 0; __size += starknet::core::types::Felt::cairo_serialized_size(&__rust.table); __size += starknet::core::types::Felt::cairo_serialized_size(&__rust.entity_id); - __size - += Vec::::cairo_serialized_size(&__rust.values); + __size += Vec::::cairo_serialized_size(&__rust.values); __size } fn cairo_serialize(__rust: &Self::RustType) -> Vec { let mut __out: Vec = vec![]; __out.extend(starknet::core::types::Felt::cairo_serialize(&__rust.table)); - __out.extend(starknet::core::types::Felt::cairo_serialize(&__rust.entity_id)); - __out - .extend(Vec::::cairo_serialize(&__rust.values)); + __out.extend(starknet::core::types::Felt::cairo_serialize( + &__rust.entity_id, + )); + __out.extend(Vec::::cairo_serialize( + &__rust.values, + )); __out } fn cairo_deserialize( @@ -1143,14 +953,9 @@ impl cainome::cairo_serde::CairoSerde for StoreUpdateRecord { let mut __offset = __offset; let table = starknet::core::types::Felt::cairo_deserialize(__felts, __offset)?; __offset += starknet::core::types::Felt::cairo_serialized_size(&table); - let entity_id = starknet::core::types::Felt::cairo_deserialize( - __felts, - __offset, - )?; + let entity_id = starknet::core::types::Felt::cairo_deserialize(__felts, __offset)?; __offset += starknet::core::types::Felt::cairo_serialized_size(&entity_id); - let values = Vec::< - starknet::core::types::Felt, - >::cairo_deserialize(__felts, __offset)?; + let values = Vec::::cairo_deserialize(__felts, __offset)?; __offset += Vec::::cairo_serialized_size(&values); Ok(StoreUpdateRecord { table, @@ -1170,26 +975,18 @@ impl cainome::cairo_serde::CairoSerde for WorldSpawned { #[inline] fn cairo_serialized_size(__rust: &Self::RustType) -> usize { let mut __size = 0; - __size - += cainome::cairo_serde::ContractAddress::cairo_serialized_size( - &__rust.address, - ); - __size - += cainome::cairo_serde::ContractAddress::cairo_serialized_size( - &__rust.creator, - ); + __size += cainome::cairo_serde::ContractAddress::cairo_serialized_size(&__rust.address); + __size += cainome::cairo_serde::ContractAddress::cairo_serialized_size(&__rust.creator); __size } fn cairo_serialize(__rust: &Self::RustType) -> Vec { let mut __out: Vec = vec![]; - __out - .extend( - cainome::cairo_serde::ContractAddress::cairo_serialize(&__rust.address), - ); - __out - .extend( - cainome::cairo_serde::ContractAddress::cairo_serialize(&__rust.creator), - ); + __out.extend(cainome::cairo_serde::ContractAddress::cairo_serialize( + &__rust.address, + )); + __out.extend(cainome::cairo_serde::ContractAddress::cairo_serialize( + &__rust.creator, + )); __out } fn cairo_deserialize( @@ -1197,18 +994,10 @@ impl cainome::cairo_serde::CairoSerde for WorldSpawned { __offset: usize, ) -> cainome::cairo_serde::Result { let mut __offset = __offset; - let address = cainome::cairo_serde::ContractAddress::cairo_deserialize( - __felts, - __offset, - )?; - __offset - += cainome::cairo_serde::ContractAddress::cairo_serialized_size(&address); - let creator = cainome::cairo_serde::ContractAddress::cairo_deserialize( - __felts, - __offset, - )?; - __offset - += cainome::cairo_serde::ContractAddress::cairo_serialized_size(&creator); + let address = cainome::cairo_serde::ContractAddress::cairo_deserialize(__felts, __offset)?; + __offset += cainome::cairo_serde::ContractAddress::cairo_serialized_size(&address); + let creator = cainome::cairo_serde::ContractAddress::cairo_deserialize(__felts, __offset)?; + __offset += cainome::cairo_serde::ContractAddress::cairo_serialized_size(&creator); Ok(WorldSpawned { address, creator }) } } @@ -1222,18 +1011,14 @@ impl cainome::cairo_serde::CairoSerde for WorldUpgraded { #[inline] fn cairo_serialized_size(__rust: &Self::RustType) -> usize { let mut __size = 0; - __size - += cainome::cairo_serde::ClassHash::cairo_serialized_size( - &__rust.class_hash, - ); + __size += cainome::cairo_serde::ClassHash::cairo_serialized_size(&__rust.class_hash); __size } fn cairo_serialize(__rust: &Self::RustType) -> Vec { let mut __out: Vec = vec![]; - __out - .extend( - cainome::cairo_serde::ClassHash::cairo_serialize(&__rust.class_hash), - ); + __out.extend(cainome::cairo_serde::ClassHash::cairo_serialize( + &__rust.class_hash, + )); __out } fn cairo_deserialize( @@ -1241,10 +1026,7 @@ impl cainome::cairo_serde::CairoSerde for WorldUpgraded { __offset: usize, ) -> cainome::cairo_serde::Result { let mut __offset = __offset; - let class_hash = cainome::cairo_serde::ClassHash::cairo_deserialize( - __felts, - __offset, - )?; + let class_hash = cainome::cairo_serde::ClassHash::cairo_deserialize(__felts, __offset)?; __offset += cainome::cairo_serde::ClassHash::cairo_serialized_size(&class_hash); Ok(WorldUpgraded { class_hash }) } @@ -1262,20 +1044,18 @@ impl cainome::cairo_serde::CairoSerde for WriterUpdated { fn cairo_serialized_size(__rust: &Self::RustType) -> usize { let mut __size = 0; __size += starknet::core::types::Felt::cairo_serialized_size(&__rust.resource); - __size - += cainome::cairo_serde::ContractAddress::cairo_serialized_size( - &__rust.contract, - ); + __size += cainome::cairo_serde::ContractAddress::cairo_serialized_size(&__rust.contract); __size += bool::cairo_serialized_size(&__rust.value); __size } fn cairo_serialize(__rust: &Self::RustType) -> Vec { let mut __out: Vec = vec![]; - __out.extend(starknet::core::types::Felt::cairo_serialize(&__rust.resource)); - __out - .extend( - cainome::cairo_serde::ContractAddress::cairo_serialize(&__rust.contract), - ); + __out.extend(starknet::core::types::Felt::cairo_serialize( + &__rust.resource, + )); + __out.extend(cainome::cairo_serde::ContractAddress::cairo_serialize( + &__rust.contract, + )); __out.extend(bool::cairo_serialize(&__rust.value)); __out } @@ -1284,17 +1064,10 @@ impl cainome::cairo_serde::CairoSerde for WriterUpdated { __offset: usize, ) -> cainome::cairo_serde::Result { let mut __offset = __offset; - let resource = starknet::core::types::Felt::cairo_deserialize( - __felts, - __offset, - )?; + let resource = starknet::core::types::Felt::cairo_deserialize(__felts, __offset)?; __offset += starknet::core::types::Felt::cairo_serialized_size(&resource); - let contract = cainome::cairo_serde::ContractAddress::cairo_deserialize( - __felts, - __offset, - )?; - __offset - += cainome::cairo_serde::ContractAddress::cairo_serialized_size(&contract); + let contract = cainome::cairo_serde::ContractAddress::cairo_deserialize(__felts, __offset)?; + __offset += cainome::cairo_serde::ContractAddress::cairo_serialized_size(&contract); let value = bool::cairo_deserialize(__felts, __offset)?; __offset += bool::cairo_serialized_size(&value); Ok(WriterUpdated { @@ -1358,48 +1131,27 @@ impl cainome::cairo_serde::CairoSerde for DojoConfigEvent { let __f = __felts[__offset]; let __index = u128::from_be_bytes(__f.to_bytes_be()[16..].try_into().unwrap()); match __index as usize { - 0usize => { - Ok( - DojoConfigEvent::DifferProgramHashUpdate( - DifferProgramHashUpdate::cairo_deserialize( - __felts, - __offset + 1, - )?, - ), - ) - } - 1usize => { - Ok( - DojoConfigEvent::MergerProgramHashUpdate( - MergerProgramHashUpdate::cairo_deserialize( - __felts, - __offset + 1, - )?, - ), - ) - } - 2usize => { - Ok( - DojoConfigEvent::FactsRegistryUpdate( - FactsRegistryUpdate::cairo_deserialize(__felts, __offset + 1)?, - ), - ) - } + 0usize => Ok(DojoConfigEvent::DifferProgramHashUpdate( + DifferProgramHashUpdate::cairo_deserialize(__felts, __offset + 1)?, + )), + 1usize => Ok(DojoConfigEvent::MergerProgramHashUpdate( + MergerProgramHashUpdate::cairo_deserialize(__felts, __offset + 1)?, + )), + 2usize => Ok(DojoConfigEvent::FactsRegistryUpdate( + FactsRegistryUpdate::cairo_deserialize(__felts, __offset + 1)?, + )), _ => { - return Err( - cainome::cairo_serde::Error::Deserialize( - format!("Index not handle for enum {}", "DojoConfigEvent"), - ), - ); + return Err(cainome::cairo_serde::Error::Deserialize(format!( + "Index not handle for enum {}", + "DojoConfigEvent" + ))); } } } } impl TryFrom for DojoConfigEvent { type Error = String; - fn try_from( - event: starknet::core::types::EmittedEvent, - ) -> Result { + fn try_from(event: starknet::core::types::EmittedEvent) -> Result { use cainome::cairo_serde::CairoSerde; if event.keys.is_empty() { return Err("Event has no key".to_string()); @@ -1407,71 +1159,51 @@ impl TryFrom for DojoConfigEvent { let selector = event.keys[0]; if selector == starknet::core::utils::get_selector_from_name("DifferProgramHashUpdate") - .unwrap_or_else(|_| { - panic!("Invalid selector for {}", "DifferProgramHashUpdate") - }) + .unwrap_or_else(|_| panic!("Invalid selector for {}", "DifferProgramHashUpdate")) { let mut key_offset = 0 + 1; let mut data_offset = 0; - let program_hash = match starknet::core::types::Felt::cairo_deserialize( - &event.data, - data_offset, - ) { - Ok(v) => v, - Err(e) => { - return Err( - format!( + let program_hash = + match starknet::core::types::Felt::cairo_deserialize(&event.data, data_offset) { + Ok(v) => v, + Err(e) => { + return Err(format!( "Could not deserialize field {} for {}: {:?}", "program_hash", "DifferProgramHashUpdate", e - ), - ); - } - }; - data_offset - += starknet::core::types::Felt::cairo_serialized_size(&program_hash); - return Ok( - DojoConfigEvent::DifferProgramHashUpdate(DifferProgramHashUpdate { - program_hash, - }), - ); + )); + } + }; + data_offset += starknet::core::types::Felt::cairo_serialized_size(&program_hash); + return Ok(DojoConfigEvent::DifferProgramHashUpdate( + DifferProgramHashUpdate { program_hash }, + )); } let selector = event.keys[0]; if selector == starknet::core::utils::get_selector_from_name("MergerProgramHashUpdate") - .unwrap_or_else(|_| { - panic!("Invalid selector for {}", "MergerProgramHashUpdate") - }) + .unwrap_or_else(|_| panic!("Invalid selector for {}", "MergerProgramHashUpdate")) { let mut key_offset = 0 + 1; let mut data_offset = 0; - let program_hash = match starknet::core::types::Felt::cairo_deserialize( - &event.data, - data_offset, - ) { - Ok(v) => v, - Err(e) => { - return Err( - format!( + let program_hash = + match starknet::core::types::Felt::cairo_deserialize(&event.data, data_offset) { + Ok(v) => v, + Err(e) => { + return Err(format!( "Could not deserialize field {} for {}: {:?}", "program_hash", "MergerProgramHashUpdate", e - ), - ); - } - }; - data_offset - += starknet::core::types::Felt::cairo_serialized_size(&program_hash); - return Ok( - DojoConfigEvent::MergerProgramHashUpdate(MergerProgramHashUpdate { - program_hash, - }), - ); + )); + } + }; + data_offset += starknet::core::types::Felt::cairo_serialized_size(&program_hash); + return Ok(DojoConfigEvent::MergerProgramHashUpdate( + MergerProgramHashUpdate { program_hash }, + )); } let selector = event.keys[0]; if selector == starknet::core::utils::get_selector_from_name("FactsRegistryUpdate") - .unwrap_or_else(|_| { - panic!("Invalid selector for {}", "FactsRegistryUpdate") - }) + .unwrap_or_else(|_| panic!("Invalid selector for {}", "FactsRegistryUpdate")) { let mut key_offset = 0 + 1; let mut data_offset = 0; @@ -1481,23 +1213,21 @@ impl TryFrom for DojoConfigEvent { ) { Ok(v) => v, Err(e) => { - return Err( - format!( - "Could not deserialize field {} for {}: {:?}", "address", - "FactsRegistryUpdate", e - ), - ); + return Err(format!( + "Could not deserialize field {} for {}: {:?}", + "address", "FactsRegistryUpdate", e + )); } }; - data_offset - += cainome::cairo_serde::ContractAddress::cairo_serialized_size( - &address, - ); - return Ok( - DojoConfigEvent::FactsRegistryUpdate(FactsRegistryUpdate { address }), - ); + data_offset += cainome::cairo_serde::ContractAddress::cairo_serialized_size(&address); + return Ok(DojoConfigEvent::FactsRegistryUpdate(FactsRegistryUpdate { + address, + })); } - Err(format!("Could not match any event from keys {:?}", event.keys)) + Err(format!( + "Could not match any event from keys {:?}", + event.keys + )) } } #[derive(Clone, serde::Serialize, serde::Deserialize, PartialEq, Debug)] @@ -1527,31 +1257,17 @@ impl cainome::cairo_serde::CairoSerde for Event { fn cairo_serialized_size(__rust: &Self::RustType) -> usize { match __rust { Event::WorldSpawned(val) => WorldSpawned::cairo_serialized_size(val) + 1, - Event::ContractDeployed(val) => { - ContractDeployed::cairo_serialized_size(val) + 1 - } - Event::ContractUpgraded(val) => { - ContractUpgraded::cairo_serialized_size(val) + 1 - } - Event::ContractInitialized(val) => { - ContractInitialized::cairo_serialized_size(val) + 1 - } + Event::ContractDeployed(val) => ContractDeployed::cairo_serialized_size(val) + 1, + Event::ContractUpgraded(val) => ContractUpgraded::cairo_serialized_size(val) + 1, + Event::ContractInitialized(val) => ContractInitialized::cairo_serialized_size(val) + 1, Event::WorldUpgraded(val) => WorldUpgraded::cairo_serialized_size(val) + 1, Event::MetadataUpdate(val) => MetadataUpdate::cairo_serialized_size(val) + 1, - Event::NamespaceRegistered(val) => { - NamespaceRegistered::cairo_serialized_size(val) + 1 - } - Event::ModelRegistered(val) => { - ModelRegistered::cairo_serialized_size(val) + 1 - } + Event::NamespaceRegistered(val) => NamespaceRegistered::cairo_serialized_size(val) + 1, + Event::ModelRegistered(val) => ModelRegistered::cairo_serialized_size(val) + 1, Event::ModelUpgraded(val) => ModelUpgraded::cairo_serialized_size(val) + 1, Event::StoreSetRecord(val) => StoreSetRecord::cairo_serialized_size(val) + 1, - Event::StoreUpdateRecord(val) => { - StoreUpdateRecord::cairo_serialized_size(val) + 1 - } - Event::StoreUpdateMember(val) => { - StoreUpdateMember::cairo_serialized_size(val) + 1 - } + Event::StoreUpdateRecord(val) => StoreUpdateRecord::cairo_serialized_size(val) + 1, + Event::StoreUpdateMember(val) => StoreUpdateMember::cairo_serialized_size(val) + 1, Event::StoreDelRecord(val) => StoreDelRecord::cairo_serialized_size(val) + 1, Event::WriterUpdated(val) => WriterUpdated::cairo_serialized_size(val) + 1, Event::OwnerUpdated(val) => OwnerUpdated::cairo_serialized_size(val) + 1, @@ -1674,140 +1390,80 @@ impl cainome::cairo_serde::CairoSerde for Event { let __f = __felts[__offset]; let __index = u128::from_be_bytes(__f.to_bytes_be()[16..].try_into().unwrap()); match __index as usize { - 0usize => { - Ok( - Event::WorldSpawned( - WorldSpawned::cairo_deserialize(__felts, __offset + 1)?, - ), - ) - } - 1usize => { - Ok( - Event::ContractDeployed( - ContractDeployed::cairo_deserialize(__felts, __offset + 1)?, - ), - ) - } - 2usize => { - Ok( - Event::ContractUpgraded( - ContractUpgraded::cairo_deserialize(__felts, __offset + 1)?, - ), - ) - } - 3usize => { - Ok( - Event::ContractInitialized( - ContractInitialized::cairo_deserialize(__felts, __offset + 1)?, - ), - ) - } - 4usize => { - Ok( - Event::WorldUpgraded( - WorldUpgraded::cairo_deserialize(__felts, __offset + 1)?, - ), - ) - } - 5usize => { - Ok( - Event::MetadataUpdate( - MetadataUpdate::cairo_deserialize(__felts, __offset + 1)?, - ), - ) - } - 6usize => { - Ok( - Event::NamespaceRegistered( - NamespaceRegistered::cairo_deserialize(__felts, __offset + 1)?, - ), - ) - } - 7usize => { - Ok( - Event::ModelRegistered( - ModelRegistered::cairo_deserialize(__felts, __offset + 1)?, - ), - ) - } - 8usize => { - Ok( - Event::ModelUpgraded( - ModelUpgraded::cairo_deserialize(__felts, __offset + 1)?, - ), - ) - } - 9usize => { - Ok( - Event::StoreSetRecord( - StoreSetRecord::cairo_deserialize(__felts, __offset + 1)?, - ), - ) - } - 10usize => { - Ok( - Event::StoreUpdateRecord( - StoreUpdateRecord::cairo_deserialize(__felts, __offset + 1)?, - ), - ) - } - 11usize => { - Ok( - Event::StoreUpdateMember( - StoreUpdateMember::cairo_deserialize(__felts, __offset + 1)?, - ), - ) - } - 12usize => { - Ok( - Event::StoreDelRecord( - StoreDelRecord::cairo_deserialize(__felts, __offset + 1)?, - ), - ) - } - 13usize => { - Ok( - Event::WriterUpdated( - WriterUpdated::cairo_deserialize(__felts, __offset + 1)?, - ), - ) - } - 14usize => { - Ok( - Event::OwnerUpdated( - OwnerUpdated::cairo_deserialize(__felts, __offset + 1)?, - ), - ) - } - 15usize => { - Ok( - Event::ConfigEvent( - DojoConfigEvent::cairo_deserialize(__felts, __offset + 1)?, - ), - ) - } - 16usize => { - Ok( - Event::StateUpdated( - StateUpdated::cairo_deserialize(__felts, __offset + 1)?, - ), - ) - } + 0usize => Ok(Event::WorldSpawned(WorldSpawned::cairo_deserialize( + __felts, + __offset + 1, + )?)), + 1usize => Ok(Event::ContractDeployed( + ContractDeployed::cairo_deserialize(__felts, __offset + 1)?, + )), + 2usize => Ok(Event::ContractUpgraded( + ContractUpgraded::cairo_deserialize(__felts, __offset + 1)?, + )), + 3usize => Ok(Event::ContractInitialized( + ContractInitialized::cairo_deserialize(__felts, __offset + 1)?, + )), + 4usize => Ok(Event::WorldUpgraded(WorldUpgraded::cairo_deserialize( + __felts, + __offset + 1, + )?)), + 5usize => Ok(Event::MetadataUpdate(MetadataUpdate::cairo_deserialize( + __felts, + __offset + 1, + )?)), + 6usize => Ok(Event::NamespaceRegistered( + NamespaceRegistered::cairo_deserialize(__felts, __offset + 1)?, + )), + 7usize => Ok(Event::ModelRegistered(ModelRegistered::cairo_deserialize( + __felts, + __offset + 1, + )?)), + 8usize => Ok(Event::ModelUpgraded(ModelUpgraded::cairo_deserialize( + __felts, + __offset + 1, + )?)), + 9usize => Ok(Event::StoreSetRecord(StoreSetRecord::cairo_deserialize( + __felts, + __offset + 1, + )?)), + 10usize => Ok(Event::StoreUpdateRecord( + StoreUpdateRecord::cairo_deserialize(__felts, __offset + 1)?, + )), + 11usize => Ok(Event::StoreUpdateMember( + StoreUpdateMember::cairo_deserialize(__felts, __offset + 1)?, + )), + 12usize => Ok(Event::StoreDelRecord(StoreDelRecord::cairo_deserialize( + __felts, + __offset + 1, + )?)), + 13usize => Ok(Event::WriterUpdated(WriterUpdated::cairo_deserialize( + __felts, + __offset + 1, + )?)), + 14usize => Ok(Event::OwnerUpdated(OwnerUpdated::cairo_deserialize( + __felts, + __offset + 1, + )?)), + 15usize => Ok(Event::ConfigEvent(DojoConfigEvent::cairo_deserialize( + __felts, + __offset + 1, + )?)), + 16usize => Ok(Event::StateUpdated(StateUpdated::cairo_deserialize( + __felts, + __offset + 1, + )?)), _ => { - return Err( - cainome::cairo_serde::Error::Deserialize( - format!("Index not handle for enum {}", "Event"), - ), - ); + return Err(cainome::cairo_serde::Error::Deserialize(format!( + "Index not handle for enum {}", + "Event" + ))); } } } } impl TryFrom for Event { type Error = String; - fn try_from( - event: starknet::core::types::EmittedEvent, - ) -> Result { + fn try_from(event: starknet::core::types::EmittedEvent) -> Result { use cainome::cairo_serde::CairoSerde; if event.keys.is_empty() { return Err("Event has no key".to_string()); @@ -1825,61 +1481,45 @@ impl TryFrom for Event { ) { Ok(v) => v, Err(e) => { - return Err( - format!( - "Could not deserialize field {} for {}: {:?}", "address", - "WorldSpawned", e - ), - ); + return Err(format!( + "Could not deserialize field {} for {}: {:?}", + "address", "WorldSpawned", e + )); } }; - data_offset - += cainome::cairo_serde::ContractAddress::cairo_serialized_size( - &address, - ); + data_offset += cainome::cairo_serde::ContractAddress::cairo_serialized_size(&address); let creator = match cainome::cairo_serde::ContractAddress::cairo_deserialize( &event.data, data_offset, ) { Ok(v) => v, Err(e) => { - return Err( - format!( - "Could not deserialize field {} for {}: {:?}", "creator", - "WorldSpawned", e - ), - ); + return Err(format!( + "Could not deserialize field {} for {}: {:?}", + "creator", "WorldSpawned", e + )); } }; - data_offset - += cainome::cairo_serde::ContractAddress::cairo_serialized_size( - &creator, - ); + data_offset += cainome::cairo_serde::ContractAddress::cairo_serialized_size(&creator); return Ok(Event::WorldSpawned(WorldSpawned { address, creator })); } let selector = event.keys[0]; if selector == starknet::core::utils::get_selector_from_name("ContractDeployed") - .unwrap_or_else(|_| { - panic!("Invalid selector for {}", "ContractDeployed") - }) + .unwrap_or_else(|_| panic!("Invalid selector for {}", "ContractDeployed")) { let mut key_offset = 0 + 1; let mut data_offset = 0; - let salt = match starknet::core::types::Felt::cairo_deserialize( - &event.data, - data_offset, - ) { - Ok(v) => v, - Err(e) => { - return Err( - format!( - "Could not deserialize field {} for {}: {:?}", "salt", - "ContractDeployed", e - ), - ); - } - }; + let salt = + match starknet::core::types::Felt::cairo_deserialize(&event.data, data_offset) { + Ok(v) => v, + Err(e) => { + return Err(format!( + "Could not deserialize field {} for {}: {:?}", + "salt", "ContractDeployed", e + )); + } + }; data_offset += starknet::core::types::Felt::cairo_serialized_size(&salt); let class_hash = match cainome::cairo_serde::ClassHash::cairo_deserialize( &event.data, @@ -1887,81 +1527,64 @@ impl TryFrom for Event { ) { Ok(v) => v, Err(e) => { - return Err( - format!( - "Could not deserialize field {} for {}: {:?}", "class_hash", - "ContractDeployed", e - ), - ); + return Err(format!( + "Could not deserialize field {} for {}: {:?}", + "class_hash", "ContractDeployed", e + )); } }; - data_offset - += cainome::cairo_serde::ClassHash::cairo_serialized_size(&class_hash); + data_offset += cainome::cairo_serde::ClassHash::cairo_serialized_size(&class_hash); let address = match cainome::cairo_serde::ContractAddress::cairo_deserialize( &event.data, data_offset, ) { Ok(v) => v, Err(e) => { - return Err( - format!( - "Could not deserialize field {} for {}: {:?}", "address", - "ContractDeployed", e - ), - ); + return Err(format!( + "Could not deserialize field {} for {}: {:?}", + "address", "ContractDeployed", e + )); } }; - data_offset - += cainome::cairo_serde::ContractAddress::cairo_serialized_size( - &address, - ); + data_offset += cainome::cairo_serde::ContractAddress::cairo_serialized_size(&address); let namespace = match cainome::cairo_serde::ByteArray::cairo_deserialize( &event.data, data_offset, ) { Ok(v) => v, Err(e) => { - return Err( - format!( - "Could not deserialize field {} for {}: {:?}", "namespace", - "ContractDeployed", e - ), - ); + return Err(format!( + "Could not deserialize field {} for {}: {:?}", + "namespace", "ContractDeployed", e + )); } }; - data_offset - += cainome::cairo_serde::ByteArray::cairo_serialized_size(&namespace); + data_offset += cainome::cairo_serde::ByteArray::cairo_serialized_size(&namespace); let name = match cainome::cairo_serde::ByteArray::cairo_deserialize( &event.data, data_offset, ) { Ok(v) => v, Err(e) => { - return Err( - format!( - "Could not deserialize field {} for {}: {:?}", "name", - "ContractDeployed", e - ), - ); + return Err(format!( + "Could not deserialize field {} for {}: {:?}", + "name", "ContractDeployed", e + )); } }; data_offset += cainome::cairo_serde::ByteArray::cairo_serialized_size(&name); - return Ok( - Event::ContractDeployed(ContractDeployed { - salt, - class_hash, - address, - namespace, - name, - }), - ); + return Ok(Event::ContractDeployed(ContractDeployed { + salt, + class_hash, + address, + namespace, + name, + })); } let selector = event.keys[0]; if selector == starknet::core::utils::get_selector_from_name("ContractUpgraded") - .unwrap_or_else(|_| { - panic!("Invalid selector for {}", "ContractUpgraded") - }) + .unwrap_or_else(|_| panic!("Invalid selector for {}", "ContractUpgraded")) { let mut key_offset = 0 + 1; let mut data_offset = 0; @@ -1971,88 +1594,67 @@ impl TryFrom for Event { ) { Ok(v) => v, Err(e) => { - return Err( - format!( - "Could not deserialize field {} for {}: {:?}", "class_hash", - "ContractUpgraded", e - ), - ); + return Err(format!( + "Could not deserialize field {} for {}: {:?}", + "class_hash", "ContractUpgraded", e + )); } }; - data_offset - += cainome::cairo_serde::ClassHash::cairo_serialized_size(&class_hash); + data_offset += cainome::cairo_serde::ClassHash::cairo_serialized_size(&class_hash); let address = match cainome::cairo_serde::ContractAddress::cairo_deserialize( &event.data, data_offset, ) { Ok(v) => v, Err(e) => { - return Err( - format!( - "Could not deserialize field {} for {}: {:?}", "address", - "ContractUpgraded", e - ), - ); + return Err(format!( + "Could not deserialize field {} for {}: {:?}", + "address", "ContractUpgraded", e + )); } }; - data_offset - += cainome::cairo_serde::ContractAddress::cairo_serialized_size( - &address, - ); - return Ok( - Event::ContractUpgraded(ContractUpgraded { - class_hash, - address, - }), - ); + data_offset += cainome::cairo_serde::ContractAddress::cairo_serialized_size(&address); + return Ok(Event::ContractUpgraded(ContractUpgraded { + class_hash, + address, + })); } let selector = event.keys[0]; if selector == starknet::core::utils::get_selector_from_name("ContractInitialized") - .unwrap_or_else(|_| { - panic!("Invalid selector for {}", "ContractInitialized") - }) + .unwrap_or_else(|_| panic!("Invalid selector for {}", "ContractInitialized")) { let mut key_offset = 0 + 1; let mut data_offset = 0; - let selector = match starknet::core::types::Felt::cairo_deserialize( + let selector = + match starknet::core::types::Felt::cairo_deserialize(&event.data, data_offset) { + Ok(v) => v, + Err(e) => { + return Err(format!( + "Could not deserialize field {} for {}: {:?}", + "selector", "ContractInitialized", e + )); + } + }; + data_offset += starknet::core::types::Felt::cairo_serialized_size(&selector); + let init_calldata = match Vec::::cairo_deserialize( &event.data, data_offset, ) { Ok(v) => v, Err(e) => { - return Err( - format!( - "Could not deserialize field {} for {}: {:?}", "selector", - "ContractInitialized", e - ), - ); + return Err(format!( + "Could not deserialize field {} for {}: {:?}", + "init_calldata", "ContractInitialized", e + )); } }; - data_offset += starknet::core::types::Felt::cairo_serialized_size(&selector); - let init_calldata = match Vec::< - starknet::core::types::Felt, - >::cairo_deserialize(&event.data, data_offset) { - Ok(v) => v, - Err(e) => { - return Err( - format!( - "Could not deserialize field {} for {}: {:?}", - "init_calldata", "ContractInitialized", e - ), - ); - } - }; - data_offset - += Vec::< - starknet::core::types::Felt, - >::cairo_serialized_size(&init_calldata); - return Ok( - Event::ContractInitialized(ContractInitialized { - selector, - init_calldata, - }), - ); + data_offset += + Vec::::cairo_serialized_size(&init_calldata); + return Ok(Event::ContractInitialized(ContractInitialized { + selector, + init_calldata, + })); } let selector = event.keys[0]; if selector @@ -2067,16 +1669,13 @@ impl TryFrom for Event { ) { Ok(v) => v, Err(e) => { - return Err( - format!( - "Could not deserialize field {} for {}: {:?}", "class_hash", - "WorldUpgraded", e - ), - ); + return Err(format!( + "Could not deserialize field {} for {}: {:?}", + "class_hash", "WorldUpgraded", e + )); } }; - data_offset - += cainome::cairo_serde::ClassHash::cairo_serialized_size(&class_hash); + data_offset += cainome::cairo_serde::ClassHash::cairo_serialized_size(&class_hash); return Ok(Event::WorldUpgraded(WorldUpgraded { class_hash })); } let selector = event.keys[0]; @@ -2086,20 +1685,16 @@ impl TryFrom for Event { { let mut key_offset = 0 + 1; let mut data_offset = 0; - let resource = match starknet::core::types::Felt::cairo_deserialize( - &event.data, - data_offset, - ) { - Ok(v) => v, - Err(e) => { - return Err( - format!( - "Could not deserialize field {} for {}: {:?}", "resource", - "MetadataUpdate", e - ), - ); - } - }; + let resource = + match starknet::core::types::Felt::cairo_deserialize(&event.data, data_offset) { + Ok(v) => v, + Err(e) => { + return Err(format!( + "Could not deserialize field {} for {}: {:?}", + "resource", "MetadataUpdate", e + )); + } + }; data_offset += starknet::core::types::Felt::cairo_serialized_size(&resource); let uri = match cainome::cairo_serde::ByteArray::cairo_deserialize( &event.data, @@ -2107,12 +1702,10 @@ impl TryFrom for Event { ) { Ok(v) => v, Err(e) => { - return Err( - format!( - "Could not deserialize field {} for {}: {:?}", "uri", - "MetadataUpdate", e - ), - ); + return Err(format!( + "Could not deserialize field {} for {}: {:?}", + "uri", "MetadataUpdate", e + )); } }; data_offset += cainome::cairo_serde::ByteArray::cairo_serialized_size(&uri); @@ -2121,9 +1714,7 @@ impl TryFrom for Event { let selector = event.keys[0]; if selector == starknet::core::utils::get_selector_from_name("NamespaceRegistered") - .unwrap_or_else(|_| { - panic!("Invalid selector for {}", "NamespaceRegistered") - }) + .unwrap_or_else(|_| panic!("Invalid selector for {}", "NamespaceRegistered")) { let mut key_offset = 0 + 1; let mut data_offset = 0; @@ -2133,37 +1724,28 @@ impl TryFrom for Event { ) { Ok(v) => v, Err(e) => { - return Err( - format!( - "Could not deserialize field {} for {}: {:?}", "namespace", - "NamespaceRegistered", e - ), - ); - } - }; - data_offset - += cainome::cairo_serde::ByteArray::cairo_serialized_size(&namespace); - let hash = match starknet::core::types::Felt::cairo_deserialize( - &event.data, - data_offset, - ) { - Ok(v) => v, - Err(e) => { - return Err( - format!( - "Could not deserialize field {} for {}: {:?}", "hash", - "NamespaceRegistered", e - ), - ); + return Err(format!( + "Could not deserialize field {} for {}: {:?}", + "namespace", "NamespaceRegistered", e + )); } }; + data_offset += cainome::cairo_serde::ByteArray::cairo_serialized_size(&namespace); + let hash = + match starknet::core::types::Felt::cairo_deserialize(&event.data, data_offset) { + Ok(v) => v, + Err(e) => { + return Err(format!( + "Could not deserialize field {} for {}: {:?}", + "hash", "NamespaceRegistered", e + )); + } + }; data_offset += starknet::core::types::Felt::cairo_serialized_size(&hash); - return Ok( - Event::NamespaceRegistered(NamespaceRegistered { - namespace, - hash, - }), - ); + return Ok(Event::NamespaceRegistered(NamespaceRegistered { + namespace, + hash, + })); } let selector = event.keys[0]; if selector @@ -2178,12 +1760,10 @@ impl TryFrom for Event { ) { Ok(v) => v, Err(e) => { - return Err( - format!( - "Could not deserialize field {} for {}: {:?}", "name", - "ModelRegistered", e - ), - ); + return Err(format!( + "Could not deserialize field {} for {}: {:?}", + "name", "ModelRegistered", e + )); } }; data_offset += cainome::cairo_serde::ByteArray::cairo_serialized_size(&name); @@ -2193,58 +1773,45 @@ impl TryFrom for Event { ) { Ok(v) => v, Err(e) => { - return Err( - format!( - "Could not deserialize field {} for {}: {:?}", "namespace", - "ModelRegistered", e - ), - ); + return Err(format!( + "Could not deserialize field {} for {}: {:?}", + "namespace", "ModelRegistered", e + )); } }; - data_offset - += cainome::cairo_serde::ByteArray::cairo_serialized_size(&namespace); + data_offset += cainome::cairo_serde::ByteArray::cairo_serialized_size(&namespace); let class_hash = match cainome::cairo_serde::ClassHash::cairo_deserialize( &event.data, data_offset, ) { Ok(v) => v, Err(e) => { - return Err( - format!( - "Could not deserialize field {} for {}: {:?}", "class_hash", - "ModelRegistered", e - ), - ); + return Err(format!( + "Could not deserialize field {} for {}: {:?}", + "class_hash", "ModelRegistered", e + )); } }; - data_offset - += cainome::cairo_serde::ClassHash::cairo_serialized_size(&class_hash); + data_offset += cainome::cairo_serde::ClassHash::cairo_serialized_size(&class_hash); let address = match cainome::cairo_serde::ContractAddress::cairo_deserialize( &event.data, data_offset, ) { Ok(v) => v, Err(e) => { - return Err( - format!( - "Could not deserialize field {} for {}: {:?}", "address", - "ModelRegistered", e - ), - ); + return Err(format!( + "Could not deserialize field {} for {}: {:?}", + "address", "ModelRegistered", e + )); } }; - data_offset - += cainome::cairo_serde::ContractAddress::cairo_serialized_size( - &address, - ); - return Ok( - Event::ModelRegistered(ModelRegistered { - name, - namespace, - class_hash, - address, - }), - ); + data_offset += cainome::cairo_serde::ContractAddress::cairo_serialized_size(&address); + return Ok(Event::ModelRegistered(ModelRegistered { + name, + namespace, + class_hash, + address, + })); } let selector = event.keys[0]; if selector @@ -2259,12 +1826,10 @@ impl TryFrom for Event { ) { Ok(v) => v, Err(e) => { - return Err( - format!( - "Could not deserialize field {} for {}: {:?}", "name", - "ModelUpgraded", e - ), - ); + return Err(format!( + "Could not deserialize field {} for {}: {:?}", + "name", "ModelUpgraded", e + )); } }; data_offset += cainome::cairo_serde::ByteArray::cairo_serialized_size(&name); @@ -2274,96 +1839,74 @@ impl TryFrom for Event { ) { Ok(v) => v, Err(e) => { - return Err( - format!( - "Could not deserialize field {} for {}: {:?}", "namespace", - "ModelUpgraded", e - ), - ); + return Err(format!( + "Could not deserialize field {} for {}: {:?}", + "namespace", "ModelUpgraded", e + )); } }; - data_offset - += cainome::cairo_serde::ByteArray::cairo_serialized_size(&namespace); + data_offset += cainome::cairo_serde::ByteArray::cairo_serialized_size(&namespace); let class_hash = match cainome::cairo_serde::ClassHash::cairo_deserialize( &event.data, data_offset, ) { Ok(v) => v, Err(e) => { - return Err( - format!( - "Could not deserialize field {} for {}: {:?}", "class_hash", - "ModelUpgraded", e - ), - ); + return Err(format!( + "Could not deserialize field {} for {}: {:?}", + "class_hash", "ModelUpgraded", e + )); } }; - data_offset - += cainome::cairo_serde::ClassHash::cairo_serialized_size(&class_hash); + data_offset += cainome::cairo_serde::ClassHash::cairo_serialized_size(&class_hash); let prev_class_hash = match cainome::cairo_serde::ClassHash::cairo_deserialize( &event.data, data_offset, ) { Ok(v) => v, Err(e) => { - return Err( - format!( - "Could not deserialize field {} for {}: {:?}", - "prev_class_hash", "ModelUpgraded", e - ), - ); + return Err(format!( + "Could not deserialize field {} for {}: {:?}", + "prev_class_hash", "ModelUpgraded", e + )); } }; - data_offset - += cainome::cairo_serde::ClassHash::cairo_serialized_size( - &prev_class_hash, - ); + data_offset += cainome::cairo_serde::ClassHash::cairo_serialized_size(&prev_class_hash); let address = match cainome::cairo_serde::ContractAddress::cairo_deserialize( &event.data, data_offset, ) { Ok(v) => v, Err(e) => { - return Err( - format!( - "Could not deserialize field {} for {}: {:?}", "address", - "ModelUpgraded", e - ), - ); + return Err(format!( + "Could not deserialize field {} for {}: {:?}", + "address", "ModelUpgraded", e + )); } }; - data_offset - += cainome::cairo_serde::ContractAddress::cairo_serialized_size( - &address, - ); + data_offset += cainome::cairo_serde::ContractAddress::cairo_serialized_size(&address); let prev_address = match cainome::cairo_serde::ContractAddress::cairo_deserialize( &event.data, data_offset, ) { Ok(v) => v, Err(e) => { - return Err( - format!( - "Could not deserialize field {} for {}: {:?}", - "prev_address", "ModelUpgraded", e - ), - ); + return Err(format!( + "Could not deserialize field {} for {}: {:?}", + "prev_address", "ModelUpgraded", e + )); } }; - data_offset - += cainome::cairo_serde::ContractAddress::cairo_serialized_size( - &prev_address, - ); - return Ok( - Event::ModelUpgraded(ModelUpgraded { - name, - namespace, - class_hash, - prev_class_hash, - address, - prev_address, - }), - ); + data_offset += + cainome::cairo_serde::ContractAddress::cairo_serialized_size(&prev_address); + return Ok(Event::ModelUpgraded(ModelUpgraded { + name, + namespace, + class_hash, + prev_class_hash, + address, + prev_address, + })); } let selector = event.keys[0]; if selector @@ -2372,218 +1915,168 @@ impl TryFrom for Event { { let mut key_offset = 0 + 1; let mut data_offset = 0; - let table = match starknet::core::types::Felt::cairo_deserialize( + let table = + match starknet::core::types::Felt::cairo_deserialize(&event.data, data_offset) { + Ok(v) => v, + Err(e) => { + return Err(format!( + "Could not deserialize field {} for {}: {:?}", + "table", "StoreSetRecord", e + )); + } + }; + data_offset += starknet::core::types::Felt::cairo_serialized_size(&table); + let entity_id = + match starknet::core::types::Felt::cairo_deserialize(&event.data, data_offset) { + Ok(v) => v, + Err(e) => { + return Err(format!( + "Could not deserialize field {} for {}: {:?}", + "entity_id", "StoreSetRecord", e + )); + } + }; + data_offset += starknet::core::types::Felt::cairo_serialized_size(&entity_id); + let keys = match Vec::::cairo_deserialize( &event.data, data_offset, ) { Ok(v) => v, Err(e) => { - return Err( - format!( - "Could not deserialize field {} for {}: {:?}", "table", - "StoreSetRecord", e - ), - ); + return Err(format!( + "Could not deserialize field {} for {}: {:?}", + "keys", "StoreSetRecord", e + )); } }; - data_offset += starknet::core::types::Felt::cairo_serialized_size(&table); - let entity_id = match starknet::core::types::Felt::cairo_deserialize( + data_offset += Vec::::cairo_serialized_size(&keys); + let values = match Vec::::cairo_deserialize( &event.data, data_offset, ) { Ok(v) => v, Err(e) => { - return Err( - format!( - "Could not deserialize field {} for {}: {:?}", "entity_id", - "StoreSetRecord", e - ), - ); - } - }; - data_offset - += starknet::core::types::Felt::cairo_serialized_size(&entity_id); - let keys = match Vec::< - starknet::core::types::Felt, - >::cairo_deserialize(&event.data, data_offset) { - Ok(v) => v, - Err(e) => { - return Err( - format!( - "Could not deserialize field {} for {}: {:?}", "keys", - "StoreSetRecord", e - ), - ); - } - }; - data_offset - += Vec::::cairo_serialized_size(&keys); - let values = match Vec::< - starknet::core::types::Felt, - >::cairo_deserialize(&event.data, data_offset) { - Ok(v) => v, - Err(e) => { - return Err( - format!( - "Could not deserialize field {} for {}: {:?}", "values", - "StoreSetRecord", e - ), - ); + return Err(format!( + "Could not deserialize field {} for {}: {:?}", + "values", "StoreSetRecord", e + )); } }; - data_offset - += Vec::::cairo_serialized_size(&values); - return Ok( - Event::StoreSetRecord(StoreSetRecord { - table, - entity_id, - keys, - values, - }), - ); + data_offset += Vec::::cairo_serialized_size(&values); + return Ok(Event::StoreSetRecord(StoreSetRecord { + table, + entity_id, + keys, + values, + })); } let selector = event.keys[0]; if selector == starknet::core::utils::get_selector_from_name("StoreUpdateRecord") - .unwrap_or_else(|_| { - panic!("Invalid selector for {}", "StoreUpdateRecord") - }) + .unwrap_or_else(|_| panic!("Invalid selector for {}", "StoreUpdateRecord")) { let mut key_offset = 0 + 1; let mut data_offset = 0; - let table = match starknet::core::types::Felt::cairo_deserialize( - &event.data, - data_offset, - ) { - Ok(v) => v, - Err(e) => { - return Err( - format!( - "Could not deserialize field {} for {}: {:?}", "table", - "StoreUpdateRecord", e - ), - ); - } - }; + let table = + match starknet::core::types::Felt::cairo_deserialize(&event.data, data_offset) { + Ok(v) => v, + Err(e) => { + return Err(format!( + "Could not deserialize field {} for {}: {:?}", + "table", "StoreUpdateRecord", e + )); + } + }; data_offset += starknet::core::types::Felt::cairo_serialized_size(&table); - let entity_id = match starknet::core::types::Felt::cairo_deserialize( + let entity_id = + match starknet::core::types::Felt::cairo_deserialize(&event.data, data_offset) { + Ok(v) => v, + Err(e) => { + return Err(format!( + "Could not deserialize field {} for {}: {:?}", + "entity_id", "StoreUpdateRecord", e + )); + } + }; + data_offset += starknet::core::types::Felt::cairo_serialized_size(&entity_id); + let values = match Vec::::cairo_deserialize( &event.data, data_offset, ) { Ok(v) => v, Err(e) => { - return Err( - format!( - "Could not deserialize field {} for {}: {:?}", "entity_id", - "StoreUpdateRecord", e - ), - ); + return Err(format!( + "Could not deserialize field {} for {}: {:?}", + "values", "StoreUpdateRecord", e + )); } }; - data_offset - += starknet::core::types::Felt::cairo_serialized_size(&entity_id); - let values = match Vec::< - starknet::core::types::Felt, - >::cairo_deserialize(&event.data, data_offset) { - Ok(v) => v, - Err(e) => { - return Err( - format!( - "Could not deserialize field {} for {}: {:?}", "values", - "StoreUpdateRecord", e - ), - ); - } - }; - data_offset - += Vec::::cairo_serialized_size(&values); - return Ok( - Event::StoreUpdateRecord(StoreUpdateRecord { - table, - entity_id, - values, - }), - ); + data_offset += Vec::::cairo_serialized_size(&values); + return Ok(Event::StoreUpdateRecord(StoreUpdateRecord { + table, + entity_id, + values, + })); } let selector = event.keys[0]; if selector == starknet::core::utils::get_selector_from_name("StoreUpdateMember") - .unwrap_or_else(|_| { - panic!("Invalid selector for {}", "StoreUpdateMember") - }) + .unwrap_or_else(|_| panic!("Invalid selector for {}", "StoreUpdateMember")) { let mut key_offset = 0 + 1; let mut data_offset = 0; - let table = match starknet::core::types::Felt::cairo_deserialize( - &event.data, - data_offset, - ) { - Ok(v) => v, - Err(e) => { - return Err( - format!( - "Could not deserialize field {} for {}: {:?}", "table", - "StoreUpdateMember", e - ), - ); - } - }; + let table = + match starknet::core::types::Felt::cairo_deserialize(&event.data, data_offset) { + Ok(v) => v, + Err(e) => { + return Err(format!( + "Could not deserialize field {} for {}: {:?}", + "table", "StoreUpdateMember", e + )); + } + }; data_offset += starknet::core::types::Felt::cairo_serialized_size(&table); - let entity_id = match starknet::core::types::Felt::cairo_deserialize( - &event.data, - data_offset, - ) { - Ok(v) => v, - Err(e) => { - return Err( - format!( - "Could not deserialize field {} for {}: {:?}", "entity_id", - "StoreUpdateMember", e - ), - ); - } - }; - data_offset - += starknet::core::types::Felt::cairo_serialized_size(&entity_id); - let member_selector = match starknet::core::types::Felt::cairo_deserialize( + let entity_id = + match starknet::core::types::Felt::cairo_deserialize(&event.data, data_offset) { + Ok(v) => v, + Err(e) => { + return Err(format!( + "Could not deserialize field {} for {}: {:?}", + "entity_id", "StoreUpdateMember", e + )); + } + }; + data_offset += starknet::core::types::Felt::cairo_serialized_size(&entity_id); + let member_selector = + match starknet::core::types::Felt::cairo_deserialize(&event.data, data_offset) { + Ok(v) => v, + Err(e) => { + return Err(format!( + "Could not deserialize field {} for {}: {:?}", + "member_selector", "StoreUpdateMember", e + )); + } + }; + data_offset += starknet::core::types::Felt::cairo_serialized_size(&member_selector); + let values = match Vec::::cairo_deserialize( &event.data, data_offset, ) { Ok(v) => v, Err(e) => { - return Err( - format!( - "Could not deserialize field {} for {}: {:?}", - "member_selector", "StoreUpdateMember", e - ), - ); + return Err(format!( + "Could not deserialize field {} for {}: {:?}", + "values", "StoreUpdateMember", e + )); } }; - data_offset - += starknet::core::types::Felt::cairo_serialized_size(&member_selector); - let values = match Vec::< - starknet::core::types::Felt, - >::cairo_deserialize(&event.data, data_offset) { - Ok(v) => v, - Err(e) => { - return Err( - format!( - "Could not deserialize field {} for {}: {:?}", "values", - "StoreUpdateMember", e - ), - ); - } - }; - data_offset - += Vec::::cairo_serialized_size(&values); - return Ok( - Event::StoreUpdateMember(StoreUpdateMember { - table, - entity_id, - member_selector, - values, - }), - ); + data_offset += Vec::::cairo_serialized_size(&values); + return Ok(Event::StoreUpdateMember(StoreUpdateMember { + table, + entity_id, + member_selector, + values, + })); } let selector = event.keys[0]; if selector @@ -2592,37 +2085,28 @@ impl TryFrom for Event { { let mut key_offset = 0 + 1; let mut data_offset = 0; - let table = match starknet::core::types::Felt::cairo_deserialize( - &event.data, - data_offset, - ) { - Ok(v) => v, - Err(e) => { - return Err( - format!( - "Could not deserialize field {} for {}: {:?}", "table", - "StoreDelRecord", e - ), - ); - } - }; + let table = + match starknet::core::types::Felt::cairo_deserialize(&event.data, data_offset) { + Ok(v) => v, + Err(e) => { + return Err(format!( + "Could not deserialize field {} for {}: {:?}", + "table", "StoreDelRecord", e + )); + } + }; data_offset += starknet::core::types::Felt::cairo_serialized_size(&table); - let entity_id = match starknet::core::types::Felt::cairo_deserialize( - &event.data, - data_offset, - ) { - Ok(v) => v, - Err(e) => { - return Err( - format!( - "Could not deserialize field {} for {}: {:?}", "entity_id", - "StoreDelRecord", e - ), - ); - } - }; - data_offset - += starknet::core::types::Felt::cairo_serialized_size(&entity_id); + let entity_id = + match starknet::core::types::Felt::cairo_deserialize(&event.data, data_offset) { + Ok(v) => v, + Err(e) => { + return Err(format!( + "Could not deserialize field {} for {}: {:?}", + "entity_id", "StoreDelRecord", e + )); + } + }; + data_offset += starknet::core::types::Felt::cairo_serialized_size(&entity_id); return Ok(Event::StoreDelRecord(StoreDelRecord { table, entity_id })); } let selector = event.keys[0]; @@ -2632,20 +2116,16 @@ impl TryFrom for Event { { let mut key_offset = 0 + 1; let mut data_offset = 0; - let resource = match starknet::core::types::Felt::cairo_deserialize( - &event.data, - data_offset, - ) { - Ok(v) => v, - Err(e) => { - return Err( - format!( - "Could not deserialize field {} for {}: {:?}", "resource", - "WriterUpdated", e - ), - ); - } - }; + let resource = + match starknet::core::types::Felt::cairo_deserialize(&event.data, data_offset) { + Ok(v) => v, + Err(e) => { + return Err(format!( + "Could not deserialize field {} for {}: {:?}", + "resource", "WriterUpdated", e + )); + } + }; data_offset += starknet::core::types::Felt::cairo_serialized_size(&resource); let contract = match cainome::cairo_serde::ContractAddress::cairo_deserialize( &event.data, @@ -2653,37 +2133,28 @@ impl TryFrom for Event { ) { Ok(v) => v, Err(e) => { - return Err( - format!( - "Could not deserialize field {} for {}: {:?}", "contract", - "WriterUpdated", e - ), - ); + return Err(format!( + "Could not deserialize field {} for {}: {:?}", + "contract", "WriterUpdated", e + )); } }; - data_offset - += cainome::cairo_serde::ContractAddress::cairo_serialized_size( - &contract, - ); + data_offset += cainome::cairo_serde::ContractAddress::cairo_serialized_size(&contract); let value = match bool::cairo_deserialize(&event.data, data_offset) { Ok(v) => v, Err(e) => { - return Err( - format!( - "Could not deserialize field {} for {}: {:?}", "value", - "WriterUpdated", e - ), - ); + return Err(format!( + "Could not deserialize field {} for {}: {:?}", + "value", "WriterUpdated", e + )); } }; data_offset += bool::cairo_serialized_size(&value); - return Ok( - Event::WriterUpdated(WriterUpdated { - resource, - contract, - value, - }), - ); + return Ok(Event::WriterUpdated(WriterUpdated { + resource, + contract, + value, + })); } let selector = event.keys[0]; if selector @@ -2698,52 +2169,39 @@ impl TryFrom for Event { ) { Ok(v) => v, Err(e) => { - return Err( - format!( - "Could not deserialize field {} for {}: {:?}", "address", - "OwnerUpdated", e - ), - ); - } - }; - data_offset - += cainome::cairo_serde::ContractAddress::cairo_serialized_size( - &address, - ); - let resource = match starknet::core::types::Felt::cairo_deserialize( - &event.data, - data_offset, - ) { - Ok(v) => v, - Err(e) => { - return Err( - format!( - "Could not deserialize field {} for {}: {:?}", "resource", - "OwnerUpdated", e - ), - ); + return Err(format!( + "Could not deserialize field {} for {}: {:?}", + "address", "OwnerUpdated", e + )); } }; + data_offset += cainome::cairo_serde::ContractAddress::cairo_serialized_size(&address); + let resource = + match starknet::core::types::Felt::cairo_deserialize(&event.data, data_offset) { + Ok(v) => v, + Err(e) => { + return Err(format!( + "Could not deserialize field {} for {}: {:?}", + "resource", "OwnerUpdated", e + )); + } + }; data_offset += starknet::core::types::Felt::cairo_serialized_size(&resource); let value = match bool::cairo_deserialize(&event.data, data_offset) { Ok(v) => v, Err(e) => { - return Err( - format!( - "Could not deserialize field {} for {}: {:?}", "value", - "OwnerUpdated", e - ), - ); + return Err(format!( + "Could not deserialize field {} for {}: {:?}", + "value", "OwnerUpdated", e + )); } }; data_offset += bool::cairo_serialized_size(&value); - return Ok( - Event::OwnerUpdated(OwnerUpdated { - address, - resource, - value, - }), - ); + return Ok(Event::OwnerUpdated(OwnerUpdated { + address, + resource, + value, + })); } let selector = event.keys[0]; if selector @@ -2752,9 +2210,7 @@ impl TryFrom for Event { { let selector = event.keys[1]; if selector - == starknet::core::utils::get_selector_from_name( - "DifferProgramHashUpdate", - ) + == starknet::core::utils::get_selector_from_name("DifferProgramHashUpdate") .unwrap_or_else(|_| { panic!("Invalid selector for {}", "DifferProgramHashUpdate") }) @@ -2767,29 +2223,22 @@ impl TryFrom for Event { ) { Ok(v) => v, Err(e) => { - return Err( - format!( - "Could not deserialize field {} for {}: {:?}", - "program_hash", "DifferProgramHashUpdate", e - ), - ); + return Err(format!( + "Could not deserialize field {} for {}: {:?}", + "program_hash", "DifferProgramHashUpdate", e + )); } }; - data_offset - += starknet::core::types::Felt::cairo_serialized_size(&program_hash); - return Ok( - Event::ConfigEvent( - DojoConfigEvent::DifferProgramHashUpdate(DifferProgramHashUpdate { - program_hash, - }), - ), - ); + data_offset += starknet::core::types::Felt::cairo_serialized_size(&program_hash); + return Ok(Event::ConfigEvent( + DojoConfigEvent::DifferProgramHashUpdate(DifferProgramHashUpdate { + program_hash, + }), + )); } let selector = event.keys[1]; if selector - == starknet::core::utils::get_selector_from_name( - "MergerProgramHashUpdate", - ) + == starknet::core::utils::get_selector_from_name("MergerProgramHashUpdate") .unwrap_or_else(|_| { panic!("Invalid selector for {}", "MergerProgramHashUpdate") }) @@ -2802,30 +2251,23 @@ impl TryFrom for Event { ) { Ok(v) => v, Err(e) => { - return Err( - format!( - "Could not deserialize field {} for {}: {:?}", - "program_hash", "MergerProgramHashUpdate", e - ), - ); + return Err(format!( + "Could not deserialize field {} for {}: {:?}", + "program_hash", "MergerProgramHashUpdate", e + )); } }; - data_offset - += starknet::core::types::Felt::cairo_serialized_size(&program_hash); - return Ok( - Event::ConfigEvent( - DojoConfigEvent::MergerProgramHashUpdate(MergerProgramHashUpdate { - program_hash, - }), - ), - ); + data_offset += starknet::core::types::Felt::cairo_serialized_size(&program_hash); + return Ok(Event::ConfigEvent( + DojoConfigEvent::MergerProgramHashUpdate(MergerProgramHashUpdate { + program_hash, + }), + )); } let selector = event.keys[1]; if selector == starknet::core::utils::get_selector_from_name("FactsRegistryUpdate") - .unwrap_or_else(|_| { - panic!("Invalid selector for {}", "FactsRegistryUpdate") - }) + .unwrap_or_else(|_| panic!("Invalid selector for {}", "FactsRegistryUpdate")) { let mut key_offset = 1 + 1; let mut data_offset = 0; @@ -2835,25 +2277,17 @@ impl TryFrom for Event { ) { Ok(v) => v, Err(e) => { - return Err( - format!( - "Could not deserialize field {} for {}: {:?}", "address", - "FactsRegistryUpdate", e - ), - ); + return Err(format!( + "Could not deserialize field {} for {}: {:?}", + "address", "FactsRegistryUpdate", e + )); } }; - data_offset - += cainome::cairo_serde::ContractAddress::cairo_serialized_size( - &address, - ); - return Ok( - Event::ConfigEvent( - DojoConfigEvent::FactsRegistryUpdate(FactsRegistryUpdate { - address, - }), - ), - ); + data_offset += + cainome::cairo_serde::ContractAddress::cairo_serialized_size(&address); + return Ok(Event::ConfigEvent(DojoConfigEvent::FactsRegistryUpdate( + FactsRegistryUpdate { address }, + ))); } } let selector = event.keys[0]; @@ -2863,24 +2297,23 @@ impl TryFrom for Event { { let mut key_offset = 0 + 1; let mut data_offset = 0; - let da_hash = match starknet::core::types::Felt::cairo_deserialize( - &event.data, - data_offset, - ) { - Ok(v) => v, - Err(e) => { - return Err( - format!( - "Could not deserialize field {} for {}: {:?}", "da_hash", - "StateUpdated", e - ), - ); - } - }; + let da_hash = + match starknet::core::types::Felt::cairo_deserialize(&event.data, data_offset) { + Ok(v) => v, + Err(e) => { + return Err(format!( + "Could not deserialize field {} for {}: {:?}", + "da_hash", "StateUpdated", e + )); + } + }; data_offset += starknet::core::types::Felt::cairo_serialized_size(&da_hash); return Ok(Event::StateUpdated(StateUpdated { da_hash })); } - Err(format!("Could not match any event from keys {:?}", event.keys)) + Err(format!( + "Could not match any event from keys {:?}", + event.keys + )) } } #[derive(Clone, serde::Serialize, serde::Deserialize, PartialEq, Debug)] @@ -2950,44 +2383,32 @@ impl cainome::cairo_serde::CairoSerde for Layout { let __f = __felts[__offset]; let __index = u128::from_be_bytes(__f.to_bytes_be()[16..].try_into().unwrap()); match __index as usize { - 0usize => { - Ok(Layout::Fixed(Vec::::cairo_deserialize(__felts, __offset + 1)?)) - } - 1usize => { - Ok( - Layout::Struct( - Vec::::cairo_deserialize(__felts, __offset + 1)?, - ), - ) - } - 2usize => { - Ok( - Layout::Tuple( - Vec::::cairo_deserialize(__felts, __offset + 1)?, - ), - ) - } - 3usize => { - Ok( - Layout::Array( - Vec::::cairo_deserialize(__felts, __offset + 1)?, - ), - ) - } + 0usize => Ok(Layout::Fixed(Vec::::cairo_deserialize( + __felts, + __offset + 1, + )?)), + 1usize => Ok(Layout::Struct(Vec::::cairo_deserialize( + __felts, + __offset + 1, + )?)), + 2usize => Ok(Layout::Tuple(Vec::::cairo_deserialize( + __felts, + __offset + 1, + )?)), + 3usize => Ok(Layout::Array(Vec::::cairo_deserialize( + __felts, + __offset + 1, + )?)), 4usize => Ok(Layout::ByteArray), - 5usize => { - Ok( - Layout::Enum( - Vec::::cairo_deserialize(__felts, __offset + 1)?, - ), - ) - } + 5usize => Ok(Layout::Enum(Vec::::cairo_deserialize( + __felts, + __offset + 1, + )?)), _ => { - return Err( - cainome::cairo_serde::Error::Deserialize( - format!("Index not handle for enum {}", "Layout"), - ), - ); + return Err(cainome::cairo_serde::Error::Deserialize(format!( + "Index not handle for enum {}", + "Layout" + ))); } } } @@ -3007,14 +2428,11 @@ impl cainome::cairo_serde::CairoSerde for ModelIndex { ModelIndex::Keys(val) => { Vec::::cairo_serialized_size(val) + 1 } - ModelIndex::Id(val) => { - starknet::core::types::Felt::cairo_serialized_size(val) + 1 - } + ModelIndex::Id(val) => starknet::core::types::Felt::cairo_serialized_size(val) + 1, ModelIndex::MemberId(val) => { - <( - starknet::core::types::Felt, - starknet::core::types::Felt, - )>::cairo_serialized_size(val) + 1 + <(starknet::core::types::Felt, starknet::core::types::Felt)>::cairo_serialized_size( + val, + ) + 1 } _ => 0, } @@ -3037,10 +2455,9 @@ impl cainome::cairo_serde::CairoSerde for ModelIndex { let mut temp = vec![]; temp.extend(usize::cairo_serialize(&2usize)); temp.extend( - <( - starknet::core::types::Felt, - starknet::core::types::Felt, - )>::cairo_serialize(val), + <(starknet::core::types::Felt, starknet::core::types::Felt)>::cairo_serialize( + val, + ), ); temp } @@ -3054,49 +2471,41 @@ impl cainome::cairo_serde::CairoSerde for ModelIndex { let __f = __felts[__offset]; let __index = u128::from_be_bytes(__f.to_bytes_be()[16..].try_into().unwrap()); match __index as usize { - 0usize => { - Ok( - ModelIndex::Keys( - Vec::< - starknet::core::types::Felt, - >::cairo_deserialize(__felts, __offset + 1)?, - ), - ) - } - 1usize => { - Ok( - ModelIndex::Id( - starknet::core::types::Felt::cairo_deserialize( - __felts, - __offset + 1, - )?, - ), - ) - } - 2usize => { - Ok( - ModelIndex::MemberId( - <( - starknet::core::types::Felt, - starknet::core::types::Felt, - )>::cairo_deserialize(__felts, __offset + 1)?, - ), - ) - } + 0usize => Ok(ModelIndex::Keys( + Vec::::cairo_deserialize(__felts, __offset + 1)?, + )), + 1usize => Ok(ModelIndex::Id( + starknet::core::types::Felt::cairo_deserialize(__felts, __offset + 1)?, + )), + 2usize => Ok(ModelIndex::MemberId(<( + starknet::core::types::Felt, + starknet::core::types::Felt, + )>::cairo_deserialize( + __felts, __offset + 1 + )?)), _ => { - return Err( - cainome::cairo_serde::Error::Deserialize( - format!("Index not handle for enum {}", "ModelIndex"), - ), - ); + return Err(cainome::cairo_serde::Error::Deserialize(format!( + "Index not handle for enum {}", + "ModelIndex" + ))); } } } } #[derive(Clone, serde::Serialize, serde::Deserialize, PartialEq, Debug)] pub enum Resource { - Model((cainome::cairo_serde::ClassHash, cainome::cairo_serde::ContractAddress)), - Contract((cainome::cairo_serde::ClassHash, cainome::cairo_serde::ContractAddress)), + Model( + ( + cainome::cairo_serde::ClassHash, + cainome::cairo_serde::ContractAddress, + ), + ), + Contract( + ( + cainome::cairo_serde::ClassHash, + cainome::cairo_serde::ContractAddress, + ), + ), Namespace, World, Unregistered, @@ -3111,13 +2520,15 @@ impl cainome::cairo_serde::CairoSerde for Resource { <( cainome::cairo_serde::ClassHash, cainome::cairo_serde::ContractAddress, - )>::cairo_serialized_size(val) + 1 + )>::cairo_serialized_size(val) + + 1 } Resource::Contract(val) => { <( cainome::cairo_serde::ClassHash, cainome::cairo_serde::ContractAddress, - )>::cairo_serialized_size(val) + 1 + )>::cairo_serialized_size(val) + + 1 } Resource::Namespace => 1, Resource::World => 1, @@ -3130,23 +2541,19 @@ impl cainome::cairo_serde::CairoSerde for Resource { Resource::Model(val) => { let mut temp = vec![]; temp.extend(usize::cairo_serialize(&0usize)); - temp.extend( - <( - cainome::cairo_serde::ClassHash, - cainome::cairo_serde::ContractAddress, - )>::cairo_serialize(val), - ); + temp.extend(<( + cainome::cairo_serde::ClassHash, + cainome::cairo_serde::ContractAddress, + )>::cairo_serialize(val)); temp } Resource::Contract(val) => { let mut temp = vec![]; temp.extend(usize::cairo_serialize(&1usize)); - temp.extend( - <( - cainome::cairo_serde::ClassHash, - cainome::cairo_serde::ContractAddress, - )>::cairo_serialize(val), - ); + temp.extend(<( + cainome::cairo_serde::ClassHash, + cainome::cairo_serde::ContractAddress, + )>::cairo_serialize(val)); temp } Resource::Namespace => usize::cairo_serialize(&2usize), @@ -3162,35 +2569,26 @@ impl cainome::cairo_serde::CairoSerde for Resource { let __f = __felts[__offset]; let __index = u128::from_be_bytes(__f.to_bytes_be()[16..].try_into().unwrap()); match __index as usize { - 0usize => { - Ok( - Resource::Model( - <( - cainome::cairo_serde::ClassHash, - cainome::cairo_serde::ContractAddress, - )>::cairo_deserialize(__felts, __offset + 1)?, - ), - ) - } - 1usize => { - Ok( - Resource::Contract( - <( - cainome::cairo_serde::ClassHash, - cainome::cairo_serde::ContractAddress, - )>::cairo_deserialize(__felts, __offset + 1)?, - ), - ) - } + 0usize => Ok(Resource::Model(<( + cainome::cairo_serde::ClassHash, + cainome::cairo_serde::ContractAddress, + )>::cairo_deserialize( + __felts, __offset + 1 + )?)), + 1usize => Ok(Resource::Contract(<( + cainome::cairo_serde::ClassHash, + cainome::cairo_serde::ContractAddress, + )>::cairo_deserialize( + __felts, __offset + 1 + )?)), 2usize => Ok(Resource::Namespace), 3usize => Ok(Resource::World), 4usize => Ok(Resource::Unregistered), _ => { - return Err( - cainome::cairo_serde::Error::Deserialize( - format!("Index not handle for enum {}", "Resource"), - ), - ); + return Err(cainome::cairo_serde::Error::Deserialize(format!( + "Index not handle for enum {}", + "Resource" + ))); } } } @@ -3200,10 +2598,7 @@ impl WorldContract { #[allow(clippy::too_many_arguments)] pub fn base( &self, - ) -> cainome::cairo_serde::call::FCall< - A::Provider, - cainome::cairo_serde::ClassHash, - > { + ) -> cainome::cairo_serde::call::FCall { use cainome::cairo_serde::CairoSerde; let mut __calldata = vec![]; let __call = starknet::core::types::FunctionCall { @@ -3238,10 +2633,7 @@ impl WorldContract { model_selector: &starknet::core::types::Felt, index: &ModelIndex, layout: &Layout, - ) -> cainome::cairo_serde::call::FCall< - A::Provider, - Vec, - > { + ) -> cainome::cairo_serde::call::FCall> { use cainome::cairo_serde::CairoSerde; let mut __calldata = vec![]; __calldata.extend(starknet::core::types::Felt::cairo_serialize(model_selector)); @@ -3272,10 +2664,7 @@ impl WorldContract { #[allow(clippy::too_many_arguments)] pub fn get_facts_registry( &self, - ) -> cainome::cairo_serde::call::FCall< - A::Provider, - cainome::cairo_serde::ContractAddress, - > { + ) -> cainome::cairo_serde::call::FCall { use cainome::cairo_serde::CairoSerde; let mut __calldata = vec![]; let __call = starknet::core::types::FunctionCall { @@ -3309,8 +2698,9 @@ impl WorldContract { use cainome::cairo_serde::CairoSerde; let mut __calldata = vec![]; __calldata.extend(starknet::core::types::Felt::cairo_serialize(resource)); - __calldata - .extend(cainome::cairo_serde::ContractAddress::cairo_serialize(address)); + __calldata.extend(cainome::cairo_serde::ContractAddress::cairo_serialize( + address, + )); let __call = starknet::core::types::FunctionCall { contract_address: self.address, entry_point_selector: starknet::macros::selector!("is_owner"), @@ -3328,8 +2718,9 @@ impl WorldContract { use cainome::cairo_serde::CairoSerde; let mut __calldata = vec![]; __calldata.extend(starknet::core::types::Felt::cairo_serialize(resource)); - __calldata - .extend(cainome::cairo_serde::ContractAddress::cairo_serialize(contract)); + __calldata.extend(cainome::cairo_serde::ContractAddress::cairo_serialize( + contract, + )); let __call = starknet::core::types::FunctionCall { contract_address: self.address, entry_point_selector: starknet::macros::selector!("is_writer"), @@ -3345,8 +2736,9 @@ impl WorldContract { ) -> cainome::cairo_serde::call::FCall { use cainome::cairo_serde::CairoSerde; let mut __calldata = vec![]; - __calldata - .extend(starknet::core::types::Felt::cairo_serialize(resource_selector)); + __calldata.extend(starknet::core::types::Felt::cairo_serialize( + resource_selector, + )); let __call = starknet::core::types::FunctionCall { contract_address: self.address, entry_point_selector: starknet::macros::selector!("metadata"), @@ -3454,8 +2846,9 @@ impl WorldContract { use cainome::cairo_serde::CairoSerde; let mut __calldata = vec![]; __calldata.extend(starknet::core::types::Felt::cairo_serialize(resource)); - __calldata - .extend(cainome::cairo_serde::ContractAddress::cairo_serialize(address)); + __calldata.extend(cainome::cairo_serde::ContractAddress::cairo_serialize( + address, + )); starknet::core::types::Call { to: self.address, selector: starknet::macros::selector!("grant_owner"), @@ -3472,8 +2865,9 @@ impl WorldContract { use cainome::cairo_serde::CairoSerde; let mut __calldata = vec![]; __calldata.extend(starknet::core::types::Felt::cairo_serialize(resource)); - __calldata - .extend(cainome::cairo_serde::ContractAddress::cairo_serialize(address)); + __calldata.extend(cainome::cairo_serde::ContractAddress::cairo_serialize( + address, + )); let __call = starknet::core::types::Call { to: self.address, selector: starknet::macros::selector!("grant_owner"), @@ -3491,8 +2885,9 @@ impl WorldContract { use cainome::cairo_serde::CairoSerde; let mut __calldata = vec![]; __calldata.extend(starknet::core::types::Felt::cairo_serialize(resource)); - __calldata - .extend(cainome::cairo_serde::ContractAddress::cairo_serialize(contract)); + __calldata.extend(cainome::cairo_serde::ContractAddress::cairo_serialize( + contract, + )); starknet::core::types::Call { to: self.address, selector: starknet::macros::selector!("grant_writer"), @@ -3509,8 +2904,9 @@ impl WorldContract { use cainome::cairo_serde::CairoSerde; let mut __calldata = vec![]; __calldata.extend(starknet::core::types::Felt::cairo_serialize(resource)); - __calldata - .extend(cainome::cairo_serde::ContractAddress::cairo_serialize(contract)); + __calldata.extend(cainome::cairo_serde::ContractAddress::cairo_serialize( + contract, + )); let __call = starknet::core::types::Call { to: self.address, selector: starknet::macros::selector!("grant_writer"), @@ -3528,8 +2924,9 @@ impl WorldContract { use cainome::cairo_serde::CairoSerde; let mut __calldata = vec![]; __calldata.extend(starknet::core::types::Felt::cairo_serialize(selector)); - __calldata - .extend(Vec::::cairo_serialize(init_calldata)); + __calldata.extend(Vec::::cairo_serialize( + init_calldata, + )); starknet::core::types::Call { to: self.address, selector: starknet::macros::selector!("init_contract"), @@ -3546,8 +2943,9 @@ impl WorldContract { use cainome::cairo_serde::CairoSerde; let mut __calldata = vec![]; __calldata.extend(starknet::core::types::Felt::cairo_serialize(selector)); - __calldata - .extend(Vec::::cairo_serialize(init_calldata)); + __calldata.extend(Vec::::cairo_serialize( + init_calldata, + )); let __call = starknet::core::types::Call { to: self.address, selector: starknet::macros::selector!("init_contract"), @@ -3627,8 +3025,9 @@ impl WorldContract { use cainome::cairo_serde::CairoSerde; let mut __calldata = vec![]; __calldata.extend(starknet::core::types::Felt::cairo_serialize(resource)); - __calldata - .extend(cainome::cairo_serde::ContractAddress::cairo_serialize(address)); + __calldata.extend(cainome::cairo_serde::ContractAddress::cairo_serialize( + address, + )); starknet::core::types::Call { to: self.address, selector: starknet::macros::selector!("revoke_owner"), @@ -3645,8 +3044,9 @@ impl WorldContract { use cainome::cairo_serde::CairoSerde; let mut __calldata = vec![]; __calldata.extend(starknet::core::types::Felt::cairo_serialize(resource)); - __calldata - .extend(cainome::cairo_serde::ContractAddress::cairo_serialize(address)); + __calldata.extend(cainome::cairo_serde::ContractAddress::cairo_serialize( + address, + )); let __call = starknet::core::types::Call { to: self.address, selector: starknet::macros::selector!("revoke_owner"), @@ -3664,8 +3064,9 @@ impl WorldContract { use cainome::cairo_serde::CairoSerde; let mut __calldata = vec![]; __calldata.extend(starknet::core::types::Felt::cairo_serialize(resource)); - __calldata - .extend(cainome::cairo_serde::ContractAddress::cairo_serialize(contract)); + __calldata.extend(cainome::cairo_serde::ContractAddress::cairo_serialize( + contract, + )); starknet::core::types::Call { to: self.address, selector: starknet::macros::selector!("revoke_writer"), @@ -3682,8 +3083,9 @@ impl WorldContract { use cainome::cairo_serde::CairoSerde; let mut __calldata = vec![]; __calldata.extend(starknet::core::types::Felt::cairo_serialize(resource)); - __calldata - .extend(cainome::cairo_serde::ContractAddress::cairo_serialize(contract)); + __calldata.extend(cainome::cairo_serde::ContractAddress::cairo_serialize( + contract, + )); let __call = starknet::core::types::Call { to: self.address, selector: starknet::macros::selector!("revoke_writer"), @@ -3773,8 +3175,9 @@ impl WorldContract { ) -> starknet::core::types::Call { use cainome::cairo_serde::CairoSerde; let mut __calldata = vec![]; - __calldata - .extend(cainome::cairo_serde::ContractAddress::cairo_serialize(address)); + __calldata.extend(cainome::cairo_serde::ContractAddress::cairo_serialize( + address, + )); starknet::core::types::Call { to: self.address, selector: starknet::macros::selector!("set_facts_registry"), @@ -3789,8 +3192,9 @@ impl WorldContract { ) -> starknet::accounts::ExecutionV1 { use cainome::cairo_serde::CairoSerde; let mut __calldata = vec![]; - __calldata - .extend(cainome::cairo_serde::ContractAddress::cairo_serialize(address)); + __calldata.extend(cainome::cairo_serde::ContractAddress::cairo_serialize( + address, + )); let __call = starknet::core::types::Call { to: self.address, selector: starknet::macros::selector!("set_facts_registry"), @@ -3831,10 +3235,7 @@ impl WorldContract { } #[allow(clippy::ptr_arg)] #[allow(clippy::too_many_arguments)] - pub fn set_metadata_getcall( - &self, - metadata: &ResourceMetadata, - ) -> starknet::core::types::Call { + pub fn set_metadata_getcall(&self, metadata: &ResourceMetadata) -> starknet::core::types::Call { use cainome::cairo_serde::CairoSerde; let mut __calldata = vec![]; __calldata.extend(ResourceMetadata::cairo_serialize(metadata)); @@ -3846,10 +3247,7 @@ impl WorldContract { } #[allow(clippy::ptr_arg)] #[allow(clippy::too_many_arguments)] - pub fn set_metadata( - &self, - metadata: &ResourceMetadata, - ) -> starknet::accounts::ExecutionV1 { + pub fn set_metadata(&self, metadata: &ResourceMetadata) -> starknet::accounts::ExecutionV1 { use cainome::cairo_serde::CairoSerde; let mut __calldata = vec![]; __calldata.extend(ResourceMetadata::cairo_serialize(metadata)); @@ -3868,8 +3266,9 @@ impl WorldContract { ) -> starknet::core::types::Call { use cainome::cairo_serde::CairoSerde; let mut __calldata = vec![]; - __calldata - .extend(cainome::cairo_serde::ClassHash::cairo_serialize(new_class_hash)); + __calldata.extend(cainome::cairo_serde::ClassHash::cairo_serialize( + new_class_hash, + )); starknet::core::types::Call { to: self.address, selector: starknet::macros::selector!("upgrade"), @@ -3884,8 +3283,9 @@ impl WorldContract { ) -> starknet::accounts::ExecutionV1 { use cainome::cairo_serde::CairoSerde; let mut __calldata = vec![]; - __calldata - .extend(cainome::cairo_serde::ClassHash::cairo_serialize(new_class_hash)); + __calldata.extend(cainome::cairo_serde::ClassHash::cairo_serialize( + new_class_hash, + )); let __call = starknet::core::types::Call { to: self.address, selector: starknet::macros::selector!("upgrade"), @@ -4025,9 +3425,7 @@ impl WorldContract { impl WorldContractReader

{ #[allow(clippy::ptr_arg)] #[allow(clippy::too_many_arguments)] - pub fn base( - &self, - ) -> cainome::cairo_serde::call::FCall { + pub fn base(&self) -> cainome::cairo_serde::call::FCall { use cainome::cairo_serde::CairoSerde; let mut __calldata = vec![]; let __call = starknet::core::types::FunctionCall { @@ -4127,8 +3525,9 @@ impl WorldContractReader

{ use cainome::cairo_serde::CairoSerde; let mut __calldata = vec![]; __calldata.extend(starknet::core::types::Felt::cairo_serialize(resource)); - __calldata - .extend(cainome::cairo_serde::ContractAddress::cairo_serialize(address)); + __calldata.extend(cainome::cairo_serde::ContractAddress::cairo_serialize( + address, + )); let __call = starknet::core::types::FunctionCall { contract_address: self.address, entry_point_selector: starknet::macros::selector!("is_owner"), @@ -4146,8 +3545,9 @@ impl WorldContractReader

{ use cainome::cairo_serde::CairoSerde; let mut __calldata = vec![]; __calldata.extend(starknet::core::types::Felt::cairo_serialize(resource)); - __calldata - .extend(cainome::cairo_serde::ContractAddress::cairo_serialize(contract)); + __calldata.extend(cainome::cairo_serde::ContractAddress::cairo_serialize( + contract, + )); let __call = starknet::core::types::FunctionCall { contract_address: self.address, entry_point_selector: starknet::macros::selector!("is_writer"), @@ -4163,8 +3563,9 @@ impl WorldContractReader

{ ) -> cainome::cairo_serde::call::FCall { use cainome::cairo_serde::CairoSerde; let mut __calldata = vec![]; - __calldata - .extend(starknet::core::types::Felt::cairo_serialize(resource_selector)); + __calldata.extend(starknet::core::types::Felt::cairo_serialize( + resource_selector, + )); let __call = starknet::core::types::FunctionCall { contract_address: self.address, entry_point_selector: starknet::macros::selector!("metadata"), diff --git a/crates/types/tests/json.rs b/crates/types/tests/json.rs index 61a6579..ea1a9f3 100644 --- a/crates/types/tests/json.rs +++ b/crates/types/tests/json.rs @@ -7,8 +7,16 @@ fn serialize_ty_to_json() { let ty = Ty::Struct(Struct { name: "Position".into(), children: vec![ - Member { name: "x".into(), key: false, ty: Ty::Primitive(Primitive::U8(Some(128))) }, - Member { name: "y".into(), key: false, ty: Ty::Primitive(Primitive::U64(Some(2048))) }, + Member { + name: "x".into(), + key: false, + ty: Ty::Primitive(Primitive::U8(Some(128))), + }, + Member { + name: "y".into(), + key: false, + ty: Ty::Primitive(Primitive::U64(Some(2048))), + }, Member { name: "kind".into(), key: false, @@ -16,8 +24,14 @@ fn serialize_ty_to_json() { name: "PositionKind".into(), option: Some(1), options: vec![ - EnumOption { name: "Kind1".into(), ty: Ty::Tuple(vec![]) }, - EnumOption { name: "Kind2".into(), ty: Ty::Tuple(vec![]) }, + EnumOption { + name: "Kind1".into(), + ty: Ty::Tuple(vec![]), + }, + EnumOption { + name: "Kind2".into(), + ty: Ty::Tuple(vec![]), + }, ], }), }, @@ -149,8 +163,16 @@ fn deserialize_ty_from_json() { let expected_value = Ty::Struct(Struct { name: "Position".into(), children: vec![ - Member { name: "x".into(), key: false, ty: Ty::Primitive(Primitive::U8(Some(128))) }, - Member { name: "y".into(), key: false, ty: Ty::Primitive(Primitive::U64(Some(2048))) }, + Member { + name: "x".into(), + key: false, + ty: Ty::Primitive(Primitive::U8(Some(128))), + }, + Member { + name: "y".into(), + key: false, + ty: Ty::Primitive(Primitive::U64(Some(2048))), + }, Member { name: "kind".into(), key: false, @@ -158,8 +180,14 @@ fn deserialize_ty_from_json() { name: "PositionKind".into(), option: Some(1), options: vec![ - EnumOption { name: "Kind1".into(), ty: Ty::Tuple(vec![]) }, - EnumOption { name: "Kind2".into(), ty: Ty::Tuple(vec![]) }, + EnumOption { + name: "Kind1".into(), + ty: Ty::Tuple(vec![]), + }, + EnumOption { + name: "Kind2".into(), + ty: Ty::Tuple(vec![]), + }, ], }), }, diff --git a/examples/game-lib/Scarb.lock b/examples/game-lib/Scarb.lock new file mode 100644 index 0000000..8c5b465 --- /dev/null +++ b/examples/game-lib/Scarb.lock @@ -0,0 +1,28 @@ +# Code generated by scarb DO NOT EDIT. +version = 1 + +[[package]] +name = "armory" +version = "0.1.0" +dependencies = [ + "dojo", +] + +[[package]] +name = "bestiary" +version = "0.1.0" +dependencies = [ + "dojo", +] + +[[package]] +name = "dojo" +version = "1.0.0-alpha.4" +dependencies = [ + "dojo_plugin", +] + +[[package]] +name = "dojo_plugin" +version = "1.0.0-alpha.4" +source = "git+https://github.com/dojoengine/dojo?rev=f15def33#f15def330c0d099e79351d11c197f63e8cc1ff36" diff --git a/examples/game-lib/Scarb.toml b/examples/game-lib/Scarb.toml new file mode 100644 index 0000000..e2f0690 --- /dev/null +++ b/examples/game-lib/Scarb.toml @@ -0,0 +1,12 @@ +[workspace] +members = [ + "armory", + "bestiary" +] + +[workspace.package] +version = "0.1.0" +description = "Example game library for Dojo" + +[workspace.dependencies] +dojo = { path = "../../crates/contracts/" } diff --git a/examples/game-lib/armory/Scarb.lock b/examples/game-lib/armory/Scarb.lock new file mode 100644 index 0000000..39069b1 --- /dev/null +++ b/examples/game-lib/armory/Scarb.lock @@ -0,0 +1,21 @@ +# Code generated by scarb DO NOT EDIT. +version = 1 + +[[package]] +name = "armory" +version = "0.7.3" +dependencies = [ + "dojo", +] + +[[package]] +name = "dojo" +version = "0.7.3" +dependencies = [ + "dojo_plugin", +] + +[[package]] +name = "dojo_plugin" +version = "0.7.2" +source = "git+https://github.com/dojoengine/dojo?tag=v0.7.3#e8539d5b199efbd51c89c75da32f6592de5d9262" diff --git a/examples/game-lib/armory/Scarb.toml b/examples/game-lib/armory/Scarb.toml new file mode 100644 index 0000000..103b5ec --- /dev/null +++ b/examples/game-lib/armory/Scarb.toml @@ -0,0 +1,9 @@ +[package] +name = "armory" +version = "0.1.0" +description = "An armory of epic weapons." + +[dependencies] +dojo.workspace = true + +[lib] diff --git a/examples/game-lib/armory/dojo_dev.toml b/examples/game-lib/armory/dojo_dev.toml new file mode 100644 index 0000000..2e10f73 --- /dev/null +++ b/examples/game-lib/armory/dojo_dev.toml @@ -0,0 +1,6 @@ +[world] +name = "" +seed = "" + +[namespace] +default = "armory" diff --git a/examples/game-lib/armory/src/lib.cairo b/examples/game-lib/armory/src/lib.cairo new file mode 100644 index 0000000..b182078 --- /dev/null +++ b/examples/game-lib/armory/src/lib.cairo @@ -0,0 +1,8 @@ +#[derive(Drop, Serde)] +#[dojo::model] +pub struct Flatbow { + #[key] + pub id: u32, + pub atk_speek: u32, + pub range: u32, +} diff --git a/examples/game-lib/bestiary/Scarb.toml b/examples/game-lib/bestiary/Scarb.toml new file mode 100644 index 0000000..195a962 --- /dev/null +++ b/examples/game-lib/bestiary/Scarb.toml @@ -0,0 +1,9 @@ +[package] +name = "bestiary" +version = "0.1.0" +description = "Some scary foes to fight." + +[dependencies] +dojo.workspace = true + +[lib] diff --git a/examples/game-lib/bestiary/dojo_dev.toml b/examples/game-lib/bestiary/dojo_dev.toml new file mode 100644 index 0000000..d6c6431 --- /dev/null +++ b/examples/game-lib/bestiary/dojo_dev.toml @@ -0,0 +1,6 @@ +[world] +name = "" +seed = "" + +[namespace] +default = "bestiary" diff --git a/examples/game-lib/bestiary/src/lib.cairo b/examples/game-lib/bestiary/src/lib.cairo new file mode 100644 index 0000000..77f4ac8 --- /dev/null +++ b/examples/game-lib/bestiary/src/lib.cairo @@ -0,0 +1,9 @@ +#[derive(Drop, Serde)] +#[dojo::model] +pub struct RiverSkale { + #[key] + pub id: u32, + pub health: u32, + pub armor: u32, + pub attack: u32, +} diff --git a/examples/spawn-and-move/.gitignore b/examples/spawn-and-move/.gitignore new file mode 100644 index 0000000..b61463a --- /dev/null +++ b/examples/spawn-and-move/.gitignore @@ -0,0 +1,2 @@ +target +generated diff --git a/examples/spawn-and-move/Cargo.toml b/examples/spawn-and-move/Cargo.toml new file mode 100644 index 0000000..e2aea7d --- /dev/null +++ b/examples/spawn-and-move/Cargo.toml @@ -0,0 +1,15 @@ +[package] +edition.workspace = true +license-file.workspace = true +name = "dojo-examples-spawn-and-move" +repository.workspace = true +version.workspace = true + +[package.metadata.release] +pre-release-replacements = [ + { file = "Scarb.lock", search = "^name = \"dojo\"\nversion = \".*\"$", replace = "name = \"dojo\"\nversion = \"{{version}}\"", min = 1 }, + { file = "Scarb.toml", search = "^version = \".*\"$", replace = "version = \"{{version}}\"", min = 1 }, +] + +[lib] +path = "src/lib.rs" diff --git a/examples/spawn-and-move/README.md b/examples/spawn-and-move/README.md new file mode 100644 index 0000000..5d1bc4c --- /dev/null +++ b/examples/spawn-and-move/README.md @@ -0,0 +1,66 @@ +# Dojo ECS Example + +This repo contains a simple example of using the Dojo ECS system. It defines a simple game where a player has a limited set of moves and can move their position through executing the move system. + +## Getting started + +```sh +# Build the world +sozo build + +# Migrate the world +sozo migrate + +# Get the class hash of the Moves model by name +sozo model class-hash Moves --world 0x33ac2f528bb97cc7b79148fd1756dc368be0e95d391d8c6d6473ecb60b4560e +> 0x64495ca6dc1dc328972697b30468cea364bcb7452bbb6e4aaad3e4b3f190147 + +# Get the schema of the Moves model +sozo model schema Moves --world 0x33ac2f528bb97cc7b79148fd1756dc368be0e95d391d8c6d6473ecb60b4560e +> struct Moves { +> #[key] +> player: ContractAddress, +> remaining: u8, +> last_direction: Direction = Invalid Option, +> } +> +> enum Direction { +> None +> Left +> Right +> Up +> Down +> } + +# Get the value of the Moves model for an entity. (in this example, +# 0x6162896d1d7ab204c7ccac6dd5f8e9e7c25ecd5ae4fcb4ad32e57786bb46e03, is +# the calling account which is also the key to retrieve a Moves model) +sozo model get Moves 0x6162896d1d7ab204c7ccac6dd5f8e9e7c25ecd5ae4fcb4ad32e57786bb46e03 --world 0x33ac2f528bb97cc7b79148fd1756dc368be0e95d391d8c6d6473ecb60b4560e +> struct Moves { +> #[key] +> player: ContractAddress = 0x6162896d1d7ab204c7ccac6dd5f8e9e7c25ecd5ae4fcb4ad32e57786bb46e03, +> remaining: u8 = 0, +> last_direction: Direction = None, +> } + +# The returned value is 0 since we haven't spawned yet. +# We can spawn a player using the actions contract address. +sozo execute 0x152dcff993befafe5001975149d2c50bd9621da7cbaed74f68e7d5e54e65abc spawn + +# Fetch the updated entity. +sozo model get Moves 0x6162896d1d7ab204c7ccac6dd5f8e9e7c25ecd5ae4fcb4ad32e57786bb46e03 --world 0x33ac2f528bb97cc7b79148fd1756dc368be0e95d391d8c6d6473ecb60b4560e +> struct Moves { +> #[key] +> player: ContractAddress = 0x6162896d1d7ab204c7ccac6dd5f8e9e7c25ecd5ae4fcb4ad32e57786bb46e03, +> remaining: u8 = 1, +> last_direction: Direction = None, +> } +> +> enum Direction { +> None +> Left +> Right +> Up +> Down +> } +``` diff --git a/examples/spawn-and-move/Scarb.lock b/examples/spawn-and-move/Scarb.lock new file mode 100644 index 0000000..8d95782 --- /dev/null +++ b/examples/spawn-and-move/Scarb.lock @@ -0,0 +1,29 @@ +# Code generated by scarb DO NOT EDIT. +version = 1 + +[[package]] +name = "armory" +version = "0.1.0" +dependencies = [ + "dojo", +] + +[[package]] +name = "bestiary" +version = "0.1.0" +dependencies = [ + "dojo", +] + +[[package]] +name = "dojo" +version = "1.0.0-rc.1" + +[[package]] +name = "dojo_examples" +version = "1.0.0-alpha.8" +dependencies = [ + "armory", + "bestiary", + "dojo", +] diff --git a/examples/spawn-and-move/Scarb.toml b/examples/spawn-and-move/Scarb.toml new file mode 100644 index 0000000..a4b6808 --- /dev/null +++ b/examples/spawn-and-move/Scarb.toml @@ -0,0 +1,24 @@ +[package] +cairo-version = "=2.7.1" +name = "dojo_examples" +version = "1.0.0-rc1" +# Use the prelude with the less imports as possible +# from corelib. +edition = "2024_07" + +[cairo] +sierra-replace-ids = true + +[dependencies] +armory = { path = "../game-lib/armory" } +bestiary = { path = "../game-lib/bestiary" } +dojo = { path = "../../crates/contracts" } + +[[target.dojo]] +build-external-contracts = [ "armory::Flatbow", "bestiary::RiverSkale" ] + +[features] +default = [ "dungeon" ] +dungeon = [ ] + +[profile.saya] diff --git a/examples/spawn-and-move/assets/cover.png b/examples/spawn-and-move/assets/cover.png new file mode 100644 index 0000000..8ac043f Binary files /dev/null and b/examples/spawn-and-move/assets/cover.png differ diff --git a/examples/spawn-and-move/assets/icon.png b/examples/spawn-and-move/assets/icon.png new file mode 100644 index 0000000..2169b56 Binary files /dev/null and b/examples/spawn-and-move/assets/icon.png differ diff --git a/examples/spawn-and-move/dojo_dev.toml b/examples/spawn-and-move/dojo_dev.toml new file mode 100644 index 0000000..7f4b562 --- /dev/null +++ b/examples/spawn-and-move/dojo_dev.toml @@ -0,0 +1,23 @@ +[world] +description = "example world" +name = "example" +seed = "dojo_examples" + +[namespace] +default = "dojo_examples" +# remapping can be done at tag level, or for the whole namespace. +# In this example, `armory-Flatbow` model will belong to `dojo_examples_weapons` namespace, and all `bestiary` models will belong to the `dojo_examples_foes` namespace when compiled into `spawn-and-move`. +mappings = { "armory-Flatbow" = "dojo_examples_weapons", "bestiary" = "dojo_examples_foes" } + +[env] +rpc_url = "http://localhost:5050/" +# Default account for katana with seed = 0 +account_address = "0x6162896d1d7ab204c7ccac6dd5f8e9e7c25ecd5ae4fcb4ad32e57786bb46e03" +private_key = "0x1800000000300000180000000000030000000000003006001800006600" +world_address = "0x46c1fd10836a8426197bf412fc5f26ea10f11a8d5c61474407f03f82c096593" + +[fhihgiehghe] +a = "2" +b = "fhiehgf" + +[0-fheihfe-fehioooooo] diff --git a/examples/spawn-and-move/dojo_release.toml b/examples/spawn-and-move/dojo_release.toml new file mode 100644 index 0000000..053cc21 --- /dev/null +++ b/examples/spawn-and-move/dojo_release.toml @@ -0,0 +1,23 @@ +[world] +description = "example world" +name = "example" +seed = "dojo_examples" + +[namespace] +default = "dojo_examples" +# remapping can be done at tag level, or for the whole namespace. +# In this example, `armory-Flatbow` model will belong to `dojo_examples_weapons` namespace, and all `bestiary` models will belong to the `dojo_examples_foes` namespace when compiled into `spawn-and-move`. +mappings = { "armory-Flatbow" = "dojo_examples_weapons", "bestiary" = "dojo_examples_foes" } + +[env] +rpc_url = "http://localhost:5050/" +# Default account for katana with seed = 0 +account_address = "0x6162896d1d7ab204c7ccac6dd5f8e9e7c25ecd5ae4fcb4ad32e57786bb46e03" +private_key = "0x1800000000300000180000000000030000000000003006001800006600" +world_address = "0x577ff0295103774d1bedd597a1c5673670eea0bb2cdeba6b8205d79396825b3" + +[migration] +skip_contracts = [ + "dojo_examples::mock_token::mock_token", + "dojo_examples::models::mock_token", +] diff --git a/examples/spawn-and-move/src/actions.cairo b/examples/spawn-and-move/src/actions.cairo new file mode 100644 index 0000000..1bdb8cd --- /dev/null +++ b/examples/spawn-and-move/src/actions.cairo @@ -0,0 +1,304 @@ +use dojo_examples::models::{Direction, Position, PlayerItem}; + +#[dojo::interface] +pub trait IActions { + fn spawn(ref world: IWorldDispatcher); + fn move(ref world: IWorldDispatcher, direction: Direction); + fn set_player_config(ref world: IWorldDispatcher, name: ByteArray); + fn get_player_position(world: @IWorldDispatcher) -> Position; + fn update_player_name(ref world: IWorldDispatcher, name: ByteArray); + fn update_player_items(ref world: IWorldDispatcher, items: Array); + fn reset_player_config(ref world: IWorldDispatcher); + fn set_player_server_profile(ref world: IWorldDispatcher, server_id: u32, name: ByteArray); + fn set_models(ref world: IWorldDispatcher, seed: felt252, n_models: u32); + #[cfg(feature: 'dungeon')] + fn enter_dungeon(ref world: IWorldDispatcher, dungeon_address: starknet::ContractAddress); +} + +#[dojo::contract] +pub mod actions { + use super::IActions; + + use starknet::{ContractAddress, get_caller_address}; + use dojo_examples::models::{ + Position, Moves, Direction, Vec2, PlayerConfig, PlayerItem, ServerProfile, PositionStore, + MovesStore, MovesEntityStore, PlayerConfigStore, PlayerConfigEntityStore, + }; + use dojo_examples::utils::next_position; + + // Features can be used on modules, structs, trait and `use`. Not inside + // a function. + #[cfg(feature: 'dungeon')] + use dojo_examples::dungeon::{IDungeonDispatcher, IDungeonDispatcherTrait}; + #[cfg(feature: 'dungeon')] + use armory::Flatbow; + #[cfg(feature: 'dungeon')] + use bestiary::RiverSkale; + + #[derive(Copy, Drop, Serde)] + #[dojo::event] + #[dojo::model] + pub struct Moved { + #[key] + pub player: ContractAddress, + pub direction: Direction, + } + + // impl: implement functions specified in trait + #[abi(embed_v0)] + impl ActionsImpl of IActions { + // Set some models randomly. + fn set_models(ref world: IWorldDispatcher, seed: felt252, n_models: u32) { + let uint: u256 = seed.into(); + let prng: u32 = (uint % 4_294_967_000).try_into().unwrap(); + let byte: u8 = (uint % 255).try_into().unwrap(); + + let moves = Moves { + player: seed.try_into().unwrap(), remaining: byte, last_direction: Direction::None + }; + let position = Position { + player: seed.try_into().unwrap(), vec: Vec2 { x: prng, y: prng } + }; + let server_profile = ServerProfile { + player: seed.try_into().unwrap(), server_id: prng, name: "hello" + }; + let player_config = PlayerConfig { + player: seed.try_into().unwrap(), + name: "hello", + items: array![], + favorite_item: Option::None + }; + + if n_models == 4 { + set!(world, (moves, position, server_profile, player_config)); + } else if n_models == 3 { + set!(world, (moves, position, server_profile)); + } else if n_models == 2 { + set!(world, (moves, position)); + } else { + set!(world, (moves)); + } + } + + // ContractState is defined by system decorator expansion + fn spawn(ref world: IWorldDispatcher) { + let player = get_caller_address(); + self.set_default_position(player, world); + } + + fn move(ref world: IWorldDispatcher, direction: Direction) { + let player = get_caller_address(); + + // instead of using the `get!` macro, you can directly use + // the Store::get method + let mut position = PositionStore::get(world, player); + + // you can also get entity values by entity ID with the `EntityStore` trait. + // Note that it returns a `Entity` struct which contains + // model values and the entity ID. + let move_id = MovesStore::entity_id_from_keys(player); + let mut moves = MovesEntityStore::get(world, move_id); + + moves.remaining -= 1; + moves.last_direction = direction; + let next = next_position(position, direction); + + // instead of using the `set!` macro, you can directly use + // the Store::set method + next.set(world); + + // you can also update entity values by entity ID with the `EntityStore` + // trait. + moves.update(world); + + emit!(world, (Moved { player, direction })); + } + + fn set_player_config(ref world: IWorldDispatcher, name: ByteArray) { + let player = get_caller_address(); + + let items = array![ + PlayerItem { item_id: 1, quantity: 100, score: 150 }, + PlayerItem { item_id: 2, quantity: 50, score: -32 } + ]; + + let config = PlayerConfig { player, name, items, favorite_item: Option::Some(1), }; + + set!(world, (config)); + } + + fn reset_player_config(ref world: IWorldDispatcher) { + let player = get_caller_address(); + + let (position, moves) = get!(world, player, (Position, Moves)); + let config = PlayerConfigStore::get(world, player); + + delete!(world, (position, moves)); + config.delete(world); + + let (position, moves, config) = get!(world, player, (Position, Moves, PlayerConfig)); + + assert(moves.remaining == 0, 'bad remaining'); + assert(moves.last_direction == Direction::None, 'bad last direction'); + + assert(position.vec.x == 0, 'bad x'); + assert(position.vec.y == 0, 'bad y'); + + assert(config.items.len() == 0, 'bad items'); + assert(config.favorite_item == Option::Some(0), 'bad favorite item'); + let empty_string: ByteArray = ""; + assert(config.name == empty_string, 'bad name'); + } + + fn set_player_server_profile(ref world: IWorldDispatcher, server_id: u32, name: ByteArray) { + let player = get_caller_address(); + set!(world, ServerProfile { player, server_id, name }); + } + + fn get_player_position(world: @IWorldDispatcher) -> Position { + let player = get_caller_address(); + get!(world, player, (Position)) + } + + #[cfg(feature: 'dungeon')] + fn enter_dungeon(ref world: IWorldDispatcher, dungeon_address: ContractAddress) { + let flatbow = Flatbow { id: 1, atk_speek: 2, range: 1 }; + let river_skale = RiverSkale { id: 1, health: 5, armor: 3, attack: 2 }; + + set!(world, (flatbow, river_skale)); + IDungeonDispatcher { contract_address: dungeon_address }.enter(); + } + + fn update_player_name(ref world: IWorldDispatcher, name: ByteArray) { + let player = get_caller_address(); + let config = PlayerConfigStore::get(world, player); + config.set_name(world, name.clone()); + + let new_name = PlayerConfigStore::get_name(world, player); + assert(new_name == name, 'unable to change name'); + } + + fn update_player_items(ref world: IWorldDispatcher, items: Array) { + let player = get_caller_address(); + let config_id = PlayerConfigStore::entity_id_from_keys(player); + + let items_clone = items.clone(); + + let config = PlayerConfigEntityStore::get(world, config_id); + config.set_items(world, items); + + let new_items = PlayerConfigEntityStore::get_items(world, config_id); + let mut size = items_clone.len(); + + while size > 0 { + assert(new_items.at(size - 1) == items_clone.at(size - 1), 'item not found'); + size -= 1; + } + } + } + + // The `generate_trait` attribute is not compatible with `world` parameter expansion. + // Hence, the use of `self` to access the contract state. + #[generate_trait] + impl InternalImpl of InternalUtils { + fn set_default_position( + self: @ContractState, player: ContractAddress, world: IWorldDispatcher + ) { + // The world is always accessible from `self` inside a `dojo::contract`. + // let world = self.world(); + + set!( + world, + ( + Moves { player, remaining: 99, last_direction: Direction::None }, + Position { player, vec: Vec2 { x: 10, y: 10 } }, + ) + ); + } + } +} + +#[cfg(test)] +mod tests { + use dojo::model::{Model, ModelTest, ModelIndex, ModelEntityTest}; + use dojo::world::{IWorldDispatcher, IWorldDispatcherTrait}; + + use dojo::utils::test::deploy_contract; + + use super::{actions, IActionsDispatcher, IActionsDispatcherTrait}; + use armory::flatbow; + use dojo_examples::models::{ + Position, position, PositionStore, PositionEntityStore, Moves, moves, Direction, Vec2 + }; + + #[test] + fn test_world_test_set() { + let caller = starknet::contract_address_const::<0x0>(); + + let world = spawn_test_world!(); + + // Without having the permission, we can set data into the dojo database for the given + // models. + let mut position = PositionStore::get(world, caller); + assert(position.vec.x == 0 && position.vec.y == 0, 'bad x'); + + position.vec.x = 122; + // `set_test` and `delete_test` are available on `Model`. + // `update_test` and `delete_test` are available on `ModelEntity`. + position.set_test(world); + + let id = PositionStore::entity_id_from_keys(caller); + let mut position = PositionEntityStore::get(world, id); + assert(position.vec.x == 122, 'bad x'); + + position.vec.y = 88; + position.update_test(world); + + let mut position = PositionStore::get(world, caller); + assert(position.vec.y == 88, 'bad y'); + + position.delete_test(world); + + let position = PositionStore::get(world, caller); + assert(position.vec.x == 0 && position.vec.y == 0, 'bad delete'); + } + + #[test] + #[available_gas(30000000)] + fn test_move() { + let caller = starknet::contract_address_const::<0x0>(); + + // deploy world with only the models for the given namespaces. + let world = spawn_test_world!(["dojo_examples", "dojo_examples_weapons"]); + + // deploy systems contract + let contract_address = world + .deploy_contract('salt', actions::TEST_CLASS_HASH.try_into().unwrap()); + let actions_system = IActionsDispatcher { contract_address }; + + // set authorizations + world.grant_writer(Model::::selector(), contract_address); + world.grant_writer(Model::::selector(), contract_address); + + // System calls + actions_system.spawn(); + let initial_moves = get!(world, caller, Moves); + let initial_position = get!(world, caller, Position); + + assert( + initial_position.vec.x == 10 && initial_position.vec.y == 10, 'wrong initial position' + ); + + actions_system.move(Direction::Right(())); + + let moves = get!(world, caller, Moves); + let right_dir_felt: felt252 = Direction::Right(()).into(); + + assert(moves.remaining == initial_moves.remaining - 1, 'moves is wrong'); + assert(moves.last_direction.into() == right_dir_felt, 'last direction is wrong'); + + let new_position = get!(world, caller, Position); + assert(new_position.vec.x == initial_position.vec.x + 1, 'position x is wrong'); + assert(new_position.vec.y == initial_position.vec.y, 'position y is wrong'); + } +} diff --git a/examples/spawn-and-move/src/dungeon.cairo b/examples/spawn-and-move/src/dungeon.cairo new file mode 100644 index 0000000..474f88b --- /dev/null +++ b/examples/spawn-and-move/src/dungeon.cairo @@ -0,0 +1,12 @@ +#[dojo::interface] +pub trait IDungeon { + fn enter(); +} + +#[dojo::contract] +pub mod dungeon { + #[abi(embed_v0)] + pub impl IDungeonImpl of super::IDungeon { + fn enter() {} + } +} diff --git a/examples/spawn-and-move/src/lib.cairo b/examples/spawn-and-move/src/lib.cairo new file mode 100644 index 0000000..c3f2f56 --- /dev/null +++ b/examples/spawn-and-move/src/lib.cairo @@ -0,0 +1,7 @@ +pub mod actions; +pub mod models; +pub mod utils; +pub mod others; +pub mod mock_token; +#[cfg(feature: 'dungeon')] +pub mod dungeon; diff --git a/examples/spawn-and-move/src/lib.rs b/examples/spawn-and-move/src/lib.rs new file mode 100644 index 0000000..4199cce --- /dev/null +++ b/examples/spawn-and-move/src/lib.rs @@ -0,0 +1 @@ +// Placeholder so we can use `cargo release` to update Scarb.toml diff --git a/examples/spawn-and-move/src/mock_token.cairo b/examples/spawn-and-move/src/mock_token.cairo new file mode 100644 index 0000000..1d0174e --- /dev/null +++ b/examples/spawn-and-move/src/mock_token.cairo @@ -0,0 +1,10 @@ +#[dojo::contract] +pub mod mock_token { + use dojo_examples::models::{MockToken}; + use starknet::{ContractAddress, get_caller_address}; + + fn dojo_init(world: @IWorldDispatcher) { + let account: ContractAddress = get_caller_address(); + set!(world, MockToken { account, amount: 1000 }); + } +} diff --git a/examples/spawn-and-move/src/models.cairo b/examples/spawn-and-move/src/models.cairo new file mode 100644 index 0000000..094ec84 --- /dev/null +++ b/examples/spawn-and-move/src/models.cairo @@ -0,0 +1,134 @@ +use starknet::ContractAddress; + +#[derive(Serde, Copy, Drop, Introspect, PartialEq, Debug)] +pub enum Direction { + None, + Left, + Right, + Up, + Down, +} + +impl DirectionIntoFelt252 of Into { + fn into(self: Direction) -> felt252 { + match self { + Direction::None => 0, + Direction::Left => 1, + Direction::Right => 2, + Direction::Up => 3, + Direction::Down => 4, + } + } +} + +#[derive(Drop, Serde)] +#[dojo::model] +pub struct Message { + #[key] + pub identity: ContractAddress, + #[key] + pub channel: felt252, + pub message: ByteArray, + #[key] + pub salt: felt252 +} + +#[derive(Copy, Drop, Serde, Debug)] +#[dojo::model] +pub struct Moves { + #[key] + pub player: ContractAddress, + pub remaining: u8, + pub last_direction: Direction +} + +#[derive(Copy, Drop, Serde, Debug)] +#[dojo::model] +pub struct MockToken { + #[key] + pub account: ContractAddress, + pub amount: u128, +} + +#[derive(Copy, Drop, Serde, IntrospectPacked, Debug)] +pub struct Vec2 { + pub x: u32, + pub y: u32 +} + +// If `Vec2` wasn't packed, the `Position` would be invalid, +// and a runtime error would be thrown. +// Any field that is a custom type into a `IntrospectPacked` type +// must be packed. +#[derive(Copy, Drop, Serde, IntrospectPacked, Debug)] +#[dojo::model] +pub struct Position { + #[key] + pub player: ContractAddress, + pub vec: Vec2, +} + +// Every field inside a model must derive `Introspect` or `IntrospectPacked`. +// `IntrospectPacked` can also be used into models that are only using `Introspect`. +#[derive(Copy, Drop, Serde, Introspect, PartialEq)] +pub struct PlayerItem { + pub item_id: u32, + pub quantity: u32, + pub score: i32, +} + +#[derive(Drop, Serde)] +#[dojo::model] +pub struct PlayerConfig { + #[key] + pub player: ContractAddress, + pub name: ByteArray, + pub items: Array, + pub favorite_item: Option, +} + +#[derive(Drop, Serde)] +#[dojo::model] +pub struct ServerProfile { + #[key] + pub player: ContractAddress, + #[key] + pub server_id: u32, + pub name: ByteArray, +} + +trait Vec2Trait { + fn is_zero(self: Vec2) -> bool; + fn is_equal(self: Vec2, b: Vec2) -> bool; +} + +impl Vec2Impl of Vec2Trait { + fn is_zero(self: Vec2) -> bool { + if self.x - self.y == 0 { + return true; + } + false + } + + fn is_equal(self: Vec2, b: Vec2) -> bool { + self.x == b.x && self.y == b.y + } +} + +#[cfg(test)] +mod tests { + use super::{Position, Vec2, Vec2Trait}; + + #[test] + #[available_gas(100000)] + fn test_vec_is_zero() { + assert(Vec2Trait::is_zero(Vec2 { x: 0, y: 0 }), 'not zero'); + } + + #[test] + #[available_gas(100000)] + fn test_vec_is_equal() { + let position = Vec2 { x: 420, y: 0 }; + assert(position.is_equal(Vec2 { x: 420, y: 0 }), 'not equal'); + } +} diff --git a/examples/spawn-and-move/src/others.cairo b/examples/spawn-and-move/src/others.cairo new file mode 100644 index 0000000..8b9c1a9 --- /dev/null +++ b/examples/spawn-and-move/src/others.cairo @@ -0,0 +1,31 @@ +#[dojo::contract] +pub mod others { + use starknet::{ContractAddress, ClassHash, get_caller_address}; + use dojo_examples::models::{Position, Moves, Direction, Vec2}; + use dojo_examples::utils::next_position; + + #[derive(Copy, Drop, Serde)] + #[dojo::event] + #[dojo::model] + struct ContractInitialized { + #[key] + contract_address: ContractAddress, + contract_class: ClassHash, + value: u8, + } + + + fn dojo_init( + world: @IWorldDispatcher, + actions_address: ContractAddress, + actions_class: ClassHash, + value: u8 + ) { + emit!( + world, + ContractInitialized { + contract_address: actions_address, contract_class: actions_class, value + } + ); + } +} diff --git a/examples/spawn-and-move/src/utils.cairo b/examples/spawn-and-move/src/utils.cairo new file mode 100644 index 0000000..60d2bb8 --- /dev/null +++ b/examples/spawn-and-move/src/utils.cairo @@ -0,0 +1,12 @@ +use dojo_examples::models::{Position, Direction}; + +pub fn next_position(mut position: Position, direction: Direction) -> Position { + match direction { + Direction::None => { return position; }, + Direction::Left => { position.vec.x -= 1; }, + Direction::Right => { position.vec.x += 1; }, + Direction::Up => { position.vec.y -= 1; }, + Direction::Down => { position.vec.y += 1; }, + }; + position +} diff --git a/rust-toolchain.toml b/rust-toolchain.toml new file mode 100644 index 0000000..4d2dee8 --- /dev/null +++ b/rust-toolchain.toml @@ -0,0 +1,2 @@ +[toolchain] +channel = "1.80.0" diff --git a/scripts/rust_fmt.sh b/scripts/rust_fmt.sh new file mode 100755 index 0000000..db5636d --- /dev/null +++ b/scripts/rust_fmt.sh @@ -0,0 +1,3 @@ +#!/bin/bash + +cargo +nightly-2024-08-28 fmt --check --all -- "$@"