From f80c594f3d378dd0614c91266ede0b084a1c7f49 Mon Sep 17 00:00:00 2001 From: Xor0v0 Date: Tue, 15 Oct 2024 10:41:25 +0800 Subject: [PATCH] Add zkCTF wp --- .gitignore | 3 +- docs/crypto/2+2=5/two_plus_two.md | 5 + .../zkCTF/day1/Division Quiz/.gitignore | 5 + .../zkCTF/day1/Division Quiz/Cargo.toml | 14 + .../zkCTF/day1/Division Quiz/description.md | 20 + .../zkCTF/day1/Division Quiz/src/lib.rs | 1 + .../zkCTF/day1/Division Quiz/src/quiz.rs | 352 + docs/crypto/zkCTF/day1/Ethereal/README.md | 80 + .../.github/workflows/publish_web.yaml | 40 + .../day1/Ethereal/mint-client/.gitignore | 1 + .../day1/Ethereal/mint-client/abi/mint.json | 693 + .../day1/Ethereal/mint-client/blacksmith.go | 80 + .../zkCTF/day1/Ethereal/mint-client/go.mod | 38 + .../zkCTF/day1/Ethereal/mint-client/go.sum | 190 + .../zkCTF/day1/Ethereal/mint-client/main.go | 203 + .../day1/Ethereal/mint-client/mint/mint.go | 1221 ++ .../day1/Ethereal/mint-client/sword.json | 18 + .../day1/Ethereal/mint-client/types/types.go | 17 + .../Ethereal/mint-client/utils/transactor.go | 53 + .../mint-contracts/.github/workflows/test.yml | 34 + .../day1/Ethereal/mint-contracts/.gitignore | 14 + .../day1/Ethereal/mint-contracts/README.md | 66 + .../day1/Ethereal/mint-contracts/foundry.toml | 6 + .../lib/forge-std/.gitattributes | 1 + .../lib/forge-std/.github/workflows/ci.yml | 134 + .../lib/forge-std/.github/workflows/sync.yml | 29 + .../mint-contracts/lib/forge-std/.gitignore | 4 + .../mint-contracts/lib/forge-std/.gitmodules | 3 + .../lib/forge-std/LICENSE-APACHE | 203 + .../mint-contracts/lib/forge-std/LICENSE-MIT | 25 + .../mint-contracts/lib/forge-std/README.md | 250 + .../mint-contracts/lib/forge-std/foundry.toml | 21 + .../lib/ds-test/.github/workflows/build.yml | 41 + .../lib/forge-std/lib/ds-test/.gitignore | 4 + .../lib/forge-std/lib/ds-test/LICENSE | 674 + .../lib/forge-std/lib/ds-test/Makefile | 14 + .../lib/forge-std/lib/ds-test/default.nix | 4 + .../lib/forge-std/lib/ds-test/demo/demo.sol | 222 + .../lib/forge-std/lib/ds-test/package.json | 15 + .../lib/forge-std/lib/ds-test/src/test.sol | 592 + .../lib/forge-std/lib/ds-test/src/test.t.sol | 417 + .../mint-contracts/lib/forge-std/package.json | 16 + .../lib/forge-std/scripts/vm.py | 666 + .../mint-contracts/lib/forge-std/src/Base.sol | 35 + .../lib/forge-std/src/Script.sol | 27 + .../lib/forge-std/src/StdAssertions.sol | 376 + .../lib/forge-std/src/StdChains.sol | 248 + .../lib/forge-std/src/StdCheats.sol | 817 + .../lib/forge-std/src/StdError.sol | 15 + .../lib/forge-std/src/StdInvariant.sol | 107 + .../lib/forge-std/src/StdJson.sol | 183 + .../lib/forge-std/src/StdMath.sol | 43 + .../lib/forge-std/src/StdStorage.sol | 378 + .../lib/forge-std/src/StdStyle.sol | 333 + .../lib/forge-std/src/StdUtils.sol | 226 + .../mint-contracts/lib/forge-std/src/Test.sol | 33 + .../mint-contracts/lib/forge-std/src/Vm.sol | 1096 ++ .../lib/forge-std/src/console.sol | 1533 ++ .../lib/forge-std/src/console2.sol | 1558 ++ .../lib/forge-std/src/interfaces/IERC1155.sol | 105 + .../lib/forge-std/src/interfaces/IERC165.sol | 12 + .../lib/forge-std/src/interfaces/IERC20.sol | 43 + .../lib/forge-std/src/interfaces/IERC4626.sol | 190 + .../lib/forge-std/src/interfaces/IERC721.sol | 164 + .../forge-std/src/interfaces/IMulticall3.sol | 73 + .../lib/forge-std/src/mocks/MockERC20.sol | 216 + .../lib/forge-std/src/mocks/MockERC721.sol | 221 + .../lib/forge-std/src/safeconsole.sol | 13248 ++++++++++++++++ .../lib/forge-std/test/StdAssertions.t.sol | 1015 ++ .../lib/forge-std/test/StdChains.t.sol | 216 + .../lib/forge-std/test/StdCheats.t.sol | 610 + .../lib/forge-std/test/StdError.t.sol | 120 + .../lib/forge-std/test/StdMath.t.sol | 212 + .../lib/forge-std/test/StdStorage.t.sol | 315 + .../lib/forge-std/test/StdStyle.t.sol | 110 + .../lib/forge-std/test/StdUtils.t.sol | 342 + .../lib/forge-std/test/Vm.t.sol | 15 + .../test/compilation/CompilationScript.sol | 10 + .../compilation/CompilationScriptBase.sol | 10 + .../test/compilation/CompilationTest.sol | 10 + .../test/compilation/CompilationTestBase.sol | 10 + .../test/fixtures/broadcast.log.json | 187 + .../lib/forge-std/test/mocks/MockERC20.t.sol | 441 + .../lib/forge-std/test/mocks/MockERC721.t.sol | 721 + .../mint-contracts/script/Counter.s.sol | 12 + .../Ethereal/mint-contracts/src/Constants.sol | 72 + .../mint-contracts/src/KZGVerifier.sol | 198 + .../Ethereal/mint-contracts/src/MintGem.sol | 95 + .../Ethereal/mint-contracts/src/Pairing.sol | 122 + .../mint-contracts/test/MintNFT.t.sol | 29 + docs/crypto/zkCTF/day1/Kid Math/.gitignore | 1 + docs/crypto/zkCTF/day1/Kid Math/Cargo.lock | 1932 +++ docs/crypto/zkCTF/day1/Kid Math/Cargo.toml | 22 + .../crypto/zkCTF/day1/Kid Math/description.md | 15 + docs/crypto/zkCTF/day1/Kid Math/src/fib.rs | 271 + docs/crypto/zkCTF/day1/Kid Math/src/lib.rs | 1 + .../day1/Roundabout/Circom/Roundabout.circom | 319 + .../Roundabout/Circom/Roundabout_groth16.zkey | Bin 0 -> 3068 bytes .../day1/Roundabout/Contract/verifier.sol | 191 + .../zkCTF/day1/Roundabout/description.md | 3 + docs/crypto/zkCTF/day2/Is Zero/.gitignore | 5 + docs/crypto/zkCTF/day2/Is Zero/Cargo.toml | 14 + docs/crypto/zkCTF/day2/Is Zero/description.md | 22 + docs/crypto/zkCTF/day2/Is Zero/src/is_zero.rs | 229 + docs/crypto/zkCTF/day2/Is Zero/src/lib.rs | 1 + docs/crypto/zkCTF/day2/Mixer/Challenge.sol | 16 + .../crypto/zkCTF/day2/Mixer/MerkleTreeLib.sol | 119 + docs/crypto/zkCTF/day2/Mixer/Mixer.sol | 84 + docs/crypto/zkCTF/day2/Mixer/PoseidonT3.sol | 1372 ++ docs/crypto/zkCTF/day2/Mixer/Verifier.sol | 132 + .../zkCTF/day2/Mixer/interfaces/IMixer.sol | 34 + .../day2/Mixer/interfaces/IPoseidonT3.sol | 6 + .../zkCTF/day2/Mixer/interfaces/IVerifier.sol | 13 + .../What a Waste/Circuit/Round 2 Seed.txt | 1 + .../day2/What a Waste/Circuit/locker.circom | 13 + .../Circuit/locker_plonk_or_groth16.zkey | Bin 0 -> 2624 bytes .../day2/What a Waste/Contract/verifier.sol | 192 + .../zkCTF/day2/familiar_strangers/README.md | 139 + .../circuits/challenge.circom | 31 + .../day2/familiar_strangers/package-lock.json | 2166 +++ .../day2/familiar_strangers/package.json | 17 + .../day2/familiar_strangers/stranger_judge.js | 64 + .../test/level1_test.circom | 5 + .../test/level2_test.circom | 5 + docs/crypto/zkCTF/imgs/feistel.png | Bin 0 -> 262324 bytes docs/crypto/zkCTF/zkCTF.md | 379 + mkdocs.yml | 2 + 127 files changed, 40456 insertions(+), 1 deletion(-) create mode 100644 docs/crypto/zkCTF/day1/Division Quiz/.gitignore create mode 100644 docs/crypto/zkCTF/day1/Division Quiz/Cargo.toml create mode 100644 docs/crypto/zkCTF/day1/Division Quiz/description.md create mode 100644 docs/crypto/zkCTF/day1/Division Quiz/src/lib.rs create mode 100644 docs/crypto/zkCTF/day1/Division Quiz/src/quiz.rs create mode 100644 docs/crypto/zkCTF/day1/Ethereal/README.md create mode 100644 docs/crypto/zkCTF/day1/Ethereal/mint-client/.github/workflows/publish_web.yaml create mode 100644 docs/crypto/zkCTF/day1/Ethereal/mint-client/.gitignore create mode 100644 docs/crypto/zkCTF/day1/Ethereal/mint-client/abi/mint.json create mode 100644 docs/crypto/zkCTF/day1/Ethereal/mint-client/blacksmith.go create mode 100644 docs/crypto/zkCTF/day1/Ethereal/mint-client/go.mod create mode 100644 docs/crypto/zkCTF/day1/Ethereal/mint-client/go.sum create mode 100644 docs/crypto/zkCTF/day1/Ethereal/mint-client/main.go create mode 100644 docs/crypto/zkCTF/day1/Ethereal/mint-client/mint/mint.go create mode 100644 docs/crypto/zkCTF/day1/Ethereal/mint-client/sword.json create mode 100644 docs/crypto/zkCTF/day1/Ethereal/mint-client/types/types.go create mode 100644 docs/crypto/zkCTF/day1/Ethereal/mint-client/utils/transactor.go create mode 100644 docs/crypto/zkCTF/day1/Ethereal/mint-contracts/.github/workflows/test.yml create mode 100644 docs/crypto/zkCTF/day1/Ethereal/mint-contracts/.gitignore create mode 100644 docs/crypto/zkCTF/day1/Ethereal/mint-contracts/README.md create mode 100644 docs/crypto/zkCTF/day1/Ethereal/mint-contracts/foundry.toml create mode 100644 docs/crypto/zkCTF/day1/Ethereal/mint-contracts/lib/forge-std/.gitattributes create mode 100644 docs/crypto/zkCTF/day1/Ethereal/mint-contracts/lib/forge-std/.github/workflows/ci.yml create mode 100644 docs/crypto/zkCTF/day1/Ethereal/mint-contracts/lib/forge-std/.github/workflows/sync.yml create mode 100644 docs/crypto/zkCTF/day1/Ethereal/mint-contracts/lib/forge-std/.gitignore create mode 100644 docs/crypto/zkCTF/day1/Ethereal/mint-contracts/lib/forge-std/.gitmodules create mode 100644 docs/crypto/zkCTF/day1/Ethereal/mint-contracts/lib/forge-std/LICENSE-APACHE create mode 100644 docs/crypto/zkCTF/day1/Ethereal/mint-contracts/lib/forge-std/LICENSE-MIT create mode 100644 docs/crypto/zkCTF/day1/Ethereal/mint-contracts/lib/forge-std/README.md create mode 100644 docs/crypto/zkCTF/day1/Ethereal/mint-contracts/lib/forge-std/foundry.toml create mode 100644 docs/crypto/zkCTF/day1/Ethereal/mint-contracts/lib/forge-std/lib/ds-test/.github/workflows/build.yml create mode 100644 docs/crypto/zkCTF/day1/Ethereal/mint-contracts/lib/forge-std/lib/ds-test/.gitignore create mode 100644 docs/crypto/zkCTF/day1/Ethereal/mint-contracts/lib/forge-std/lib/ds-test/LICENSE create mode 100644 docs/crypto/zkCTF/day1/Ethereal/mint-contracts/lib/forge-std/lib/ds-test/Makefile create mode 100644 docs/crypto/zkCTF/day1/Ethereal/mint-contracts/lib/forge-std/lib/ds-test/default.nix create mode 100644 docs/crypto/zkCTF/day1/Ethereal/mint-contracts/lib/forge-std/lib/ds-test/demo/demo.sol create mode 100644 docs/crypto/zkCTF/day1/Ethereal/mint-contracts/lib/forge-std/lib/ds-test/package.json create mode 100644 docs/crypto/zkCTF/day1/Ethereal/mint-contracts/lib/forge-std/lib/ds-test/src/test.sol create mode 100644 docs/crypto/zkCTF/day1/Ethereal/mint-contracts/lib/forge-std/lib/ds-test/src/test.t.sol create mode 100644 docs/crypto/zkCTF/day1/Ethereal/mint-contracts/lib/forge-std/package.json create mode 100644 docs/crypto/zkCTF/day1/Ethereal/mint-contracts/lib/forge-std/scripts/vm.py create mode 100644 docs/crypto/zkCTF/day1/Ethereal/mint-contracts/lib/forge-std/src/Base.sol create mode 100644 docs/crypto/zkCTF/day1/Ethereal/mint-contracts/lib/forge-std/src/Script.sol create mode 100644 docs/crypto/zkCTF/day1/Ethereal/mint-contracts/lib/forge-std/src/StdAssertions.sol create mode 100644 docs/crypto/zkCTF/day1/Ethereal/mint-contracts/lib/forge-std/src/StdChains.sol create mode 100644 docs/crypto/zkCTF/day1/Ethereal/mint-contracts/lib/forge-std/src/StdCheats.sol create mode 100644 docs/crypto/zkCTF/day1/Ethereal/mint-contracts/lib/forge-std/src/StdError.sol create mode 100644 docs/crypto/zkCTF/day1/Ethereal/mint-contracts/lib/forge-std/src/StdInvariant.sol create mode 100644 docs/crypto/zkCTF/day1/Ethereal/mint-contracts/lib/forge-std/src/StdJson.sol create mode 100644 docs/crypto/zkCTF/day1/Ethereal/mint-contracts/lib/forge-std/src/StdMath.sol create mode 100644 docs/crypto/zkCTF/day1/Ethereal/mint-contracts/lib/forge-std/src/StdStorage.sol create mode 100644 docs/crypto/zkCTF/day1/Ethereal/mint-contracts/lib/forge-std/src/StdStyle.sol create mode 100644 docs/crypto/zkCTF/day1/Ethereal/mint-contracts/lib/forge-std/src/StdUtils.sol create mode 100644 docs/crypto/zkCTF/day1/Ethereal/mint-contracts/lib/forge-std/src/Test.sol create mode 100644 docs/crypto/zkCTF/day1/Ethereal/mint-contracts/lib/forge-std/src/Vm.sol create mode 100644 docs/crypto/zkCTF/day1/Ethereal/mint-contracts/lib/forge-std/src/console.sol create mode 100644 docs/crypto/zkCTF/day1/Ethereal/mint-contracts/lib/forge-std/src/console2.sol create mode 100644 docs/crypto/zkCTF/day1/Ethereal/mint-contracts/lib/forge-std/src/interfaces/IERC1155.sol create mode 100644 docs/crypto/zkCTF/day1/Ethereal/mint-contracts/lib/forge-std/src/interfaces/IERC165.sol create mode 100644 docs/crypto/zkCTF/day1/Ethereal/mint-contracts/lib/forge-std/src/interfaces/IERC20.sol create mode 100644 docs/crypto/zkCTF/day1/Ethereal/mint-contracts/lib/forge-std/src/interfaces/IERC4626.sol create mode 100644 docs/crypto/zkCTF/day1/Ethereal/mint-contracts/lib/forge-std/src/interfaces/IERC721.sol create mode 100644 docs/crypto/zkCTF/day1/Ethereal/mint-contracts/lib/forge-std/src/interfaces/IMulticall3.sol create mode 100644 docs/crypto/zkCTF/day1/Ethereal/mint-contracts/lib/forge-std/src/mocks/MockERC20.sol create mode 100644 docs/crypto/zkCTF/day1/Ethereal/mint-contracts/lib/forge-std/src/mocks/MockERC721.sol create mode 100644 docs/crypto/zkCTF/day1/Ethereal/mint-contracts/lib/forge-std/src/safeconsole.sol create mode 100644 docs/crypto/zkCTF/day1/Ethereal/mint-contracts/lib/forge-std/test/StdAssertions.t.sol create mode 100644 docs/crypto/zkCTF/day1/Ethereal/mint-contracts/lib/forge-std/test/StdChains.t.sol create mode 100644 docs/crypto/zkCTF/day1/Ethereal/mint-contracts/lib/forge-std/test/StdCheats.t.sol create mode 100644 docs/crypto/zkCTF/day1/Ethereal/mint-contracts/lib/forge-std/test/StdError.t.sol create mode 100644 docs/crypto/zkCTF/day1/Ethereal/mint-contracts/lib/forge-std/test/StdMath.t.sol create mode 100644 docs/crypto/zkCTF/day1/Ethereal/mint-contracts/lib/forge-std/test/StdStorage.t.sol create mode 100644 docs/crypto/zkCTF/day1/Ethereal/mint-contracts/lib/forge-std/test/StdStyle.t.sol create mode 100644 docs/crypto/zkCTF/day1/Ethereal/mint-contracts/lib/forge-std/test/StdUtils.t.sol create mode 100644 docs/crypto/zkCTF/day1/Ethereal/mint-contracts/lib/forge-std/test/Vm.t.sol create mode 100644 docs/crypto/zkCTF/day1/Ethereal/mint-contracts/lib/forge-std/test/compilation/CompilationScript.sol create mode 100644 docs/crypto/zkCTF/day1/Ethereal/mint-contracts/lib/forge-std/test/compilation/CompilationScriptBase.sol create mode 100644 docs/crypto/zkCTF/day1/Ethereal/mint-contracts/lib/forge-std/test/compilation/CompilationTest.sol create mode 100644 docs/crypto/zkCTF/day1/Ethereal/mint-contracts/lib/forge-std/test/compilation/CompilationTestBase.sol create mode 100644 docs/crypto/zkCTF/day1/Ethereal/mint-contracts/lib/forge-std/test/fixtures/broadcast.log.json create mode 100644 docs/crypto/zkCTF/day1/Ethereal/mint-contracts/lib/forge-std/test/mocks/MockERC20.t.sol create mode 100644 docs/crypto/zkCTF/day1/Ethereal/mint-contracts/lib/forge-std/test/mocks/MockERC721.t.sol create mode 100644 docs/crypto/zkCTF/day1/Ethereal/mint-contracts/script/Counter.s.sol create mode 100644 docs/crypto/zkCTF/day1/Ethereal/mint-contracts/src/Constants.sol create mode 100644 docs/crypto/zkCTF/day1/Ethereal/mint-contracts/src/KZGVerifier.sol create mode 100644 docs/crypto/zkCTF/day1/Ethereal/mint-contracts/src/MintGem.sol create mode 100644 docs/crypto/zkCTF/day1/Ethereal/mint-contracts/src/Pairing.sol create mode 100644 docs/crypto/zkCTF/day1/Ethereal/mint-contracts/test/MintNFT.t.sol create mode 100644 docs/crypto/zkCTF/day1/Kid Math/.gitignore create mode 100644 docs/crypto/zkCTF/day1/Kid Math/Cargo.lock create mode 100644 docs/crypto/zkCTF/day1/Kid Math/Cargo.toml create mode 100644 docs/crypto/zkCTF/day1/Kid Math/description.md create mode 100644 docs/crypto/zkCTF/day1/Kid Math/src/fib.rs create mode 100644 docs/crypto/zkCTF/day1/Kid Math/src/lib.rs create mode 100644 docs/crypto/zkCTF/day1/Roundabout/Circom/Roundabout.circom create mode 100644 docs/crypto/zkCTF/day1/Roundabout/Circom/Roundabout_groth16.zkey create mode 100644 docs/crypto/zkCTF/day1/Roundabout/Contract/verifier.sol create mode 100644 docs/crypto/zkCTF/day1/Roundabout/description.md create mode 100644 docs/crypto/zkCTF/day2/Is Zero/.gitignore create mode 100644 docs/crypto/zkCTF/day2/Is Zero/Cargo.toml create mode 100644 docs/crypto/zkCTF/day2/Is Zero/description.md create mode 100644 docs/crypto/zkCTF/day2/Is Zero/src/is_zero.rs create mode 100644 docs/crypto/zkCTF/day2/Is Zero/src/lib.rs create mode 100644 docs/crypto/zkCTF/day2/Mixer/Challenge.sol create mode 100644 docs/crypto/zkCTF/day2/Mixer/MerkleTreeLib.sol create mode 100644 docs/crypto/zkCTF/day2/Mixer/Mixer.sol create mode 100644 docs/crypto/zkCTF/day2/Mixer/PoseidonT3.sol create mode 100644 docs/crypto/zkCTF/day2/Mixer/Verifier.sol create mode 100644 docs/crypto/zkCTF/day2/Mixer/interfaces/IMixer.sol create mode 100644 docs/crypto/zkCTF/day2/Mixer/interfaces/IPoseidonT3.sol create mode 100644 docs/crypto/zkCTF/day2/Mixer/interfaces/IVerifier.sol create mode 100644 docs/crypto/zkCTF/day2/What a Waste/Circuit/Round 2 Seed.txt create mode 100644 docs/crypto/zkCTF/day2/What a Waste/Circuit/locker.circom create mode 100644 docs/crypto/zkCTF/day2/What a Waste/Circuit/locker_plonk_or_groth16.zkey create mode 100644 docs/crypto/zkCTF/day2/What a Waste/Contract/verifier.sol create mode 100644 docs/crypto/zkCTF/day2/familiar_strangers/README.md create mode 100644 docs/crypto/zkCTF/day2/familiar_strangers/circuits/challenge.circom create mode 100644 docs/crypto/zkCTF/day2/familiar_strangers/package-lock.json create mode 100644 docs/crypto/zkCTF/day2/familiar_strangers/package.json create mode 100644 docs/crypto/zkCTF/day2/familiar_strangers/stranger_judge.js create mode 100644 docs/crypto/zkCTF/day2/familiar_strangers/test/level1_test.circom create mode 100644 docs/crypto/zkCTF/day2/familiar_strangers/test/level2_test.circom create mode 100644 docs/crypto/zkCTF/imgs/feistel.png create mode 100644 docs/crypto/zkCTF/zkCTF.md diff --git a/.gitignore b/.gitignore index d97e100..d1173b4 100644 --- a/.gitignore +++ b/.gitignore @@ -1 +1,2 @@ -site \ No newline at end of file +site +.DS_Store \ No newline at end of file diff --git a/docs/crypto/2+2=5/two_plus_two.md b/docs/crypto/2+2=5/two_plus_two.md index 8307b11..daa65ba 100644 --- a/docs/crypto/2+2=5/two_plus_two.md +++ b/docs/crypto/2+2=5/two_plus_two.md @@ -3,6 +3,11 @@ title: Jolt zkVM - 2+2=5 description: 2024 | MOCA Italian Hacker Camp | Crypto --- +- [1. Background](#1-background) +- [2. Puzzle Description](#2-puzzle-description) +- [3. Alynasis](#3-alynasis) +- [4. EXP](#4-exp) + ## 1. Background [Jolt](https://jolt.a16zcrypto.com/intro.html) 是由 A16Z 的密码学家们提出的一个针对 Risc-V ISA （未来将支持更多ISA）的 zkVM 框架，它底层使用了 sumcheck-based SNARK，这个 SNARK 充分利用多变量多项式及其多项式承诺的优势。Jolt zkVM 据说拥有非常出色的性能表现并且还存在优化空间。 diff --git a/docs/crypto/zkCTF/day1/Division Quiz/.gitignore b/docs/crypto/zkCTF/day1/Division Quiz/.gitignore new file mode 100644 index 0000000..5a580a2 --- /dev/null +++ b/docs/crypto/zkCTF/day1/Division Quiz/.gitignore @@ -0,0 +1,5 @@ +/target +Cargo.lock +param +proof +vk \ No newline at end of file diff --git a/docs/crypto/zkCTF/day1/Division Quiz/Cargo.toml b/docs/crypto/zkCTF/day1/Division Quiz/Cargo.toml new file mode 100644 index 0000000..1af55c3 --- /dev/null +++ b/docs/crypto/zkCTF/day1/Division Quiz/Cargo.toml @@ -0,0 +1,14 @@ +[package] +name = "cft" +version = "0.1.0" +edition = "2021" + +# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html + +[dependencies] +backtrace = { version = "0.3", optional = true } +ff = "0.13" +halo2_proofs = { git = "https://github.com/privacy-scaling-explorations/halo2.git", default-features = true } +clap = "3.0" +halo2curves = { version = "0.6.0", default-features = false } +rand = "0.8" diff --git a/docs/crypto/zkCTF/day1/Division Quiz/description.md b/docs/crypto/zkCTF/day1/Division Quiz/description.md new file mode 100644 index 0000000..bb6dd6a --- /dev/null +++ b/docs/crypto/zkCTF/day1/Division Quiz/description.md @@ -0,0 +1,20 @@ +# ZK CFT - Halo2 - Int Division + +## Overview +1. This is a quiz about Halo2 usage. The standard answer would not be given to participants +2. Instead, a file would be given, with all necessary structs and missing logics. Participants are required to fill in the blanks, compile the program and run tests +3. Multiple test cases would be given, the prover program shall be tested against them + +## Problem description +While doing proof we always face some basic arithematics, such as int division. It is a very intuitive operation on normal programming language, but one might find it a bit harder when doing it in crypto world -- for we always use [Finte Field](https://en.wikipedia.org/wiki/Finite_field). For each non-zero element, it has inverse, so that a normal int division is not obeying ordinary division just like Python. For example, in Fp where p = 11, 10 div 3 = 7 mod 11 -- for inverse of 3 is 4, 11 div 3 = 10 times 4 = 7 mod 11. While we expect an 'ordinary' int division: 10 // 3 = 3. Now you are required to simulate an int division in Halo2. We limit the size as U8. So you are actually implementing an U8 division in a finite file Fr, which is the scalar field of ecliptic curve group BN256. + +## Comand +cargo run + +## Example +Input 10 3 3 +Explain: Proof generates and verifier passes it. It is an U8 division + +## Solve +Sumbit quiz.rs to solve the puzzle. + diff --git a/docs/crypto/zkCTF/day1/Division Quiz/src/lib.rs b/docs/crypto/zkCTF/day1/Division Quiz/src/lib.rs new file mode 100644 index 0000000..febd5fb --- /dev/null +++ b/docs/crypto/zkCTF/day1/Division Quiz/src/lib.rs @@ -0,0 +1 @@ +pub mod quiz; diff --git a/docs/crypto/zkCTF/day1/Division Quiz/src/quiz.rs b/docs/crypto/zkCTF/day1/Division Quiz/src/quiz.rs new file mode 100644 index 0000000..45b99fd --- /dev/null +++ b/docs/crypto/zkCTF/day1/Division Quiz/src/quiz.rs @@ -0,0 +1,352 @@ +use halo2_proofs::{ + arithmetic::Field, + circuit::{AssignedCell, Chip, Layouter, Region, Value}, + plonk::{Advice, Column, ConstraintSystem, Error, Expression, Instance, Selector, TableColumn}, + poly::Rotation, +}; +use std::marker::PhantomData; + +const RANGE_BITS: usize = 8; + +pub struct DivChip { + pub config: DivConfig, + _marker: PhantomData, +} + +// You could delete or add columns here +#[derive(Clone, Debug)] +pub struct DivConfig { + // Dividend + a: Column, + // Divisor + b: Column, + // Quotient + c: Column, + // Remainder + r: Column, + // Aux + k: Column, + // Range + range: TableColumn, + // Instance + instance: Column, + // Selector + selector: Selector, +} + +impl Chip for DivChip { + type Config = DivConfig; + type Loaded = (); + + fn config(&self) -> &Self::Config { + &self.config + } + + fn loaded(&self) -> &Self::Loaded { + &() + } +} + +impl DivChip { + pub fn construct(config: >::Config) -> Self { + Self { + config, + _marker: PhantomData, + } + } + + pub fn configure(meta: &mut ConstraintSystem) -> >::Config { + // Witness + let col_a = meta.advice_column(); + let col_b = meta.advice_column(); + let col_c = meta.advice_column(); + let col_r = meta.advice_column(); + let col_k = meta.advice_column(); + // Selector + let selector = meta.complex_selector(); + // Range + let range = meta.lookup_table_column(); + // Instance + let instance = meta.instance_column(); + + meta.enable_equality(col_a); + meta.enable_equality(col_b); + meta.enable_equality(col_c); + meta.enable_equality(col_r); + meta.enable_equality(col_k); + meta.enable_equality(instance); + + ///////////////////////// Please implement code here ///////////////////////// + meta.create_gate("div check", |meta| { + let a = meta.query_advice(col_a, Rotation::cur()); + let b = meta.query_advice(col_b, Rotation::cur()); + let c = meta.query_advice(col_c, Rotation::cur()); + let r = meta.query_advice(col_r, Rotation::cur()); + let k = meta.query_advice(col_k, Rotation::cur()); + let s = meta.query_selector(selector); + + vec![s.clone() * (a - b.clone() * c - r.clone()), s * (b - r - k)] + }); + + meta.lookup("range check: a", |meta| { + let s = meta.query_selector(selector); + let a = meta.query_advice(col_a, Rotation::cur()); + vec![(s * a, range)] + }); + + meta.lookup("range check: b", |meta| { + let s = meta.query_selector(selector); + let b = meta.query_advice(col_b, Rotation::cur()); + vec![(s * b, range)] + }); + + meta.lookup("range check: c", |meta| { + let s = meta.query_selector(selector); + let c = meta.query_advice(col_c, Rotation::cur()); + vec![(s * c, range)] + }); + + meta.lookup("range check: r", |meta| { + let s = meta.query_selector(selector); + let r = meta.query_advice(col_r, Rotation::cur()); + vec![(s * r, range)] + }); + + meta.lookup("range check: k", |meta| { + let s = meta.query_selector(selector); + let k = meta.query_advice(col_k, Rotation::cur()); + vec![(s * k, range)] + }); + ///////////////////////// End implement ///////////////////////// + + DivConfig { + a: col_a, + b: col_b, + c: col_c, + r: col_r, + k: col_k, + range, + instance, + selector, + } + } + + // Assign range for U8 range check + pub fn assign_range(&self, mut layouter: impl Layouter) -> Result<(), Error> { + let config = &self.config; + + ///////////////////////// Please implement code here ///////////////////////// + let mut counter = F::zero(); + layouter.assign_table( + || "assign table_col", + |mut table| { + for i in 0..(1 << RANGE_BITS) { + table.assign_cell( + || "assign range", + config.range, + i, + || Value::known(counter), + )?; + counter += F::one(); + } + Ok(()) + }, + ); + ///////////////////////// End implement ///////////////////////// + + Ok(()) + } + + // Assign witness for division + pub fn assign_witness( + &self, + mut layouter: impl Layouter, + a: F, + b: F, + c: F, + ) -> Result, Error> { + let config = self.config; + + ///////////////////////// Please implement code here ///////////////////////// + let cell_c = layouter.assign_region( + || "assign one row of the region", + |mut region| { + region.assign_advice(|| "assign a", config.a, 0, || Value::known(a))?; + region.assign_advice(|| "assign b", config.b, 0, || Value::known(b))?; + let cell_c = + region.assign_advice(|| "assign c", config.c, 0, || Value::known(c))?; + let r = a % b; + region.assign_advice(|| "assign r", config.r, 0, || Value::known(r))?; + region.assign_advice(|| "assign k", config.k, 0, || Value::known(b - r))?; + config.selector.enable(&mut region, 0)?; + + Ok(cell_c) + }, + )?; + Ok(cell_c) + ///////////////////////// End implement ///////////////////////// + } + + pub fn expose_public( + &self, + mut layouter: impl Layouter, + cell: &AssignedCell, + ) -> Result<(), Error> { + layouter.constrain_instance(cell.cell(), self.config.instance, 0) + } +} + +/* ================Circuit========================== */ +use halo2_proofs::circuit::SimpleFloorPlanner; +use halo2_proofs::plonk::Circuit; +#[derive(Clone, Debug)] +pub struct CircuitConfig { + config: DivConfig, +} + +#[derive(Default, Debug)] +pub struct DivCircuit { + pub a: F, + pub b: F, + pub c: F, +} + +impl Circuit for DivCircuit { + type Config = CircuitConfig; + type FloorPlanner = SimpleFloorPlanner; + #[cfg(feature = "circuit-params")] + type Params = (); + + fn without_witnesses(&self) -> Self { + Self::default() + } + + fn configure(meta: &mut ConstraintSystem) -> Self::Config { + let config = DivChip::::configure(meta); + CircuitConfig { config } + } + + fn synthesize( + &self, + config: Self::Config, + mut layouter: impl Layouter, + ) -> Result<(), Error> { + let chip = DivChip::::construct(config.config); + chip.assign_range(layouter.namespace(|| "assign range"))?; + let cell_c = chip.assign_witness( + layouter.namespace(|| "assign witness"), + self.a, + self.b, + self.c, + )?; + chip.expose_public(layouter.namespace(|| "expose public"), &cell_c) + } +} + +#[cfg(test)] +mod tests { + use super::*; + use ff::PrimeField; + use halo2_proofs::dev::MockProver; + use halo2curves::bn256::Fr; + + #[test] + fn sanity_check() { + let k = 10; + let a = Fr::from_u128(10); + let b = Fr::from_u128(3); + let c = Fr::from_u128(3); + let circuit: DivCircuit = DivCircuit { a, b, c }; + let prover = MockProver::run(k, &circuit, vec![vec![c]]).unwrap(); + assert_eq!(prover.verify(), Ok(())); + } +} + +use halo2_proofs::{ + plonk::{create_proof, keygen_pk, keygen_vk, verify_proof, ProvingKey}, + poly::kzg::{ + commitment::{KZGCommitmentScheme, ParamsKZG}, + multiopen::{ProverGWC, VerifierGWC}, + strategy::SingleStrategy, + }, + transcript::{ + Blake2bRead, Blake2bWrite, Challenge255, TranscriptReadBuffer, TranscriptWriterBuffer, + }, + SerdeFormat, +}; +use halo2curves::bn256::{Bn256, Fr, G1Affine}; +use rand::rngs::OsRng; +use std::{ + fs::File, + io::{BufReader, BufWriter, Write}, +}; + +fn generate_keys(k: u32, circuit: &DivCircuit) -> (ParamsKZG, ProvingKey) { + let params = ParamsKZG::::setup(k, OsRng); + let vk = keygen_vk(¶ms, circuit).expect("vk should not fail"); + let pk = keygen_pk(¶ms, vk, circuit).expect("pk should not fail"); + (params, pk) +} + +fn generate_proof(k: u32, circuit: DivCircuit) { + let (params, pk) = generate_keys(k, &circuit); + let instances: &[&[Fr]] = &[&[circuit.c]]; + let f = File::create(format!("{}", "proof")).unwrap(); + let mut proof_writer = BufWriter::new(f); + let mut transcript = Blake2bWrite::<_, _, Challenge255<_>>::init(&mut proof_writer); + create_proof::< + KZGCommitmentScheme, + ProverGWC<'_, Bn256>, + Challenge255, + _, + Blake2bWrite<_, G1Affine, Challenge255<_>>, + _, + >( + ¶ms, + &pk, + &[circuit], + &[instances], + OsRng, + &mut transcript, + ) + .expect("prover should not fail"); + let proof_writer = transcript.finalize(); + let _ = proof_writer.flush(); + // Dump params + { + let f = File::create(format!("{}", "param")).unwrap(); + let mut writer = BufWriter::new(f); + params + .write_custom(&mut writer, SerdeFormat::RawBytes) + .unwrap(); + let _ = writer.flush(); + } + // Dump vk + { + let f = File::create(format!("{}", "vk")).unwrap(); + let mut writer = BufWriter::new(f); + pk.get_vk() + .write(&mut writer, SerdeFormat::RawBytes) + .unwrap(); + let _ = writer.flush(); + } +} + +#[cfg(test)] +mod test { + use super::*; + use ff::PrimeField; + use halo2_proofs::dev::MockProver; + use halo2curves::bn256::Fr; + + #[test] + fn sanity_check() { + let k = 10; + let a = Fr::from_u128(10); + let b = Fr::from_u128(3); + let c = Fr::from_u128(3); + let circuit: DivCircuit = DivCircuit { a, b, c }; + let prover = MockProver::run(k, &circuit, vec![vec![c]]).unwrap(); + assert_eq!(prover.verify(), Ok(())); + } +} diff --git a/docs/crypto/zkCTF/day1/Ethereal/README.md b/docs/crypto/zkCTF/day1/Ethereal/README.md new file mode 100644 index 0000000..a89439e --- /dev/null +++ b/docs/crypto/zkCTF/day1/Ethereal/README.md @@ -0,0 +1,80 @@ + +# The Ethereal Quest + +## Story +Welcome to Ethereal. Here, your quest is to forge the Seed Blade, a powerful sword assembled from 10 mystical parts. With each part, your blade becomes stronger, symbolizing your growing cryptographic mastery. + +Your challenge: to mint Gems with this blade. +Mint 10 gems, and you demonstrate your skill and balance. +Mint 20, and you push the boundaries of your abilities. But beware, each gem brings both power and peril. Will your Seed Blade be a tool of wisdom or lead to your downfall? The path is yours to choose. + +## Environment Setup + +### Starting an Ethereum Node +Launch an Ethereum node: +```sh +anvil +``` + +### Deploying the Contract +Navigate to the contract directory and deploy the contract: +```sh +# Enter the contract directory +cd mint-contracts + +# Deploy the Mint contract +forge create Mint --private-key=your_key + +# Return to the previous directory +cd - +``` + +## Starting the Challenge + +### Initial Setup +Change to the client directory: +```sh +cd mint-client +``` + +## Challenge Steps + +### 1. The Initiation of the Ethereal Quest +Begin your journey by registering: +```sh +go run . -contract your_contract_address -action register +``` + +### 2. The Forging of Ethereum Gems +Mint Ethereum Gems, each one bringing you closer to your goal: +```sh +go run . -contract your_contract_address -action mint +``` + +### 3. The Path of Redemption +Should you falter, replay and learn from your missteps: +```sh +go run . -contract your_contract_address -action replay +``` + +### 4. Unveil Your Treasures + +Verifying the Escape0 Flag: If you've successfully minted 10 gems, the "escape0" flag should now be set, symbolizing a key achievement in your quest. This flag reflects your adeptness in navigating the challenges and evading the watchful eyes of the Watchdog. + +Verifying the Escape1 Flag: For the bold adventurers who pushed their limits to mint 20 gems, the "escape1" flag would be their coveted prize. Achieving this flag marks you as one of the few who have reached the pinnacle of daring and strategy in the quest. +To check your achievements and claim your flags, invoke the following incantation: +```sh +go run . -contract your_contract_address -action query +``` + +## Command Options +Use these options for specific actions: +```bash +go run . +# Options: +# -action [register, mint, replay, query] +# -contract [contract_address] +# -rpc [RPC_endpoint] +# -account [account_address] +# -privateKey [private_key] +``` diff --git a/docs/crypto/zkCTF/day1/Ethereal/mint-client/.github/workflows/publish_web.yaml b/docs/crypto/zkCTF/day1/Ethereal/mint-client/.github/workflows/publish_web.yaml new file mode 100644 index 0000000..0c08deb --- /dev/null +++ b/docs/crypto/zkCTF/day1/Ethereal/mint-client/.github/workflows/publish_web.yaml @@ -0,0 +1,40 @@ +name: Publish Web + +on: + push: + branches: + - main # Adjust this to the branch you want the action to run on + +permissions: + contents: read + pages: write + id-token: write + +jobs: + build_and_deploy: + environment: + name: github-pages + url: ${{ steps.deployment.outputs.page_url }} + runs-on: ubuntu-latest + steps: + - name: Checkout repository + uses: actions/checkout@v3 + - name: Set up Go + uses: actions/setup-go@v3 + with: + go-version: 1.19 # Adjust this to the Go version your project uses + - name: Build web folder + run: | + cd web + chmod +x build.sh + ./build.sh + - name: Setup Pages + uses: actions/configure-pages@v3 + - name: Upload artifact + uses: actions/upload-pages-artifact@v1 + with: + # Upload entire repository + path: './web' + - name: Deploy to GitHub Pages + id: deployment + uses: actions/deploy-pages@v2 diff --git a/docs/crypto/zkCTF/day1/Ethereal/mint-client/.gitignore b/docs/crypto/zkCTF/day1/Ethereal/mint-client/.gitignore new file mode 100644 index 0000000..3176bd7 --- /dev/null +++ b/docs/crypto/zkCTF/day1/Ethereal/mint-client/.gitignore @@ -0,0 +1 @@ +polynomial.json \ No newline at end of file diff --git a/docs/crypto/zkCTF/day1/Ethereal/mint-client/abi/mint.json b/docs/crypto/zkCTF/day1/Ethereal/mint-client/abi/mint.json new file mode 100644 index 0000000..ad4be10 --- /dev/null +++ b/docs/crypto/zkCTF/day1/Ethereal/mint-client/abi/mint.json @@ -0,0 +1,693 @@ +[ + { + "type": "function", + "name": "SRS_G1_X", + "inputs": [ + { + "name": "", + "type": "uint256", + "internalType": "uint256" + } + ], + "outputs": [ + { + "name": "", + "type": "uint256", + "internalType": "uint256" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "SRS_G1_Y", + "inputs": [ + { + "name": "", + "type": "uint256", + "internalType": "uint256" + } + ], + "outputs": [ + { + "name": "", + "type": "uint256", + "internalType": "uint256" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "SRS_G2_X_0", + "inputs": [ + { + "name": "", + "type": "uint256", + "internalType": "uint256" + } + ], + "outputs": [ + { + "name": "", + "type": "uint256", + "internalType": "uint256" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "SRS_G2_X_1", + "inputs": [ + { + "name": "", + "type": "uint256", + "internalType": "uint256" + } + ], + "outputs": [ + { + "name": "", + "type": "uint256", + "internalType": "uint256" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "SRS_G2_Y_0", + "inputs": [ + { + "name": "", + "type": "uint256", + "internalType": "uint256" + } + ], + "outputs": [ + { + "name": "", + "type": "uint256", + "internalType": "uint256" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "SRS_G2_Y_1", + "inputs": [ + { + "name": "", + "type": "uint256", + "internalType": "uint256" + } + ], + "outputs": [ + { + "name": "", + "type": "uint256", + "internalType": "uint256" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "commit", + "inputs": [ + { + "name": "coefficients", + "type": "uint256[]", + "internalType": "uint256[]" + } + ], + "outputs": [ + { + "name": "", + "type": "tuple", + "internalType": "struct Pairing.G1Point", + "components": [ + { + "name": "X", + "type": "uint256", + "internalType": "uint256" + }, + { + "name": "Y", + "type": "uint256", + "internalType": "uint256" + } + ] + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "deposits", + "inputs": [ + { + "name": "", + "type": "address", + "internalType": "address" + } + ], + "outputs": [ + { + "name": "registered", + "type": "bool", + "internalType": "bool" + }, + { + "name": "nonce", + "type": "uint256", + "internalType": "uint256" + }, + { + "name": "commitment", + "type": "tuple", + "internalType": "struct Pairing.G1Point", + "components": [ + { + "name": "X", + "type": "uint256", + "internalType": "uint256" + }, + { + "name": "Y", + "type": "uint256", + "internalType": "uint256" + } + ] + }, + { + "name": "publicKey", + "type": "tuple", + "internalType": "struct Pairing.G1Point", + "components": [ + { + "name": "X", + "type": "uint256", + "internalType": "uint256" + }, + { + "name": "Y", + "type": "uint256", + "internalType": "uint256" + } + ] + }, + { + "name": "escaped0", + "type": "bool", + "internalType": "bool" + }, + { + "name": "escaped1", + "type": "bool", + "internalType": "bool" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "evalPolyAt", + "inputs": [ + { + "name": "_coefficients", + "type": "uint256[]", + "internalType": "uint256[]" + }, + { + "name": "_index", + "type": "uint256", + "internalType": "uint256" + } + ], + "outputs": [ + { + "name": "", + "type": "uint256", + "internalType": "uint256" + } + ], + "stateMutability": "pure" + }, + { + "type": "function", + "name": "evaluateBarycentricPolynomial", + "inputs": [ + { + "name": "x", + "type": "uint256", + "internalType": "uint256" + }, + { + "name": "yValues", + "type": "uint256[]", + "internalType": "uint256[]" + }, + { + "name": "weights", + "type": "uint256[]", + "internalType": "uint256[]" + } + ], + "outputs": [ + { + "name": "", + "type": "uint256", + "internalType": "uint256" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "getBarycentricWeights", + "inputs": [ + { + "name": "xValues", + "type": "uint256[]", + "internalType": "uint256[]" + } + ], + "outputs": [ + { + "name": "", + "type": "uint256[]", + "internalType": "uint256[]" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "getCollectedY", + "inputs": [ + { + "name": "user", + "type": "address", + "internalType": "address" + } + ], + "outputs": [ + { + "name": "", + "type": "uint256[]", + "internalType": "uint256[]" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "getNonce", + "inputs": [ + { + "name": "_user", + "type": "address", + "internalType": "address" + } + ], + "outputs": [ + { + "name": "", + "type": "uint256", + "internalType": "uint256" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "mint", + "inputs": [ + { + "name": "_proof", + "type": "tuple", + "internalType": "struct Pairing.G1Point", + "components": [ + { + "name": "X", + "type": "uint256", + "internalType": "uint256" + }, + { + "name": "Y", + "type": "uint256", + "internalType": "uint256" + } + ] + }, + { + "name": "_value", + "type": "uint256", + "internalType": "uint256" + } + ], + "outputs": [], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "register", + "inputs": [ + { + "name": "_commitment", + "type": "tuple", + "internalType": "struct Pairing.G1Point", + "components": [ + { + "name": "X", + "type": "uint256", + "internalType": "uint256" + }, + { + "name": "Y", + "type": "uint256", + "internalType": "uint256" + } + ] + }, + { + "name": "_proof", + "type": "tuple", + "internalType": "struct Pairing.G1Point", + "components": [ + { + "name": "X", + "type": "uint256", + "internalType": "uint256" + }, + { + "name": "Y", + "type": "uint256", + "internalType": "uint256" + } + ] + }, + { + "name": "_publicKey", + "type": "tuple", + "internalType": "struct Pairing.G1Point", + "components": [ + { + "name": "X", + "type": "uint256", + "internalType": "uint256" + }, + { + "name": "Y", + "type": "uint256", + "internalType": "uint256" + } + ] + } + ], + "outputs": [], + "stateMutability": "payable" + }, + { + "type": "function", + "name": "replay", + "inputs": [], + "outputs": [], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "verify", + "inputs": [ + { + "name": "_commitment", + "type": "tuple", + "internalType": "struct Pairing.G1Point", + "components": [ + { + "name": "X", + "type": "uint256", + "internalType": "uint256" + }, + { + "name": "Y", + "type": "uint256", + "internalType": "uint256" + } + ] + }, + { + "name": "_proof", + "type": "tuple", + "internalType": "struct Pairing.G1Point", + "components": [ + { + "name": "X", + "type": "uint256", + "internalType": "uint256" + }, + { + "name": "Y", + "type": "uint256", + "internalType": "uint256" + } + ] + }, + { + "name": "_index", + "type": "uint256", + "internalType": "uint256" + }, + { + "name": "_value", + "type": "uint256", + "internalType": "uint256" + } + ], + "outputs": [ + { + "name": "", + "type": "bool", + "internalType": "bool" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "verifyMulti", + "inputs": [ + { + "name": "_commitment", + "type": "tuple", + "internalType": "struct Pairing.G1Point", + "components": [ + { + "name": "X", + "type": "uint256", + "internalType": "uint256" + }, + { + "name": "Y", + "type": "uint256", + "internalType": "uint256" + } + ] + }, + { + "name": "_proof", + "type": "tuple", + "internalType": "struct Pairing.G2Point", + "components": [ + { + "name": "X", + "type": "uint256[2]", + "internalType": "uint256[2]" + }, + { + "name": "Y", + "type": "uint256[2]", + "internalType": "uint256[2]" + } + ] + }, + { + "name": "_indices", + "type": "uint256[]", + "internalType": "uint256[]" + }, + { + "name": "_values", + "type": "uint256[]", + "internalType": "uint256[]" + }, + { + "name": "_iCoeffs", + "type": "uint256[]", + "internalType": "uint256[]" + }, + { + "name": "_zCoeffs", + "type": "uint256[]", + "internalType": "uint256[]" + } + ], + "outputs": [ + { + "name": "", + "type": "bool", + "internalType": "bool" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "verifyPublicKey", + "inputs": [ + { + "name": "_commitment", + "type": "tuple", + "internalType": "struct Pairing.G1Point", + "components": [ + { + "name": "X", + "type": "uint256", + "internalType": "uint256" + }, + { + "name": "Y", + "type": "uint256", + "internalType": "uint256" + } + ] + }, + { + "name": "_proof", + "type": "tuple", + "internalType": "struct Pairing.G1Point", + "components": [ + { + "name": "X", + "type": "uint256", + "internalType": "uint256" + }, + { + "name": "Y", + "type": "uint256", + "internalType": "uint256" + } + ] + }, + { + "name": "_publicKey", + "type": "tuple", + "internalType": "struct Pairing.G1Point", + "components": [ + { + "name": "X", + "type": "uint256", + "internalType": "uint256" + }, + { + "name": "Y", + "type": "uint256", + "internalType": "uint256" + } + ] + } + ], + "outputs": [ + { + "name": "", + "type": "bool", + "internalType": "bool" + } + ], + "stateMutability": "view" + }, + { + "type": "event", + "name": "Deposit", + "inputs": [ + { + "name": "publicKey", + "type": "tuple", + "indexed": true, + "internalType": "struct Pairing.G1Point", + "components": [ + { + "name": "X", + "type": "uint256", + "internalType": "uint256" + }, + { + "name": "Y", + "type": "uint256", + "internalType": "uint256" + } + ] + }, + { + "name": "commitment", + "type": "tuple", + "indexed": false, + "internalType": "struct Pairing.G1Point", + "components": [ + { + "name": "X", + "type": "uint256", + "internalType": "uint256" + }, + { + "name": "Y", + "type": "uint256", + "internalType": "uint256" + } + ] + }, + { + "name": "timestamp", + "type": "uint256", + "indexed": false, + "internalType": "uint256" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "Minted", + "inputs": [ + { + "name": "user", + "type": "address", + "indexed": true, + "internalType": "address" + }, + { + "name": "nonce", + "type": "uint256", + "indexed": false, + "internalType": "uint256" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "Pwned", + "inputs": [ + { + "name": "privateKey", + "type": "uint256", + "indexed": true, + "internalType": "uint256" + } + ], + "anonymous": false + } +] diff --git a/docs/crypto/zkCTF/day1/Ethereal/mint-client/blacksmith.go b/docs/crypto/zkCTF/day1/Ethereal/mint-client/blacksmith.go new file mode 100644 index 0000000..26d74f6 --- /dev/null +++ b/docs/crypto/zkCTF/day1/Ethereal/mint-client/blacksmith.go @@ -0,0 +1,80 @@ +package main + +import ( + "crypto" + "encoding/binary" + "math/big" + "time" + + "github.com/consensys/gnark-crypto/ecc/bn254" + "github.com/consensys/gnark-crypto/ecc/bn254/fr" + "github.com/consensys/gnark-crypto/ecc/bn254/fr/kzg" + "github.com/davecgh/go-spew/spew" +) + +func ForgeSword() []fr.Element { + // initialize the fr slice + f := make([]fr.Element, 16) + // initialize the hash function + h := crypto.SHA256.New() + // get the current timestamp + ts := time.Now().UnixNano() + // convert the timestamp to bytes + tsB := make([]byte, 8) + binary.LittleEndian.PutUint64(tsB, uint64(ts)) + // write the timestamp to the hash function as input + h.Write(tsB) + h.Write([]byte("Soul of a Hero")) + // get the hash of the input + seed := h.Sum(nil) + // iterate 10 times and fill the fr slice with the hash of the seed + for i := 0; i < 16; i++ { + f[i].SetBytes(seed[:32]) + h.Reset() + h.Write(seed) + seed = h.Sum(nil) + } + return f +} + +// define the KeyPairProof struct +type KeyPairProof struct { + H bn254.G1Affine + PrivateKey *fr.Element + PublicKeyG1Aff bn254.G1Affine +} + +// CraftBladeSignature crafts a blade signature +func CraftBladeSignature(poly []fr.Element, srs *kzg.SRS) (kzg.Digest, *KeyPairProof) { + //commit the polynomial + commitment, err := kzg.Commit(poly, srs.Pk) + if err != nil { + panic(err) + } + // fmt.Printf("commitment: \nX: %02x\nY: %02x\n", commitment.X, commitment.Y) + + // compute opening proof at a random point + var point fr.Element + point.SetInt64(0) + proof, err := kzg.Open(poly, point, srs.Pk) + if err != nil { + panic(err) + } + + // claimed value is private key. + // derive public key from private key + privateKey := new(big.Int) + proof.ClaimedValue.BigInt(privateKey) + + publicKey := new(bn254.G1Affine) + publicKey.ScalarMultiplication(&srs.Pk.G1[0], privateKey) + spew.Dump(privateKey, publicKey) + publicKeyG2 := new(bn254.G2Affine) + publicKeyG2.ScalarMultiplication(&srs.Vk.G2[0], privateKey) + + pubKeyProof := new(KeyPairProof) + pubKeyProof.PrivateKey = &proof.ClaimedValue + pubKeyProof.H = proof.H + pubKeyProof.PublicKeyG1Aff = *publicKey + return commitment, pubKeyProof +} diff --git a/docs/crypto/zkCTF/day1/Ethereal/mint-client/go.mod b/docs/crypto/zkCTF/day1/Ethereal/mint-client/go.mod new file mode 100644 index 0000000..888a17d --- /dev/null +++ b/docs/crypto/zkCTF/day1/Ethereal/mint-client/go.mod @@ -0,0 +1,38 @@ +module zk/mint + +go 1.23 + +require ( + github.com/consensys/gnark-crypto v0.12.1 + github.com/davecgh/go-spew v1.1.1 + github.com/ethereum/go-ethereum v1.13.10 +) + +require ( + github.com/Microsoft/go-winio v0.6.1 // indirect + github.com/StackExchange/wmi v1.2.1 // indirect + github.com/bits-and-blooms/bitset v1.10.0 // indirect + github.com/btcsuite/btcd/btcec/v2 v2.2.0 // indirect + github.com/consensys/bavard v0.1.13 // indirect + github.com/crate-crypto/go-kzg-4844 v0.7.0 // indirect + github.com/deckarep/golang-set/v2 v2.1.0 // indirect + github.com/decred/dcrd/dcrec/secp256k1/v4 v4.0.1 // indirect + github.com/ethereum/c-kzg-4844 v0.4.0 // indirect + github.com/fsnotify/fsnotify v1.6.0 // indirect + github.com/go-ole/go-ole v1.2.5 // indirect + github.com/google/uuid v1.3.0 // indirect + github.com/gorilla/websocket v1.4.2 // indirect + github.com/holiman/uint256 v1.2.4 // indirect + github.com/mmcloughlin/addchain v0.4.0 // indirect + github.com/shirou/gopsutil v3.21.4-0.20210419000835-c7a38de76ee5+incompatible // indirect + github.com/supranational/blst v0.3.11 // indirect + github.com/tklauser/go-sysconf v0.3.12 // indirect + github.com/tklauser/numcpus v0.6.1 // indirect + golang.org/x/crypto v0.17.0 // indirect + golang.org/x/exp v0.0.0-20231110203233-9a3e6036ecaa // indirect + golang.org/x/mod v0.14.0 // indirect + golang.org/x/sync v0.5.0 // indirect + golang.org/x/sys v0.15.0 // indirect + golang.org/x/tools v0.15.0 // indirect + rsc.io/tmplfunc v0.0.3 // indirect +) diff --git a/docs/crypto/zkCTF/day1/Ethereal/mint-client/go.sum b/docs/crypto/zkCTF/day1/Ethereal/mint-client/go.sum new file mode 100644 index 0000000..d79cadd --- /dev/null +++ b/docs/crypto/zkCTF/day1/Ethereal/mint-client/go.sum @@ -0,0 +1,190 @@ +github.com/DataDog/zstd v1.4.5 h1:EndNeuB0l9syBZhut0wns3gV1hL8zX8LIu6ZiVHWLIQ= +github.com/DataDog/zstd v1.4.5/go.mod h1:1jcaCB/ufaK+sKp1NBhlGmpz41jOoPQ35bpF36t7BBo= +github.com/Microsoft/go-winio v0.6.1 h1:9/kr64B9VUZrLm5YYwbGtUJnMgqWVOdUAXu6Migciow= +github.com/Microsoft/go-winio v0.6.1/go.mod h1:LRdKpFKfdobln8UmuiYcKPot9D2v6svN5+sAH+4kjUM= +github.com/StackExchange/wmi v1.2.1 h1:VIkavFPXSjcnS+O8yTq7NI32k0R5Aj+v39y29VYDOSA= +github.com/StackExchange/wmi v1.2.1/go.mod h1:rcmrprowKIVzvc+NUiLncP2uuArMWLCbu9SBzvHz7e8= +github.com/VictoriaMetrics/fastcache v1.12.1 h1:i0mICQuojGDL3KblA7wUNlY5lOK6a4bwt3uRKnkZU40= +github.com/VictoriaMetrics/fastcache v1.12.1/go.mod h1:tX04vaqcNoQeGLD+ra5pU5sWkuxnzWhEzLwhP9w653o= +github.com/beorn7/perks v1.0.1 h1:VlbKKnNfV8bJzeqoa4cOKqO6bYr3WgKZxO8Z16+hsOM= +github.com/beorn7/perks v1.0.1/go.mod h1:G2ZrVWU2WbWT9wwq4/hrbKbnv/1ERSJQ0ibhJ6rlkpw= +github.com/bits-and-blooms/bitset v1.10.0 h1:ePXTeiPEazB5+opbv5fr8umg2R/1NlzgDsyepwsSr88= +github.com/bits-and-blooms/bitset v1.10.0/go.mod h1:7hO7Gc7Pp1vODcmWvKMRA9BNmbv6a/7QIWpPxHddWR8= +github.com/btcsuite/btcd/btcec/v2 v2.2.0 h1:fzn1qaOt32TuLjFlkzYSsBC35Q3KUjT1SwPxiMSCF5k= +github.com/btcsuite/btcd/btcec/v2 v2.2.0/go.mod h1:U7MHm051Al6XmscBQ0BoNydpOTsFAn707034b5nY8zU= +github.com/btcsuite/btcd/chaincfg/chainhash v1.0.1 h1:q0rUy8C/TYNBQS1+CGKw68tLOFYSNEs0TFnxxnS9+4U= +github.com/btcsuite/btcd/chaincfg/chainhash v1.0.1/go.mod h1:7SFka0XMvUgj3hfZtydOrQY2mwhPclbT2snogU7SQQc= +github.com/cespare/cp v0.1.0 h1:SE+dxFebS7Iik5LK0tsi1k9ZCxEaFX4AjQmoyA+1dJk= +github.com/cespare/cp v0.1.0/go.mod h1:SOGHArjBr4JWaSDEVpWpo/hNg6RoKrls6Oh40hiwW+s= +github.com/cespare/xxhash/v2 v2.2.0 h1:DC2CZ1Ep5Y4k3ZQ899DldepgrayRUGE6BBZ/cd9Cj44= +github.com/cespare/xxhash/v2 v2.2.0/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs= +github.com/cockroachdb/errors v1.8.1 h1:A5+txlVZfOqFBDa4mGz2bUWSp0aHElvHX2bKkdbQu+Y= +github.com/cockroachdb/errors v1.8.1/go.mod h1:qGwQn6JmZ+oMjuLwjWzUNqblqk0xl4CVV3SQbGwK7Ac= +github.com/cockroachdb/logtags v0.0.0-20190617123548-eb05cc24525f h1:o/kfcElHqOiXqcou5a3rIlMc7oJbMQkeLk0VQJ7zgqY= +github.com/cockroachdb/logtags v0.0.0-20190617123548-eb05cc24525f/go.mod h1:i/u985jwjWRlyHXQbwatDASoW0RMlZ/3i9yJHE2xLkI= +github.com/cockroachdb/pebble v0.0.0-20230928194634-aa077af62593 h1:aPEJyR4rPBvDmeyi+l/FS/VtA00IWvjeFvjen1m1l1A= +github.com/cockroachdb/pebble v0.0.0-20230928194634-aa077af62593/go.mod h1:6hk1eMY/u5t+Cf18q5lFMUA1Rc+Sm5I6Ra1QuPyxXCo= +github.com/cockroachdb/redact v1.0.8 h1:8QG/764wK+vmEYoOlfobpe12EQcS81ukx/a4hdVMxNw= +github.com/cockroachdb/redact v1.0.8/go.mod h1:BVNblN9mBWFyMyqK1k3AAiSxhvhfK2oOZZ2lK+dpvRg= +github.com/cockroachdb/sentry-go v0.6.1-cockroachdb.2 h1:IKgmqgMQlVJIZj19CdocBeSfSaiCbEBZGKODaixqtHM= +github.com/cockroachdb/sentry-go v0.6.1-cockroachdb.2/go.mod h1:8BT+cPK6xvFOcRlk0R8eg+OTkcqI6baNH4xAkpiYVvQ= +github.com/cockroachdb/tokenbucket v0.0.0-20230807174530-cc333fc44b06 h1:zuQyyAKVxetITBuuhv3BI9cMrmStnpT18zmgmTxunpo= +github.com/cockroachdb/tokenbucket v0.0.0-20230807174530-cc333fc44b06/go.mod h1:7nc4anLGjupUW/PeY5qiNYsdNXj7zopG+eqsS7To5IQ= +github.com/consensys/bavard v0.1.13 h1:oLhMLOFGTLdlda/kma4VOJazblc7IM5y5QPd2A/YjhQ= +github.com/consensys/bavard v0.1.13/go.mod h1:9ItSMtA/dXMAiL7BG6bqW2m3NdSEObYWoH223nGHukI= +github.com/consensys/gnark-crypto v0.12.1 h1:lHH39WuuFgVHONRl3J0LRBtuYdQTumFSDtJF7HpyG8M= +github.com/consensys/gnark-crypto v0.12.1/go.mod h1:v2Gy7L/4ZRosZ7Ivs+9SfUDr0f5UlG+EM5t7MPHiLuY= +github.com/cpuguy83/go-md2man/v2 v2.0.2 h1:p1EgwI/C7NhT0JmVkwCD2ZBK8j4aeHQX2pMHHBfMQ6w= +github.com/cpuguy83/go-md2man/v2 v2.0.2/go.mod h1:tgQtvFlXSQOSOSIRvRPT7W67SCa46tRHOmNcaadrF8o= +github.com/crate-crypto/go-ipa v0.0.0-20231025140028-3c0104f4b233 h1:d28BXYi+wUpz1KBmiF9bWrjEMacUEREV6MBi2ODnrfQ= +github.com/crate-crypto/go-ipa v0.0.0-20231025140028-3c0104f4b233/go.mod h1:geZJZH3SzKCqnz5VT0q/DyIG/tvu/dZk+VIfXicupJs= +github.com/crate-crypto/go-kzg-4844 v0.7.0 h1:C0vgZRk4q4EZ/JgPfzuSoxdCq3C3mOZMBShovmncxvA= +github.com/crate-crypto/go-kzg-4844 v0.7.0/go.mod h1:1kMhvPgI0Ky3yIa+9lFySEBUBXkYxeOi8ZF1sYioxhc= +github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c= +github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= +github.com/deckarep/golang-set/v2 v2.1.0 h1:g47V4Or+DUdzbs8FxCCmgb6VYd+ptPAngjM6dtGktsI= +github.com/deckarep/golang-set/v2 v2.1.0/go.mod h1:VAky9rY/yGXJOLEDv3OMci+7wtDpOF4IN+y82NBOac4= +github.com/decred/dcrd/crypto/blake256 v1.0.0 h1:/8DMNYp9SGi5f0w7uCm6d6M4OU2rGFK09Y2A4Xv7EE0= +github.com/decred/dcrd/crypto/blake256 v1.0.0/go.mod h1:sQl2p6Y26YV+ZOcSTP6thNdn47hh8kt6rqSlvmrXFAc= +github.com/decred/dcrd/dcrec/secp256k1/v4 v4.0.1 h1:YLtO71vCjJRCBcrPMtQ9nqBsqpA1m5sE92cU+pd5Mcc= +github.com/decred/dcrd/dcrec/secp256k1/v4 v4.0.1/go.mod h1:hyedUtir6IdtD/7lIxGeCxkaw7y45JueMRL4DIyJDKs= +github.com/ethereum/c-kzg-4844 v0.4.0 h1:3MS1s4JtA868KpJxroZoepdV0ZKBp3u/O5HcZ7R3nlY= +github.com/ethereum/c-kzg-4844 v0.4.0/go.mod h1:VewdlzQmpT5QSrVhbBuGoCdFJkpaJlO1aQputP83wc0= +github.com/ethereum/go-ethereum v1.13.10 h1:Ppdil79nN+Vc+mXfge0AuUgmKWuVv4eMqzoIVSdqZek= +github.com/ethereum/go-ethereum v1.13.10/go.mod h1:sc48XYQxCzH3fG9BcrXCOOgQk2JfZzNAmIKnceogzsA= +github.com/fjl/memsize v0.0.0-20190710130421-bcb5799ab5e5 h1:FtmdgXiUlNeRsoNMFlKLDt+S+6hbjVMEW6RGQ7aUf7c= +github.com/fjl/memsize v0.0.0-20190710130421-bcb5799ab5e5/go.mod h1:VvhXpOYNQvB+uIk2RvXzuaQtkQJzzIx6lSBe1xv7hi0= +github.com/fsnotify/fsnotify v1.6.0 h1:n+5WquG0fcWoWp6xPWfHdbskMCQaFnG6PfBrh1Ky4HY= +github.com/fsnotify/fsnotify v1.6.0/go.mod h1:sl3t1tCWJFWoRz9R8WJCbQihKKwmorjAbSClcnxKAGw= +github.com/gballet/go-libpcsclite v0.0.0-20190607065134-2772fd86a8ff h1:tY80oXqGNY4FhTFhk+o9oFHGINQ/+vhlm8HFzi6znCI= +github.com/gballet/go-libpcsclite v0.0.0-20190607065134-2772fd86a8ff/go.mod h1:x7DCsMOv1taUwEWCzT4cmDeAkigA5/QCwUodaVOe8Ww= +github.com/gballet/go-verkle v0.1.1-0.20231031103413-a67434b50f46 h1:BAIP2GihuqhwdILrV+7GJel5lyPV3u1+PgzrWLc0TkE= +github.com/gballet/go-verkle v0.1.1-0.20231031103413-a67434b50f46/go.mod h1:QNpY22eby74jVhqH4WhDLDwxc/vqsern6pW+u2kbkpc= +github.com/go-ole/go-ole v1.2.5 h1:t4MGB5xEDZvXI+0rMjjsfBsD7yAgp/s9ZDkL1JndXwY= +github.com/go-ole/go-ole v1.2.5/go.mod h1:pprOEPIfldk/42T2oK7lQ4v4JSDwmV0As9GaiUsvbm0= +github.com/gofrs/flock v0.8.1 h1:+gYjHKf32LDeiEEFhQaotPbLuUXjY5ZqxKgXy7n59aw= +github.com/gofrs/flock v0.8.1/go.mod h1:F1TvTiK9OcQqauNUHlbJvyl9Qa1QvF/gOUDKA14jxHU= +github.com/gogo/protobuf v1.3.2 h1:Ov1cvc58UF3b5XjBnZv7+opcTcQFZebYjWzi34vdm4Q= +github.com/gogo/protobuf v1.3.2/go.mod h1:P1XiOD3dCwIKUDQYPy72D8LYyHL2YPYrpS2s69NZV8Q= +github.com/golang-jwt/jwt/v4 v4.5.0 h1:7cYmW1XlMY7h7ii7UhUyChSgS5wUJEnm9uZVTGqOWzg= +github.com/golang-jwt/jwt/v4 v4.5.0/go.mod h1:m21LjoU+eqJr34lmDMbreY2eSTRJ1cv77w39/MY0Ch0= +github.com/golang/protobuf v1.5.3 h1:KhyjKVUg7Usr/dYsdSqoFveMYd5ko72D+zANwlG1mmg= +github.com/golang/protobuf v1.5.3/go.mod h1:XVQd3VNwM+JqD3oG2Ue2ip4fOMUkwXdXDdiuN0vRsmY= +github.com/golang/snappy v0.0.5-0.20220116011046-fa5810519dcb h1:PBC98N2aIaM3XXiurYmW7fx4GZkL8feAMVq7nEjURHk= +github.com/golang/snappy v0.0.5-0.20220116011046-fa5810519dcb/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEWrmP2Q= +github.com/google/gofuzz v1.2.0 h1:xRy4A+RhZaiKjJ1bPfwQ8sedCA+YS2YcCHW6ec7JMi0= +github.com/google/gofuzz v1.2.0/go.mod h1:dBl0BpW6vV/+mYPU4Po3pmUjxk6FQPldtuIdl/M65Eg= +github.com/google/subcommands v1.2.0/go.mod h1:ZjhPrFU+Olkh9WazFPsl27BQ4UPiG37m3yTrtFlrHVk= +github.com/google/uuid v1.3.0 h1:t6JiXgmwXMjEs8VusXIJk2BXHsn+wx8BZdTaoZ5fu7I= +github.com/google/uuid v1.3.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo= +github.com/gorilla/websocket v1.4.2 h1:+/TMaTYc4QFitKJxsQ7Yye35DkWvkdLcvGKqM+x0Ufc= +github.com/gorilla/websocket v1.4.2/go.mod h1:YR8l580nyteQvAITg2hZ9XVh4b55+EU/adAjf1fMHhE= +github.com/hashicorp/go-bexpr v0.1.10 h1:9kuI5PFotCboP3dkDYFr/wi0gg0QVbSNz5oFRpxn4uE= +github.com/hashicorp/go-bexpr v0.1.10/go.mod h1:oxlubA2vC/gFVfX1A6JGp7ls7uCDlfJn732ehYYg+g0= +github.com/holiman/billy v0.0.0-20230718173358-1c7e68d277a7 h1:3JQNjnMRil1yD0IfZKHF9GxxWKDJGj8I0IqOUol//sw= +github.com/holiman/billy v0.0.0-20230718173358-1c7e68d277a7/go.mod h1:5GuXa7vkL8u9FkFuWdVvfR5ix8hRB7DbOAaYULamFpc= +github.com/holiman/bloomfilter/v2 v2.0.3 h1:73e0e/V0tCydx14a0SCYS/EWCxgwLZ18CZcZKVu0fao= +github.com/holiman/bloomfilter/v2 v2.0.3/go.mod h1:zpoh+gs7qcpqrHr3dB55AMiJwo0iURXE7ZOP9L9hSkA= +github.com/holiman/uint256 v1.2.4 h1:jUc4Nk8fm9jZabQuqr2JzednajVmBpC+oiTiXZJEApU= +github.com/holiman/uint256 v1.2.4/go.mod h1:EOMSn4q6Nyt9P6efbI3bueV4e1b3dGlUCXeiRV4ng7E= +github.com/huin/goupnp v1.3.0 h1:UvLUlWDNpoUdYzb2TCn+MuTWtcjXKSza2n6CBdQ0xXc= +github.com/huin/goupnp v1.3.0/go.mod h1:gnGPsThkYa7bFi/KWmEysQRf48l2dvR5bxr2OFckNX8= +github.com/jackpal/go-nat-pmp v1.0.2 h1:KzKSgb7qkJvOUTqYl9/Hg/me3pWgBmERKrTGD7BdWus= +github.com/jackpal/go-nat-pmp v1.0.2/go.mod h1:QPH045xvCAeXUZOxsnwmrtiCoxIr9eob+4orBN1SBKc= +github.com/klauspost/compress v1.15.15 h1:EF27CXIuDsYJ6mmvtBRlEuB2UVOqHG1tAXgZ7yIO+lw= +github.com/klauspost/compress v1.15.15/go.mod h1:ZcK2JAFqKOpnBlxcLsJzYfrS9X1akm9fHZNnD9+Vo/4= +github.com/kr/pretty v0.3.1 h1:flRD4NNwYAUpkphVc1HcthR4KEIFJ65n8Mw5qdRn3LE= +github.com/kr/pretty v0.3.1/go.mod h1:hoEshYVHaxMs3cyo3Yncou5ZscifuDolrwPKZanG3xk= +github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY= +github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE= +github.com/kylelemons/godebug v1.1.0 h1:RPNrshWIDI6G2gRW9EHilWtl7Z6Sb1BR0xunSBf0SNc= +github.com/kylelemons/godebug v1.1.0/go.mod h1:9/0rRGxNHcop5bhtWyNeEfOS8JIWk580+fNqagV/RAw= +github.com/leanovate/gopter v0.2.9 h1:fQjYxZaynp97ozCzfOyOuAGOU4aU/z37zf/tOujFk7c= +github.com/leanovate/gopter v0.2.9/go.mod h1:U2L/78B+KVFIx2VmW6onHJQzXtFb+p5y3y2Sh+Jxxv8= +github.com/mattn/go-colorable v0.1.13 h1:fFA4WZxdEF4tXPZVKMLwD8oUnCTTo08duU7wxecdEvA= +github.com/mattn/go-colorable v0.1.13/go.mod h1:7S9/ev0klgBDR4GtXTXX8a3vIGJpMovkB8vQcUbaXHg= +github.com/mattn/go-isatty v0.0.17 h1:BTarxUcIeDqL27Mc+vyvdWYSL28zpIhv3RoTdsLMPng= +github.com/mattn/go-isatty v0.0.17/go.mod h1:kYGgaQfpe5nmfYZH+SKPsOc2e4SrIfOl2e/yFXSvRLM= +github.com/mattn/go-runewidth v0.0.13 h1:lTGmDsbAYt5DmK6OnoV7EuIF1wEIFAcxld6ypU4OSgU= +github.com/mattn/go-runewidth v0.0.13/go.mod h1:Jdepj2loyihRzMpdS35Xk/zdY8IAYHsh153qUoGf23w= +github.com/matttproud/golang_protobuf_extensions v1.0.2-0.20181231171920-c182affec369 h1:I0XW9+e1XWDxdcEniV4rQAIOPUGDq67JSCiRCgGCZLI= +github.com/matttproud/golang_protobuf_extensions v1.0.2-0.20181231171920-c182affec369/go.mod h1:BSXmuO+STAnVfrANrmjBb36TMTDstsz7MSK+HVaYKv4= +github.com/mitchellh/mapstructure v1.4.1 h1:CpVNEelQCZBooIPDn+AR3NpivK/TIKU8bDxdASFVQag= +github.com/mitchellh/mapstructure v1.4.1/go.mod h1:bFUtVrKA4DC2yAKiSyO/QUcy7e+RRV2QTWOzhPopBRo= +github.com/mitchellh/pointerstructure v1.2.0 h1:O+i9nHnXS3l/9Wu7r4NrEdwA2VFTicjUEN1uBnDo34A= +github.com/mitchellh/pointerstructure v1.2.0/go.mod h1:BRAsLI5zgXmw97Lf6s25bs8ohIXc3tViBH44KcwB2g4= +github.com/mmcloughlin/addchain v0.4.0 h1:SobOdjm2xLj1KkXN5/n0xTIWyZA2+s99UCY1iPfkHRY= +github.com/mmcloughlin/addchain v0.4.0/go.mod h1:A86O+tHqZLMNO4w6ZZ4FlVQEadcoqkyU72HC5wJ4RlU= +github.com/mmcloughlin/profile v0.1.1/go.mod h1:IhHD7q1ooxgwTgjxQYkACGA77oFTDdFVejUS1/tS/qU= +github.com/olekukonko/tablewriter v0.0.5 h1:P2Ga83D34wi1o9J6Wh1mRuqd4mF/x/lgBS7N7AbDhec= +github.com/olekukonko/tablewriter v0.0.5/go.mod h1:hPp6KlRPjbx+hW8ykQs1w3UBbZlj6HuIJcUGPhkA7kY= +github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4= +github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0= +github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM= +github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= +github.com/prometheus/client_golang v1.12.0 h1:C+UIj/QWtmqY13Arb8kwMt5j34/0Z2iKamrJ+ryC0Gg= +github.com/prometheus/client_golang v1.12.0/go.mod h1:3Z9XVyYiZYEO+YQWt3RD2R3jrbd179Rt297l4aS6nDY= +github.com/prometheus/client_model v0.2.1-0.20210607210712-147c58e9608a h1:CmF68hwI0XsOQ5UwlBopMi2Ow4Pbg32akc4KIVCOm+Y= +github.com/prometheus/client_model v0.2.1-0.20210607210712-147c58e9608a/go.mod h1:LDGWKZIo7rky3hgvBe+caln+Dr3dPggB5dvjtD7w9+w= +github.com/prometheus/common v0.32.1 h1:hWIdL3N2HoUx3B8j3YN9mWor0qhY/NlEKZEaXxuIRh4= +github.com/prometheus/common v0.32.1/go.mod h1:vu+V0TpY+O6vW9J44gczi3Ap/oXXR10b+M/gUGO4Hls= +github.com/prometheus/procfs v0.7.3 h1:4jVXhlkAyzOScmCkXBTOLRLTz8EeU+eyjrwB/EPq0VU= +github.com/prometheus/procfs v0.7.3/go.mod h1:cz+aTbrPOrUb4q7XlbU9ygM+/jj0fzG6c1xBZuNvfVA= +github.com/rivo/uniseg v0.2.0 h1:S1pD9weZBuJdFmowNwbpi7BJ8TNftyUImj/0WQi72jY= +github.com/rivo/uniseg v0.2.0/go.mod h1:J6wj4VEh+S6ZtnVlnTBMWIodfgj8LQOQFoIToxlJtxc= +github.com/rogpeppe/go-internal v1.9.0 h1:73kH8U+JUqXU8lRuOHeVHaa/SZPifC7BkcraZVejAe8= +github.com/rogpeppe/go-internal v1.9.0/go.mod h1:WtVeX8xhTBvf0smdhujwtBcq4Qrzq/fJaraNFVN+nFs= +github.com/rs/cors v1.7.0 h1:+88SsELBHx5r+hZ8TCkggzSstaWNbDvThkVK8H6f9ik= +github.com/rs/cors v1.7.0/go.mod h1:gFx+x8UowdsKA9AchylcLynDq+nNFfI8FkUZdN/jGCU= +github.com/russross/blackfriday/v2 v2.1.0 h1:JIOH55/0cWyOuilr9/qlrm0BSXldqnqwMsf35Ld67mk= +github.com/russross/blackfriday/v2 v2.1.0/go.mod h1:+Rmxgy9KzJVeS9/2gXHxylqXiyQDYRxCVz55jmeOWTM= +github.com/shirou/gopsutil v3.21.4-0.20210419000835-c7a38de76ee5+incompatible h1:Bn1aCHHRnjv4Bl16T8rcaFjYSrGrIZvpiGO6P3Q4GpU= +github.com/shirou/gopsutil v3.21.4-0.20210419000835-c7a38de76ee5+incompatible/go.mod h1:5b4v6he4MtMOwMlS0TUMTu2PcXUg8+E1lC7eC3UO/RA= +github.com/status-im/keycard-go v0.2.0 h1:QDLFswOQu1r5jsycloeQh3bVU8n/NatHHaZobtDnDzA= +github.com/status-im/keycard-go v0.2.0/go.mod h1:wlp8ZLbsmrF6g6WjugPAx+IzoLrkdf9+mHxBEeo3Hbg= +github.com/stretchr/testify v1.8.4 h1:CcVxjf3Q8PM0mHUKJCdn+eZZtm5yQwehR5yeSVQQcUk= +github.com/stretchr/testify v1.8.4/go.mod h1:sz/lmYIOXD/1dqDmKjjqLyZ2RngseejIcXlSw2iwfAo= +github.com/supranational/blst v0.3.11 h1:LyU6FolezeWAhvQk0k6O/d49jqgO52MSDDfYgbeoEm4= +github.com/supranational/blst v0.3.11/go.mod h1:jZJtfjgudtNl4en1tzwPIV3KjUnQUvG3/j+w+fVonLw= +github.com/syndtr/goleveldb v1.0.1-0.20210819022825-2ae1ddf74ef7 h1:epCh84lMvA70Z7CTTCmYQn2CKbY8j86K7/FAIr141uY= +github.com/syndtr/goleveldb v1.0.1-0.20210819022825-2ae1ddf74ef7/go.mod h1:q4W45IWZaF22tdD+VEXcAWRA037jwmWEB5VWYORlTpc= +github.com/tklauser/go-sysconf v0.3.12 h1:0QaGUFOdQaIVdPgfITYzaTegZvdCjmYO52cSFAEVmqU= +github.com/tklauser/go-sysconf v0.3.12/go.mod h1:Ho14jnntGE1fpdOqQEEaiKRpvIavV0hSfmBq8nJbHYI= +github.com/tklauser/numcpus v0.6.1 h1:ng9scYS7az0Bk4OZLvrNXNSAO2Pxr1XXRAPyjhIx+Fk= +github.com/tklauser/numcpus v0.6.1/go.mod h1:1XfjsgE2zo8GVw7POkMbHENHzVg3GzmoZ9fESEdAacY= +github.com/tyler-smith/go-bip39 v1.1.0 h1:5eUemwrMargf3BSLRRCalXT93Ns6pQJIjYQN2nyfOP8= +github.com/tyler-smith/go-bip39 v1.1.0/go.mod h1:gUYDtqQw1JS3ZJ8UWVcGTGqqr6YIN3CWg+kkNaLt55U= +github.com/urfave/cli/v2 v2.25.7 h1:VAzn5oq403l5pHjc4OhD54+XGO9cdKVL/7lDjF+iKUs= +github.com/urfave/cli/v2 v2.25.7/go.mod h1:8qnjx1vcq5s2/wpsqoZFndg2CE5tNFyrTvS6SinrnYQ= +github.com/xrash/smetrics v0.0.0-20201216005158-039620a65673 h1:bAn7/zixMGCfxrRTfdpNzjtPYqr8smhKouy9mxVdGPU= +github.com/xrash/smetrics v0.0.0-20201216005158-039620a65673/go.mod h1:N3UwUGtsrSj3ccvlPHLoLsHnpR27oXr4ZE984MbSER8= +golang.org/x/crypto v0.17.0 h1:r8bRNjWL3GshPW3gkd+RpvzWrZAwPS49OmTGZ/uhM4k= +golang.org/x/crypto v0.17.0/go.mod h1:gCAAfMLgwOJRpTjQ2zCCt2OcSfYMTeZVSRtQlPC7Nq4= +golang.org/x/exp v0.0.0-20231110203233-9a3e6036ecaa h1:FRnLl4eNAQl8hwxVVC17teOw8kdjVDVAiFMtgUdTSRQ= +golang.org/x/exp v0.0.0-20231110203233-9a3e6036ecaa/go.mod h1:zk2irFbV9DP96SEBUUAy67IdHUaZuSnrz1n472HUCLE= +golang.org/x/mod v0.14.0 h1:dGoOF9QVLYng8IHTm7BAyWqCqSheQ5pYWGhzW00YJr0= +golang.org/x/mod v0.14.0/go.mod h1:hTbmBsO62+eylJbnUtE2MGJUyE7QWk4xUqPFrRgJ+7c= +golang.org/x/sync v0.5.0 h1:60k92dhOjHxJkrqnwsfl8KuaHbn/5dl0lUPUklKo3qE= +golang.org/x/sync v0.5.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk= +golang.org/x/sys v0.0.0-20190916202348-b4ddaad3f8a3/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20220908164124-27713097b956/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.8.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.11.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.15.0 h1:h48lPFYpsTvQJZF4EKyI4aLHaev3CxivZmv7yZig9pc= +golang.org/x/sys v0.15.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA= +golang.org/x/text v0.14.0 h1:ScX5w1eTa3QqT8oi6+ziP7dTV1S2+ALU0bI+0zXKWiQ= +golang.org/x/text v0.14.0/go.mod h1:18ZOQIKpY8NJVqYksKHtTdi31H5itFRjB5/qKTNYzSU= +golang.org/x/time v0.3.0 h1:rg5rLMjNzMS1RkNLzCG38eapWhnYLFYXDXj2gOlr8j4= +golang.org/x/time v0.3.0/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ= +golang.org/x/tools v0.15.0 h1:zdAyfUGbYmuVokhzVmghFl2ZJh5QhcfebBgmVPFYA+8= +golang.org/x/tools v0.15.0/go.mod h1:hpksKq4dtpQWS1uQ61JkdqWM3LscIS6Slf+VVkm+wQk= +google.golang.org/protobuf v1.27.1 h1:SnqbnDw1V7RiZcXPx5MEeqPv2s79L9i7BJUlG/+RurQ= +google.golang.org/protobuf v1.27.1/go.mod h1:9q0QmTI4eRPtz6boOQmLYwt+qCgq0jsYwAQnmE0givc= +gopkg.in/natefinch/lumberjack.v2 v2.0.0 h1:1Lc07Kr7qY4U2YPouBjpCLxpiyxIVoxqXgkXLknAOE8= +gopkg.in/natefinch/lumberjack.v2 v2.0.0/go.mod h1:l0ndWWf7gzL7RNwBG7wST/UCcT4T24xpD6X8LsfU/+k= +gopkg.in/yaml.v2 v2.4.0 h1:D8xgwECY7CYvx+Y2n4sBz93Jn9JRvxdiyyo8CTfuKaY= +gopkg.in/yaml.v2 v2.4.0/go.mod h1:RDklbk79AGWmwhnvt/jBztapEOGDOx6ZbXqjP6csGnQ= +gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA= +gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= +rsc.io/tmplfunc v0.0.3 h1:53XFQh69AfOa8Tw0Jm7t+GV7KZhOi6jzsCzTtKbMvzU= +rsc.io/tmplfunc v0.0.3/go.mod h1:AG3sTPzElb1Io3Yg4voV9AGZJuleGAwaVRxL9M49PhA= diff --git a/docs/crypto/zkCTF/day1/Ethereal/mint-client/main.go b/docs/crypto/zkCTF/day1/Ethereal/mint-client/main.go new file mode 100644 index 0000000..6c2345d --- /dev/null +++ b/docs/crypto/zkCTF/day1/Ethereal/mint-client/main.go @@ -0,0 +1,203 @@ +package main + +import ( + "encoding/json" + "flag" + "fmt" + "math/big" + "os" + "strconv" + "zk/mint/mint" + "zk/mint/utils" + + "github.com/consensys/gnark-crypto/ecc/bn254" + "github.com/consensys/gnark-crypto/ecc/bn254/fr" + "github.com/consensys/gnark-crypto/ecc/bn254/fr/kzg" + "github.com/davecgh/go-spew/spew" + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/ethclient" +) + +var ( + SRS kzg.SRS +) + +const ( + SRS_SIZE = 16 +) + +func panicErr(err error) { + if err != nil { + panic(err) + } +} + +func loadSRSFromContract(mintContract *mint.MintCaller) *kzg.SRS { + SRS := kzg.SRS{ + Pk: kzg.ProvingKey{ + G1: make([]bn254.G1Affine, SRS_SIZE), + }, + Vk: kzg.VerifyingKey{ + G2: [2]bn254.G2Affine{}, + G1: bn254.G1Affine{}, + }, + } + for i := 0; i < SRS_SIZE; i++ { + g1_x, err := mintContract.SRSG1X(nil, big.NewInt(int64(i))) + panicErr(err) + SRS.Pk.G1[i].X.SetBigInt(g1_x) + g1_y, err := mintContract.SRSG1Y(nil, big.NewInt(int64(i))) + panicErr(err) + SRS.Pk.G1[i].Y.SetBigInt(g1_y) + } + SRS.Vk.G1.X.Set(&SRS.Pk.G1[0].X) + SRS.Vk.G1.Y.Set(&SRS.Pk.G1[0].Y) + + zero := big.NewInt(0) + one := big.NewInt(1) + g2_x0_0, err := mintContract.SRSG2X0(nil, zero) + panicErr(err) + SRS.Vk.G2[0].X.A0.SetBigInt(g2_x0_0) + g2_x0_1, err := mintContract.SRSG2X0(nil, one) + panicErr(err) + SRS.Vk.G2[0].X.A1.SetBigInt(g2_x0_1) + + g2_x1_0, err := mintContract.SRSG2X1(nil, zero) + panicErr(err) + SRS.Vk.G2[1].X.A0.SetBigInt(g2_x1_0) + g2_x1_1, err := mintContract.SRSG2X1(nil, one) + panicErr(err) + SRS.Vk.G2[1].X.A1.SetBigInt(g2_x1_1) + + g2_y0_0, err := mintContract.SRSG2Y0(nil, zero) + panicErr(err) + SRS.Vk.G2[0].Y.A0.SetBigInt(g2_y0_0) + g2_y0_1, err := mintContract.SRSG2Y0(nil, one) + panicErr(err) + SRS.Vk.G2[0].Y.A1.SetBigInt(g2_y0_1) + + g2_y1_0, err := mintContract.SRSG2Y1(nil, zero) + panicErr(err) + SRS.Vk.G2[1].Y.A0.SetBigInt(g2_y1_0) + g2_y1_1, err := mintContract.SRSG2Y1(nil, one) + panicErr(err) + SRS.Vk.G2[1].Y.A1.SetBigInt(g2_y1_1) + return &SRS +} + +func G1AffineToG1Point(p *bn254.G1Affine) *mint.PairingG1Point { + var X, Y big.Int + p.X.BigInt(&X) + p.Y.BigInt(&Y) + return &mint.PairingG1Point{ + X: &X, + Y: &Y, + } +} + +func ordinal(n int) string { + suffix := []string{"th", "st", "nd", "rd"} + if n%100 >= 11 && n%100 <= 13 { + return strconv.Itoa(n) + "th" + } + return strconv.Itoa(n) + suffix[n%10%4] +} + +func main() { + var action = flag.String("action", "register", "action to perform") + var contractAddr = flag.String("contract", "", "contract address") + var rpcAddr = flag.String("rpc", "http://127.0.0.1:8545", "rpc address") + // -------------------------------------------------- + // Note: Please change the account and pk to your own + var accountAddr = flag.String("account", "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266", "account address") + var privateKey = flag.String("pk", "0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80", "private key") + // -------------------------------------------------- + flag.Parse() + contractAddress := common.HexToAddress(*contractAddr) + accountAddress := common.HexToAddress(*accountAddr) + ethclient, err := ethclient.Dial(*rpcAddr) + transactor := utils.NewTransactor(ethclient, *privateKey) + + mintContract, err := mint.NewMint(contractAddress, ethclient) + panicErr(err) + + SRS := loadSRSFromContract(&mintContract.MintCaller) + + switch *action { + case "register": + sword := ForgeSword() + bladeCommitment, bladeProof := CraftBladeSignature(sword, SRS) + commitmentPoint := G1AffineToG1Point(&bladeCommitment) + bladeProofPoint := G1AffineToG1Point(&bladeProof.H) + soulBox := G1AffineToG1Point(&bladeProof.PublicKeyG1Aff) + mintContract.Register(transactor, *commitmentPoint, *bladeProofPoint, *soulBox) + f, err := os.OpenFile("sword.json", os.O_CREATE|os.O_WRONLY, 0644) + panicErr(err) + defer f.Close() + f.Truncate(0) + f.Seek(0, 0) + encoder := json.NewEncoder(f) + encoder.SetIndent("", " ") + encoder.Encode(sword) + transactor.Value = big.NewInt(0) + case "replay": + mintContract.Replay(transactor) + case "mint": + var sword []fr.Element + f, err := os.Open("sword.json") + panicErr(err) + defer f.Close() + decoder := json.NewDecoder(f) + err = decoder.Decode(&sword) + panicErr(err) + + nonce, err := mintContract.GetNonce(nil, transactor.From) + panicErr(err) + nonceFr := new(fr.Element) + nonceFr.SetBigInt(nonce) + fmt.Printf("Minting the %s gem\n", ordinal(int(nonce.Int64()))) + proof, err := kzg.Open(sword, *nonceFr, SRS.Pk) + panicErr(err) + proofPoint := G1AffineToG1Point(&proof.H) + + var value big.Int + proof.ClaimedValue.BigInt(&value) + mintContract.Mint(transactor, *proofPoint, &value) + case "query": + accountDeposit, err := mintContract.Deposits(nil, accountAddress) + panicErr(err) + collectedY, err := mintContract.GetCollectedY(nil, accountAddress) + panicErr(err) + spew.Dump(collectedY, accountDeposit) + case "forge": + // 1. load sword info + var sword []fr.Element + f, err := os.Open("sword.json") + panicErr(err) + defer f.Close() + decoder := json.NewDecoder(f) + err = decoder.Decode(&sword) + panicErr(err) + + // 2. forge + bladeCommitment, bladeProof := CraftBladeSignature(sword, SRS) + commitmentPoint := G1AffineToG1Point(&bladeCommitment) + // forge the fake bladeProof + var fakeProof bn254.G1Affine + fakeProof.ScalarMultiplication(&SRS.Pk.G1[0], big.NewInt(114514)) // g^{114514}) + spew.Dump(fakeProof) + fakeProof.Add(&fakeProof, &bladeProof.H) + spew.Dump(fakeProof) + bladeProofPoint := G1AffineToG1Point(&fakeProof) + spew.Dump(bladeProofPoint) + + var fakeSoulBox bn254.G1Affine + fakeSoulBox.ScalarMultiplication(&SRS.Pk.G1[1], big.NewInt(114514)) // g^{\tau * 114514}) + fakeSoulBox.Sub(&bladeProof.PublicKeyG1Aff, &fakeSoulBox) + soulBox := G1AffineToG1Point(&fakeSoulBox) + + // 3. regiter + mintContract.Register(transactor, *commitmentPoint, *bladeProofPoint, *soulBox) + } + +} diff --git a/docs/crypto/zkCTF/day1/Ethereal/mint-client/mint/mint.go b/docs/crypto/zkCTF/day1/Ethereal/mint-client/mint/mint.go new file mode 100644 index 0000000..593edd3 --- /dev/null +++ b/docs/crypto/zkCTF/day1/Ethereal/mint-client/mint/mint.go @@ -0,0 +1,1221 @@ +// Code generated - DO NOT EDIT. +// This file is a generated binding and any manual changes will be lost. + +package mint + +import ( + "errors" + "math/big" + "strings" + + ethereum "github.com/ethereum/go-ethereum" + "github.com/ethereum/go-ethereum/accounts/abi" + "github.com/ethereum/go-ethereum/accounts/abi/bind" + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/core/types" + "github.com/ethereum/go-ethereum/event" +) + +// Reference imports to suppress errors if they are not otherwise used. +var ( + _ = errors.New + _ = big.NewInt + _ = strings.NewReader + _ = ethereum.NotFound + _ = bind.Bind + _ = common.Big1 + _ = types.BloomLookup + _ = event.NewSubscription + _ = abi.ConvertType +) + +// PairingG1Point is an auto generated low-level Go binding around an user-defined struct. +type PairingG1Point struct { + X *big.Int + Y *big.Int +} + +// PairingG2Point is an auto generated low-level Go binding around an user-defined struct. +type PairingG2Point struct { + X [2]*big.Int + Y [2]*big.Int +} + +// MintMetaData contains all meta data concerning the Mint contract. +var MintMetaData = &bind.MetaData{ + ABI: "[{\"type\":\"function\",\"name\":\"SRS_G1_X\",\"inputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"SRS_G1_Y\",\"inputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"SRS_G2_X_0\",\"inputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"SRS_G2_X_1\",\"inputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"SRS_G2_Y_0\",\"inputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"SRS_G2_Y_1\",\"inputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"commit\",\"inputs\":[{\"name\":\"coefficients\",\"type\":\"uint256[]\",\"internalType\":\"uint256[]\"}],\"outputs\":[{\"name\":\"\",\"type\":\"tuple\",\"internalType\":\"structPairing.G1Point\",\"components\":[{\"name\":\"X\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"Y\",\"type\":\"uint256\",\"internalType\":\"uint256\"}]}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"deposits\",\"inputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[{\"name\":\"registered\",\"type\":\"bool\",\"internalType\":\"bool\"},{\"name\":\"nonce\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"commitment\",\"type\":\"tuple\",\"internalType\":\"structPairing.G1Point\",\"components\":[{\"name\":\"X\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"Y\",\"type\":\"uint256\",\"internalType\":\"uint256\"}]},{\"name\":\"publicKey\",\"type\":\"tuple\",\"internalType\":\"structPairing.G1Point\",\"components\":[{\"name\":\"X\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"Y\",\"type\":\"uint256\",\"internalType\":\"uint256\"}]},{\"name\":\"escaped0\",\"type\":\"bool\",\"internalType\":\"bool\"},{\"name\":\"escaped1\",\"type\":\"bool\",\"internalType\":\"bool\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"evalPolyAt\",\"inputs\":[{\"name\":\"_coefficients\",\"type\":\"uint256[]\",\"internalType\":\"uint256[]\"},{\"name\":\"_index\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"pure\"},{\"type\":\"function\",\"name\":\"evaluateBarycentricPolynomial\",\"inputs\":[{\"name\":\"x\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"yValues\",\"type\":\"uint256[]\",\"internalType\":\"uint256[]\"},{\"name\":\"weights\",\"type\":\"uint256[]\",\"internalType\":\"uint256[]\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getBarycentricWeights\",\"inputs\":[{\"name\":\"xValues\",\"type\":\"uint256[]\",\"internalType\":\"uint256[]\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint256[]\",\"internalType\":\"uint256[]\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getCollectedY\",\"inputs\":[{\"name\":\"user\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint256[]\",\"internalType\":\"uint256[]\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getNonce\",\"inputs\":[{\"name\":\"_user\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"mint\",\"inputs\":[{\"name\":\"_proof\",\"type\":\"tuple\",\"internalType\":\"structPairing.G1Point\",\"components\":[{\"name\":\"X\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"Y\",\"type\":\"uint256\",\"internalType\":\"uint256\"}]},{\"name\":\"_value\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"register\",\"inputs\":[{\"name\":\"_commitment\",\"type\":\"tuple\",\"internalType\":\"structPairing.G1Point\",\"components\":[{\"name\":\"X\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"Y\",\"type\":\"uint256\",\"internalType\":\"uint256\"}]},{\"name\":\"_proof\",\"type\":\"tuple\",\"internalType\":\"structPairing.G1Point\",\"components\":[{\"name\":\"X\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"Y\",\"type\":\"uint256\",\"internalType\":\"uint256\"}]},{\"name\":\"_publicKey\",\"type\":\"tuple\",\"internalType\":\"structPairing.G1Point\",\"components\":[{\"name\":\"X\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"Y\",\"type\":\"uint256\",\"internalType\":\"uint256\"}]}],\"outputs\":[],\"stateMutability\":\"payable\"},{\"type\":\"function\",\"name\":\"replay\",\"inputs\":[],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"verify\",\"inputs\":[{\"name\":\"_commitment\",\"type\":\"tuple\",\"internalType\":\"structPairing.G1Point\",\"components\":[{\"name\":\"X\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"Y\",\"type\":\"uint256\",\"internalType\":\"uint256\"}]},{\"name\":\"_proof\",\"type\":\"tuple\",\"internalType\":\"structPairing.G1Point\",\"components\":[{\"name\":\"X\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"Y\",\"type\":\"uint256\",\"internalType\":\"uint256\"}]},{\"name\":\"_index\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"_value\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[{\"name\":\"\",\"type\":\"bool\",\"internalType\":\"bool\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"verifyMulti\",\"inputs\":[{\"name\":\"_commitment\",\"type\":\"tuple\",\"internalType\":\"structPairing.G1Point\",\"components\":[{\"name\":\"X\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"Y\",\"type\":\"uint256\",\"internalType\":\"uint256\"}]},{\"name\":\"_proof\",\"type\":\"tuple\",\"internalType\":\"structPairing.G2Point\",\"components\":[{\"name\":\"X\",\"type\":\"uint256[2]\",\"internalType\":\"uint256[2]\"},{\"name\":\"Y\",\"type\":\"uint256[2]\",\"internalType\":\"uint256[2]\"}]},{\"name\":\"_indices\",\"type\":\"uint256[]\",\"internalType\":\"uint256[]\"},{\"name\":\"_values\",\"type\":\"uint256[]\",\"internalType\":\"uint256[]\"},{\"name\":\"_iCoeffs\",\"type\":\"uint256[]\",\"internalType\":\"uint256[]\"},{\"name\":\"_zCoeffs\",\"type\":\"uint256[]\",\"internalType\":\"uint256[]\"}],\"outputs\":[{\"name\":\"\",\"type\":\"bool\",\"internalType\":\"bool\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"verifyPublicKey\",\"inputs\":[{\"name\":\"_commitment\",\"type\":\"tuple\",\"internalType\":\"structPairing.G1Point\",\"components\":[{\"name\":\"X\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"Y\",\"type\":\"uint256\",\"internalType\":\"uint256\"}]},{\"name\":\"_proof\",\"type\":\"tuple\",\"internalType\":\"structPairing.G1Point\",\"components\":[{\"name\":\"X\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"Y\",\"type\":\"uint256\",\"internalType\":\"uint256\"}]},{\"name\":\"_publicKey\",\"type\":\"tuple\",\"internalType\":\"structPairing.G1Point\",\"components\":[{\"name\":\"X\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"Y\",\"type\":\"uint256\",\"internalType\":\"uint256\"}]}],\"outputs\":[{\"name\":\"\",\"type\":\"bool\",\"internalType\":\"bool\"}],\"stateMutability\":\"view\"},{\"type\":\"event\",\"name\":\"Deposit\",\"inputs\":[{\"name\":\"publicKey\",\"type\":\"tuple\",\"indexed\":true,\"internalType\":\"structPairing.G1Point\",\"components\":[{\"name\":\"X\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"Y\",\"type\":\"uint256\",\"internalType\":\"uint256\"}]},{\"name\":\"commitment\",\"type\":\"tuple\",\"indexed\":false,\"internalType\":\"structPairing.G1Point\",\"components\":[{\"name\":\"X\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"Y\",\"type\":\"uint256\",\"internalType\":\"uint256\"}]},{\"name\":\"timestamp\",\"type\":\"uint256\",\"indexed\":false,\"internalType\":\"uint256\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"Minted\",\"inputs\":[{\"name\":\"user\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"nonce\",\"type\":\"uint256\",\"indexed\":false,\"internalType\":\"uint256\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"Pwned\",\"inputs\":[{\"name\":\"privateKey\",\"type\":\"uint256\",\"indexed\":true,\"internalType\":\"uint256\"}],\"anonymous\":false}]", +} + +// MintABI is the input ABI used to generate the binding from. +// Deprecated: Use MintMetaData.ABI instead. +var MintABI = MintMetaData.ABI + +// Mint is an auto generated Go binding around an Ethereum contract. +type Mint struct { + MintCaller // Read-only binding to the contract + MintTransactor // Write-only binding to the contract + MintFilterer // Log filterer for contract events +} + +// MintCaller is an auto generated read-only Go binding around an Ethereum contract. +type MintCaller struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// MintTransactor is an auto generated write-only Go binding around an Ethereum contract. +type MintTransactor struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// MintFilterer is an auto generated log filtering Go binding around an Ethereum contract events. +type MintFilterer struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// MintSession is an auto generated Go binding around an Ethereum contract, +// with pre-set call and transact options. +type MintSession struct { + Contract *Mint // Generic contract binding to set the session for + CallOpts bind.CallOpts // Call options to use throughout this session + TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session +} + +// MintCallerSession is an auto generated read-only Go binding around an Ethereum contract, +// with pre-set call options. +type MintCallerSession struct { + Contract *MintCaller // Generic contract caller binding to set the session for + CallOpts bind.CallOpts // Call options to use throughout this session +} + +// MintTransactorSession is an auto generated write-only Go binding around an Ethereum contract, +// with pre-set transact options. +type MintTransactorSession struct { + Contract *MintTransactor // Generic contract transactor binding to set the session for + TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session +} + +// MintRaw is an auto generated low-level Go binding around an Ethereum contract. +type MintRaw struct { + Contract *Mint // Generic contract binding to access the raw methods on +} + +// MintCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. +type MintCallerRaw struct { + Contract *MintCaller // Generic read-only contract binding to access the raw methods on +} + +// MintTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. +type MintTransactorRaw struct { + Contract *MintTransactor // Generic write-only contract binding to access the raw methods on +} + +// NewMint creates a new instance of Mint, bound to a specific deployed contract. +func NewMint(address common.Address, backend bind.ContractBackend) (*Mint, error) { + contract, err := bindMint(address, backend, backend, backend) + if err != nil { + return nil, err + } + return &Mint{MintCaller: MintCaller{contract: contract}, MintTransactor: MintTransactor{contract: contract}, MintFilterer: MintFilterer{contract: contract}}, nil +} + +// NewMintCaller creates a new read-only instance of Mint, bound to a specific deployed contract. +func NewMintCaller(address common.Address, caller bind.ContractCaller) (*MintCaller, error) { + contract, err := bindMint(address, caller, nil, nil) + if err != nil { + return nil, err + } + return &MintCaller{contract: contract}, nil +} + +// NewMintTransactor creates a new write-only instance of Mint, bound to a specific deployed contract. +func NewMintTransactor(address common.Address, transactor bind.ContractTransactor) (*MintTransactor, error) { + contract, err := bindMint(address, nil, transactor, nil) + if err != nil { + return nil, err + } + return &MintTransactor{contract: contract}, nil +} + +// NewMintFilterer creates a new log filterer instance of Mint, bound to a specific deployed contract. +func NewMintFilterer(address common.Address, filterer bind.ContractFilterer) (*MintFilterer, error) { + contract, err := bindMint(address, nil, nil, filterer) + if err != nil { + return nil, err + } + return &MintFilterer{contract: contract}, nil +} + +// bindMint binds a generic wrapper to an already deployed contract. +func bindMint(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { + parsed, err := MintMetaData.GetAbi() + if err != nil { + return nil, err + } + return bind.NewBoundContract(address, *parsed, caller, transactor, filterer), nil +} + +// Call invokes the (constant) contract method with params as input values and +// sets the output to result. The result type might be a single field for simple +// returns, a slice of interfaces for anonymous returns and a struct for named +// returns. +func (_Mint *MintRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { + return _Mint.Contract.MintCaller.contract.Call(opts, result, method, params...) +} + +// Transfer initiates a plain transaction to move funds to the contract, calling +// its default method if one is available. +func (_Mint *MintRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _Mint.Contract.MintTransactor.contract.Transfer(opts) +} + +// Transact invokes the (paid) contract method with params as input values. +func (_Mint *MintRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _Mint.Contract.MintTransactor.contract.Transact(opts, method, params...) +} + +// Call invokes the (constant) contract method with params as input values and +// sets the output to result. The result type might be a single field for simple +// returns, a slice of interfaces for anonymous returns and a struct for named +// returns. +func (_Mint *MintCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { + return _Mint.Contract.contract.Call(opts, result, method, params...) +} + +// Transfer initiates a plain transaction to move funds to the contract, calling +// its default method if one is available. +func (_Mint *MintTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _Mint.Contract.contract.Transfer(opts) +} + +// Transact invokes the (paid) contract method with params as input values. +func (_Mint *MintTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _Mint.Contract.contract.Transact(opts, method, params...) +} + +// SRSG1X is a free data retrieval call binding the contract method 0xdd735c0c. +// +// Solidity: function SRS_G1_X(uint256 ) view returns(uint256) +func (_Mint *MintCaller) SRSG1X(opts *bind.CallOpts, arg0 *big.Int) (*big.Int, error) { + var out []interface{} + err := _Mint.contract.Call(opts, &out, "SRS_G1_X", arg0) + + if err != nil { + return *new(*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + + return out0, err + +} + +// SRSG1X is a free data retrieval call binding the contract method 0xdd735c0c. +// +// Solidity: function SRS_G1_X(uint256 ) view returns(uint256) +func (_Mint *MintSession) SRSG1X(arg0 *big.Int) (*big.Int, error) { + return _Mint.Contract.SRSG1X(&_Mint.CallOpts, arg0) +} + +// SRSG1X is a free data retrieval call binding the contract method 0xdd735c0c. +// +// Solidity: function SRS_G1_X(uint256 ) view returns(uint256) +func (_Mint *MintCallerSession) SRSG1X(arg0 *big.Int) (*big.Int, error) { + return _Mint.Contract.SRSG1X(&_Mint.CallOpts, arg0) +} + +// SRSG1Y is a free data retrieval call binding the contract method 0x082a4770. +// +// Solidity: function SRS_G1_Y(uint256 ) view returns(uint256) +func (_Mint *MintCaller) SRSG1Y(opts *bind.CallOpts, arg0 *big.Int) (*big.Int, error) { + var out []interface{} + err := _Mint.contract.Call(opts, &out, "SRS_G1_Y", arg0) + + if err != nil { + return *new(*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + + return out0, err + +} + +// SRSG1Y is a free data retrieval call binding the contract method 0x082a4770. +// +// Solidity: function SRS_G1_Y(uint256 ) view returns(uint256) +func (_Mint *MintSession) SRSG1Y(arg0 *big.Int) (*big.Int, error) { + return _Mint.Contract.SRSG1Y(&_Mint.CallOpts, arg0) +} + +// SRSG1Y is a free data retrieval call binding the contract method 0x082a4770. +// +// Solidity: function SRS_G1_Y(uint256 ) view returns(uint256) +func (_Mint *MintCallerSession) SRSG1Y(arg0 *big.Int) (*big.Int, error) { + return _Mint.Contract.SRSG1Y(&_Mint.CallOpts, arg0) +} + +// SRSG2X0 is a free data retrieval call binding the contract method 0x71c1441e. +// +// Solidity: function SRS_G2_X_0(uint256 ) view returns(uint256) +func (_Mint *MintCaller) SRSG2X0(opts *bind.CallOpts, arg0 *big.Int) (*big.Int, error) { + var out []interface{} + err := _Mint.contract.Call(opts, &out, "SRS_G2_X_0", arg0) + + if err != nil { + return *new(*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + + return out0, err + +} + +// SRSG2X0 is a free data retrieval call binding the contract method 0x71c1441e. +// +// Solidity: function SRS_G2_X_0(uint256 ) view returns(uint256) +func (_Mint *MintSession) SRSG2X0(arg0 *big.Int) (*big.Int, error) { + return _Mint.Contract.SRSG2X0(&_Mint.CallOpts, arg0) +} + +// SRSG2X0 is a free data retrieval call binding the contract method 0x71c1441e. +// +// Solidity: function SRS_G2_X_0(uint256 ) view returns(uint256) +func (_Mint *MintCallerSession) SRSG2X0(arg0 *big.Int) (*big.Int, error) { + return _Mint.Contract.SRSG2X0(&_Mint.CallOpts, arg0) +} + +// SRSG2X1 is a free data retrieval call binding the contract method 0x82a124f6. +// +// Solidity: function SRS_G2_X_1(uint256 ) view returns(uint256) +func (_Mint *MintCaller) SRSG2X1(opts *bind.CallOpts, arg0 *big.Int) (*big.Int, error) { + var out []interface{} + err := _Mint.contract.Call(opts, &out, "SRS_G2_X_1", arg0) + + if err != nil { + return *new(*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + + return out0, err + +} + +// SRSG2X1 is a free data retrieval call binding the contract method 0x82a124f6. +// +// Solidity: function SRS_G2_X_1(uint256 ) view returns(uint256) +func (_Mint *MintSession) SRSG2X1(arg0 *big.Int) (*big.Int, error) { + return _Mint.Contract.SRSG2X1(&_Mint.CallOpts, arg0) +} + +// SRSG2X1 is a free data retrieval call binding the contract method 0x82a124f6. +// +// Solidity: function SRS_G2_X_1(uint256 ) view returns(uint256) +func (_Mint *MintCallerSession) SRSG2X1(arg0 *big.Int) (*big.Int, error) { + return _Mint.Contract.SRSG2X1(&_Mint.CallOpts, arg0) +} + +// SRSG2Y0 is a free data retrieval call binding the contract method 0xa80a0aca. +// +// Solidity: function SRS_G2_Y_0(uint256 ) view returns(uint256) +func (_Mint *MintCaller) SRSG2Y0(opts *bind.CallOpts, arg0 *big.Int) (*big.Int, error) { + var out []interface{} + err := _Mint.contract.Call(opts, &out, "SRS_G2_Y_0", arg0) + + if err != nil { + return *new(*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + + return out0, err + +} + +// SRSG2Y0 is a free data retrieval call binding the contract method 0xa80a0aca. +// +// Solidity: function SRS_G2_Y_0(uint256 ) view returns(uint256) +func (_Mint *MintSession) SRSG2Y0(arg0 *big.Int) (*big.Int, error) { + return _Mint.Contract.SRSG2Y0(&_Mint.CallOpts, arg0) +} + +// SRSG2Y0 is a free data retrieval call binding the contract method 0xa80a0aca. +// +// Solidity: function SRS_G2_Y_0(uint256 ) view returns(uint256) +func (_Mint *MintCallerSession) SRSG2Y0(arg0 *big.Int) (*big.Int, error) { + return _Mint.Contract.SRSG2Y0(&_Mint.CallOpts, arg0) +} + +// SRSG2Y1 is a free data retrieval call binding the contract method 0x7cf50768. +// +// Solidity: function SRS_G2_Y_1(uint256 ) view returns(uint256) +func (_Mint *MintCaller) SRSG2Y1(opts *bind.CallOpts, arg0 *big.Int) (*big.Int, error) { + var out []interface{} + err := _Mint.contract.Call(opts, &out, "SRS_G2_Y_1", arg0) + + if err != nil { + return *new(*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + + return out0, err + +} + +// SRSG2Y1 is a free data retrieval call binding the contract method 0x7cf50768. +// +// Solidity: function SRS_G2_Y_1(uint256 ) view returns(uint256) +func (_Mint *MintSession) SRSG2Y1(arg0 *big.Int) (*big.Int, error) { + return _Mint.Contract.SRSG2Y1(&_Mint.CallOpts, arg0) +} + +// SRSG2Y1 is a free data retrieval call binding the contract method 0x7cf50768. +// +// Solidity: function SRS_G2_Y_1(uint256 ) view returns(uint256) +func (_Mint *MintCallerSession) SRSG2Y1(arg0 *big.Int) (*big.Int, error) { + return _Mint.Contract.SRSG2Y1(&_Mint.CallOpts, arg0) +} + +// Commit is a free data retrieval call binding the contract method 0x59434d4a. +// +// Solidity: function commit(uint256[] coefficients) view returns((uint256,uint256)) +func (_Mint *MintCaller) Commit(opts *bind.CallOpts, coefficients []*big.Int) (PairingG1Point, error) { + var out []interface{} + err := _Mint.contract.Call(opts, &out, "commit", coefficients) + + if err != nil { + return *new(PairingG1Point), err + } + + out0 := *abi.ConvertType(out[0], new(PairingG1Point)).(*PairingG1Point) + + return out0, err + +} + +// Commit is a free data retrieval call binding the contract method 0x59434d4a. +// +// Solidity: function commit(uint256[] coefficients) view returns((uint256,uint256)) +func (_Mint *MintSession) Commit(coefficients []*big.Int) (PairingG1Point, error) { + return _Mint.Contract.Commit(&_Mint.CallOpts, coefficients) +} + +// Commit is a free data retrieval call binding the contract method 0x59434d4a. +// +// Solidity: function commit(uint256[] coefficients) view returns((uint256,uint256)) +func (_Mint *MintCallerSession) Commit(coefficients []*big.Int) (PairingG1Point, error) { + return _Mint.Contract.Commit(&_Mint.CallOpts, coefficients) +} + +// Deposits is a free data retrieval call binding the contract method 0xfc7e286d. +// +// Solidity: function deposits(address ) view returns(bool registered, uint256 nonce, (uint256,uint256) commitment, (uint256,uint256) publicKey, bool escaped0, bool escaped1) +func (_Mint *MintCaller) Deposits(opts *bind.CallOpts, arg0 common.Address) (struct { + Registered bool + Nonce *big.Int + Commitment PairingG1Point + PublicKey PairingG1Point + Escaped0 bool + Escaped1 bool +}, error) { + var out []interface{} + err := _Mint.contract.Call(opts, &out, "deposits", arg0) + + outstruct := new(struct { + Registered bool + Nonce *big.Int + Commitment PairingG1Point + PublicKey PairingG1Point + Escaped0 bool + Escaped1 bool + }) + if err != nil { + return *outstruct, err + } + + outstruct.Registered = *abi.ConvertType(out[0], new(bool)).(*bool) + outstruct.Nonce = *abi.ConvertType(out[1], new(*big.Int)).(**big.Int) + outstruct.Commitment = *abi.ConvertType(out[2], new(PairingG1Point)).(*PairingG1Point) + outstruct.PublicKey = *abi.ConvertType(out[3], new(PairingG1Point)).(*PairingG1Point) + outstruct.Escaped0 = *abi.ConvertType(out[4], new(bool)).(*bool) + outstruct.Escaped1 = *abi.ConvertType(out[5], new(bool)).(*bool) + + return *outstruct, err + +} + +// Deposits is a free data retrieval call binding the contract method 0xfc7e286d. +// +// Solidity: function deposits(address ) view returns(bool registered, uint256 nonce, (uint256,uint256) commitment, (uint256,uint256) publicKey, bool escaped0, bool escaped1) +func (_Mint *MintSession) Deposits(arg0 common.Address) (struct { + Registered bool + Nonce *big.Int + Commitment PairingG1Point + PublicKey PairingG1Point + Escaped0 bool + Escaped1 bool +}, error) { + return _Mint.Contract.Deposits(&_Mint.CallOpts, arg0) +} + +// Deposits is a free data retrieval call binding the contract method 0xfc7e286d. +// +// Solidity: function deposits(address ) view returns(bool registered, uint256 nonce, (uint256,uint256) commitment, (uint256,uint256) publicKey, bool escaped0, bool escaped1) +func (_Mint *MintCallerSession) Deposits(arg0 common.Address) (struct { + Registered bool + Nonce *big.Int + Commitment PairingG1Point + PublicKey PairingG1Point + Escaped0 bool + Escaped1 bool +}, error) { + return _Mint.Contract.Deposits(&_Mint.CallOpts, arg0) +} + +// EvalPolyAt is a free data retrieval call binding the contract method 0xc1eb466c. +// +// Solidity: function evalPolyAt(uint256[] _coefficients, uint256 _index) pure returns(uint256) +func (_Mint *MintCaller) EvalPolyAt(opts *bind.CallOpts, _coefficients []*big.Int, _index *big.Int) (*big.Int, error) { + var out []interface{} + err := _Mint.contract.Call(opts, &out, "evalPolyAt", _coefficients, _index) + + if err != nil { + return *new(*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + + return out0, err + +} + +// EvalPolyAt is a free data retrieval call binding the contract method 0xc1eb466c. +// +// Solidity: function evalPolyAt(uint256[] _coefficients, uint256 _index) pure returns(uint256) +func (_Mint *MintSession) EvalPolyAt(_coefficients []*big.Int, _index *big.Int) (*big.Int, error) { + return _Mint.Contract.EvalPolyAt(&_Mint.CallOpts, _coefficients, _index) +} + +// EvalPolyAt is a free data retrieval call binding the contract method 0xc1eb466c. +// +// Solidity: function evalPolyAt(uint256[] _coefficients, uint256 _index) pure returns(uint256) +func (_Mint *MintCallerSession) EvalPolyAt(_coefficients []*big.Int, _index *big.Int) (*big.Int, error) { + return _Mint.Contract.EvalPolyAt(&_Mint.CallOpts, _coefficients, _index) +} + +// EvaluateBarycentricPolynomial is a free data retrieval call binding the contract method 0x0e3d9b93. +// +// Solidity: function evaluateBarycentricPolynomial(uint256 x, uint256[] yValues, uint256[] weights) view returns(uint256) +func (_Mint *MintCaller) EvaluateBarycentricPolynomial(opts *bind.CallOpts, x *big.Int, yValues []*big.Int, weights []*big.Int) (*big.Int, error) { + var out []interface{} + err := _Mint.contract.Call(opts, &out, "evaluateBarycentricPolynomial", x, yValues, weights) + + if err != nil { + return *new(*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + + return out0, err + +} + +// EvaluateBarycentricPolynomial is a free data retrieval call binding the contract method 0x0e3d9b93. +// +// Solidity: function evaluateBarycentricPolynomial(uint256 x, uint256[] yValues, uint256[] weights) view returns(uint256) +func (_Mint *MintSession) EvaluateBarycentricPolynomial(x *big.Int, yValues []*big.Int, weights []*big.Int) (*big.Int, error) { + return _Mint.Contract.EvaluateBarycentricPolynomial(&_Mint.CallOpts, x, yValues, weights) +} + +// EvaluateBarycentricPolynomial is a free data retrieval call binding the contract method 0x0e3d9b93. +// +// Solidity: function evaluateBarycentricPolynomial(uint256 x, uint256[] yValues, uint256[] weights) view returns(uint256) +func (_Mint *MintCallerSession) EvaluateBarycentricPolynomial(x *big.Int, yValues []*big.Int, weights []*big.Int) (*big.Int, error) { + return _Mint.Contract.EvaluateBarycentricPolynomial(&_Mint.CallOpts, x, yValues, weights) +} + +// GetBarycentricWeights is a free data retrieval call binding the contract method 0x07a4d15d. +// +// Solidity: function getBarycentricWeights(uint256[] xValues) view returns(uint256[]) +func (_Mint *MintCaller) GetBarycentricWeights(opts *bind.CallOpts, xValues []*big.Int) ([]*big.Int, error) { + var out []interface{} + err := _Mint.contract.Call(opts, &out, "getBarycentricWeights", xValues) + + if err != nil { + return *new([]*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new([]*big.Int)).(*[]*big.Int) + + return out0, err + +} + +// GetBarycentricWeights is a free data retrieval call binding the contract method 0x07a4d15d. +// +// Solidity: function getBarycentricWeights(uint256[] xValues) view returns(uint256[]) +func (_Mint *MintSession) GetBarycentricWeights(xValues []*big.Int) ([]*big.Int, error) { + return _Mint.Contract.GetBarycentricWeights(&_Mint.CallOpts, xValues) +} + +// GetBarycentricWeights is a free data retrieval call binding the contract method 0x07a4d15d. +// +// Solidity: function getBarycentricWeights(uint256[] xValues) view returns(uint256[]) +func (_Mint *MintCallerSession) GetBarycentricWeights(xValues []*big.Int) ([]*big.Int, error) { + return _Mint.Contract.GetBarycentricWeights(&_Mint.CallOpts, xValues) +} + +// GetCollectedY is a free data retrieval call binding the contract method 0x8068d27d. +// +// Solidity: function getCollectedY(address user) view returns(uint256[]) +func (_Mint *MintCaller) GetCollectedY(opts *bind.CallOpts, user common.Address) ([]*big.Int, error) { + var out []interface{} + err := _Mint.contract.Call(opts, &out, "getCollectedY", user) + + if err != nil { + return *new([]*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new([]*big.Int)).(*[]*big.Int) + + return out0, err + +} + +// GetCollectedY is a free data retrieval call binding the contract method 0x8068d27d. +// +// Solidity: function getCollectedY(address user) view returns(uint256[]) +func (_Mint *MintSession) GetCollectedY(user common.Address) ([]*big.Int, error) { + return _Mint.Contract.GetCollectedY(&_Mint.CallOpts, user) +} + +// GetCollectedY is a free data retrieval call binding the contract method 0x8068d27d. +// +// Solidity: function getCollectedY(address user) view returns(uint256[]) +func (_Mint *MintCallerSession) GetCollectedY(user common.Address) ([]*big.Int, error) { + return _Mint.Contract.GetCollectedY(&_Mint.CallOpts, user) +} + +// GetNonce is a free data retrieval call binding the contract method 0x2d0335ab. +// +// Solidity: function getNonce(address _user) view returns(uint256) +func (_Mint *MintCaller) GetNonce(opts *bind.CallOpts, _user common.Address) (*big.Int, error) { + var out []interface{} + err := _Mint.contract.Call(opts, &out, "getNonce", _user) + + if err != nil { + return *new(*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + + return out0, err + +} + +// GetNonce is a free data retrieval call binding the contract method 0x2d0335ab. +// +// Solidity: function getNonce(address _user) view returns(uint256) +func (_Mint *MintSession) GetNonce(_user common.Address) (*big.Int, error) { + return _Mint.Contract.GetNonce(&_Mint.CallOpts, _user) +} + +// GetNonce is a free data retrieval call binding the contract method 0x2d0335ab. +// +// Solidity: function getNonce(address _user) view returns(uint256) +func (_Mint *MintCallerSession) GetNonce(_user common.Address) (*big.Int, error) { + return _Mint.Contract.GetNonce(&_Mint.CallOpts, _user) +} + +// Verify is a free data retrieval call binding the contract method 0x903ae890. +// +// Solidity: function verify((uint256,uint256) _commitment, (uint256,uint256) _proof, uint256 _index, uint256 _value) view returns(bool) +func (_Mint *MintCaller) Verify(opts *bind.CallOpts, _commitment PairingG1Point, _proof PairingG1Point, _index *big.Int, _value *big.Int) (bool, error) { + var out []interface{} + err := _Mint.contract.Call(opts, &out, "verify", _commitment, _proof, _index, _value) + + if err != nil { + return *new(bool), err + } + + out0 := *abi.ConvertType(out[0], new(bool)).(*bool) + + return out0, err + +} + +// Verify is a free data retrieval call binding the contract method 0x903ae890. +// +// Solidity: function verify((uint256,uint256) _commitment, (uint256,uint256) _proof, uint256 _index, uint256 _value) view returns(bool) +func (_Mint *MintSession) Verify(_commitment PairingG1Point, _proof PairingG1Point, _index *big.Int, _value *big.Int) (bool, error) { + return _Mint.Contract.Verify(&_Mint.CallOpts, _commitment, _proof, _index, _value) +} + +// Verify is a free data retrieval call binding the contract method 0x903ae890. +// +// Solidity: function verify((uint256,uint256) _commitment, (uint256,uint256) _proof, uint256 _index, uint256 _value) view returns(bool) +func (_Mint *MintCallerSession) Verify(_commitment PairingG1Point, _proof PairingG1Point, _index *big.Int, _value *big.Int) (bool, error) { + return _Mint.Contract.Verify(&_Mint.CallOpts, _commitment, _proof, _index, _value) +} + +// VerifyMulti is a free data retrieval call binding the contract method 0x87a3b8d9. +// +// Solidity: function verifyMulti((uint256,uint256) _commitment, (uint256[2],uint256[2]) _proof, uint256[] _indices, uint256[] _values, uint256[] _iCoeffs, uint256[] _zCoeffs) view returns(bool) +func (_Mint *MintCaller) VerifyMulti(opts *bind.CallOpts, _commitment PairingG1Point, _proof PairingG2Point, _indices []*big.Int, _values []*big.Int, _iCoeffs []*big.Int, _zCoeffs []*big.Int) (bool, error) { + var out []interface{} + err := _Mint.contract.Call(opts, &out, "verifyMulti", _commitment, _proof, _indices, _values, _iCoeffs, _zCoeffs) + + if err != nil { + return *new(bool), err + } + + out0 := *abi.ConvertType(out[0], new(bool)).(*bool) + + return out0, err + +} + +// VerifyMulti is a free data retrieval call binding the contract method 0x87a3b8d9. +// +// Solidity: function verifyMulti((uint256,uint256) _commitment, (uint256[2],uint256[2]) _proof, uint256[] _indices, uint256[] _values, uint256[] _iCoeffs, uint256[] _zCoeffs) view returns(bool) +func (_Mint *MintSession) VerifyMulti(_commitment PairingG1Point, _proof PairingG2Point, _indices []*big.Int, _values []*big.Int, _iCoeffs []*big.Int, _zCoeffs []*big.Int) (bool, error) { + return _Mint.Contract.VerifyMulti(&_Mint.CallOpts, _commitment, _proof, _indices, _values, _iCoeffs, _zCoeffs) +} + +// VerifyMulti is a free data retrieval call binding the contract method 0x87a3b8d9. +// +// Solidity: function verifyMulti((uint256,uint256) _commitment, (uint256[2],uint256[2]) _proof, uint256[] _indices, uint256[] _values, uint256[] _iCoeffs, uint256[] _zCoeffs) view returns(bool) +func (_Mint *MintCallerSession) VerifyMulti(_commitment PairingG1Point, _proof PairingG2Point, _indices []*big.Int, _values []*big.Int, _iCoeffs []*big.Int, _zCoeffs []*big.Int) (bool, error) { + return _Mint.Contract.VerifyMulti(&_Mint.CallOpts, _commitment, _proof, _indices, _values, _iCoeffs, _zCoeffs) +} + +// VerifyPublicKey is a free data retrieval call binding the contract method 0x1c354fe5. +// +// Solidity: function verifyPublicKey((uint256,uint256) _commitment, (uint256,uint256) _proof, (uint256,uint256) _publicKey) view returns(bool) +func (_Mint *MintCaller) VerifyPublicKey(opts *bind.CallOpts, _commitment PairingG1Point, _proof PairingG1Point, _publicKey PairingG1Point) (bool, error) { + var out []interface{} + err := _Mint.contract.Call(opts, &out, "verifyPublicKey", _commitment, _proof, _publicKey) + + if err != nil { + return *new(bool), err + } + + out0 := *abi.ConvertType(out[0], new(bool)).(*bool) + + return out0, err + +} + +// VerifyPublicKey is a free data retrieval call binding the contract method 0x1c354fe5. +// +// Solidity: function verifyPublicKey((uint256,uint256) _commitment, (uint256,uint256) _proof, (uint256,uint256) _publicKey) view returns(bool) +func (_Mint *MintSession) VerifyPublicKey(_commitment PairingG1Point, _proof PairingG1Point, _publicKey PairingG1Point) (bool, error) { + return _Mint.Contract.VerifyPublicKey(&_Mint.CallOpts, _commitment, _proof, _publicKey) +} + +// VerifyPublicKey is a free data retrieval call binding the contract method 0x1c354fe5. +// +// Solidity: function verifyPublicKey((uint256,uint256) _commitment, (uint256,uint256) _proof, (uint256,uint256) _publicKey) view returns(bool) +func (_Mint *MintCallerSession) VerifyPublicKey(_commitment PairingG1Point, _proof PairingG1Point, _publicKey PairingG1Point) (bool, error) { + return _Mint.Contract.VerifyPublicKey(&_Mint.CallOpts, _commitment, _proof, _publicKey) +} + +// Mint is a paid mutator transaction binding the contract method 0x46409539. +// +// Solidity: function mint((uint256,uint256) _proof, uint256 _value) returns() +func (_Mint *MintTransactor) Mint(opts *bind.TransactOpts, _proof PairingG1Point, _value *big.Int) (*types.Transaction, error) { + return _Mint.contract.Transact(opts, "mint", _proof, _value) +} + +// Mint is a paid mutator transaction binding the contract method 0x46409539. +// +// Solidity: function mint((uint256,uint256) _proof, uint256 _value) returns() +func (_Mint *MintSession) Mint(_proof PairingG1Point, _value *big.Int) (*types.Transaction, error) { + return _Mint.Contract.Mint(&_Mint.TransactOpts, _proof, _value) +} + +// Mint is a paid mutator transaction binding the contract method 0x46409539. +// +// Solidity: function mint((uint256,uint256) _proof, uint256 _value) returns() +func (_Mint *MintTransactorSession) Mint(_proof PairingG1Point, _value *big.Int) (*types.Transaction, error) { + return _Mint.Contract.Mint(&_Mint.TransactOpts, _proof, _value) +} + +// Register is a paid mutator transaction binding the contract method 0x42a67927. +// +// Solidity: function register((uint256,uint256) _commitment, (uint256,uint256) _proof, (uint256,uint256) _publicKey) payable returns() +func (_Mint *MintTransactor) Register(opts *bind.TransactOpts, _commitment PairingG1Point, _proof PairingG1Point, _publicKey PairingG1Point) (*types.Transaction, error) { + return _Mint.contract.Transact(opts, "register", _commitment, _proof, _publicKey) +} + +// Register is a paid mutator transaction binding the contract method 0x42a67927. +// +// Solidity: function register((uint256,uint256) _commitment, (uint256,uint256) _proof, (uint256,uint256) _publicKey) payable returns() +func (_Mint *MintSession) Register(_commitment PairingG1Point, _proof PairingG1Point, _publicKey PairingG1Point) (*types.Transaction, error) { + return _Mint.Contract.Register(&_Mint.TransactOpts, _commitment, _proof, _publicKey) +} + +// Register is a paid mutator transaction binding the contract method 0x42a67927. +// +// Solidity: function register((uint256,uint256) _commitment, (uint256,uint256) _proof, (uint256,uint256) _publicKey) payable returns() +func (_Mint *MintTransactorSession) Register(_commitment PairingG1Point, _proof PairingG1Point, _publicKey PairingG1Point) (*types.Transaction, error) { + return _Mint.Contract.Register(&_Mint.TransactOpts, _commitment, _proof, _publicKey) +} + +// Replay is a paid mutator transaction binding the contract method 0xb5b9cd7f. +// +// Solidity: function replay() returns() +func (_Mint *MintTransactor) Replay(opts *bind.TransactOpts) (*types.Transaction, error) { + return _Mint.contract.Transact(opts, "replay") +} + +// Replay is a paid mutator transaction binding the contract method 0xb5b9cd7f. +// +// Solidity: function replay() returns() +func (_Mint *MintSession) Replay() (*types.Transaction, error) { + return _Mint.Contract.Replay(&_Mint.TransactOpts) +} + +// Replay is a paid mutator transaction binding the contract method 0xb5b9cd7f. +// +// Solidity: function replay() returns() +func (_Mint *MintTransactorSession) Replay() (*types.Transaction, error) { + return _Mint.Contract.Replay(&_Mint.TransactOpts) +} + +// MintDepositIterator is returned from FilterDeposit and is used to iterate over the raw logs and unpacked data for Deposit events raised by the Mint contract. +type MintDepositIterator struct { + Event *MintDeposit // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *MintDepositIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(MintDeposit) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(MintDeposit) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *MintDepositIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *MintDepositIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// MintDeposit represents a Deposit event raised by the Mint contract. +type MintDeposit struct { + PublicKey PairingG1Point + Commitment PairingG1Point + Timestamp *big.Int + Raw types.Log // Blockchain specific contextual infos +} + +// FilterDeposit is a free log retrieval operation binding the contract event 0x5e02e546dec63caecdebd8692b65ccdbaa30e25ac8395aaef548f4ff09b78aa4. +// +// Solidity: event Deposit((uint256,uint256) indexed publicKey, (uint256,uint256) commitment, uint256 timestamp) +func (_Mint *MintFilterer) FilterDeposit(opts *bind.FilterOpts, publicKey []PairingG1Point) (*MintDepositIterator, error) { + + var publicKeyRule []interface{} + for _, publicKeyItem := range publicKey { + publicKeyRule = append(publicKeyRule, publicKeyItem) + } + + logs, sub, err := _Mint.contract.FilterLogs(opts, "Deposit", publicKeyRule) + if err != nil { + return nil, err + } + return &MintDepositIterator{contract: _Mint.contract, event: "Deposit", logs: logs, sub: sub}, nil +} + +// WatchDeposit is a free log subscription operation binding the contract event 0x5e02e546dec63caecdebd8692b65ccdbaa30e25ac8395aaef548f4ff09b78aa4. +// +// Solidity: event Deposit((uint256,uint256) indexed publicKey, (uint256,uint256) commitment, uint256 timestamp) +func (_Mint *MintFilterer) WatchDeposit(opts *bind.WatchOpts, sink chan<- *MintDeposit, publicKey []PairingG1Point) (event.Subscription, error) { + + var publicKeyRule []interface{} + for _, publicKeyItem := range publicKey { + publicKeyRule = append(publicKeyRule, publicKeyItem) + } + + logs, sub, err := _Mint.contract.WatchLogs(opts, "Deposit", publicKeyRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(MintDeposit) + if err := _Mint.contract.UnpackLog(event, "Deposit", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseDeposit is a log parse operation binding the contract event 0x5e02e546dec63caecdebd8692b65ccdbaa30e25ac8395aaef548f4ff09b78aa4. +// +// Solidity: event Deposit((uint256,uint256) indexed publicKey, (uint256,uint256) commitment, uint256 timestamp) +func (_Mint *MintFilterer) ParseDeposit(log types.Log) (*MintDeposit, error) { + event := new(MintDeposit) + if err := _Mint.contract.UnpackLog(event, "Deposit", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// MintMintedIterator is returned from FilterMinted and is used to iterate over the raw logs and unpacked data for Minted events raised by the Mint contract. +type MintMintedIterator struct { + Event *MintMinted // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *MintMintedIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(MintMinted) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(MintMinted) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *MintMintedIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *MintMintedIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// MintMinted represents a Minted event raised by the Mint contract. +type MintMinted struct { + User common.Address + Nonce *big.Int + Raw types.Log // Blockchain specific contextual infos +} + +// FilterMinted is a free log retrieval operation binding the contract event 0x30385c845b448a36257a6a1716e6ad2e1bc2cbe333cde1e69fe849ad6511adfe. +// +// Solidity: event Minted(address indexed user, uint256 nonce) +func (_Mint *MintFilterer) FilterMinted(opts *bind.FilterOpts, user []common.Address) (*MintMintedIterator, error) { + + var userRule []interface{} + for _, userItem := range user { + userRule = append(userRule, userItem) + } + + logs, sub, err := _Mint.contract.FilterLogs(opts, "Minted", userRule) + if err != nil { + return nil, err + } + return &MintMintedIterator{contract: _Mint.contract, event: "Minted", logs: logs, sub: sub}, nil +} + +// WatchMinted is a free log subscription operation binding the contract event 0x30385c845b448a36257a6a1716e6ad2e1bc2cbe333cde1e69fe849ad6511adfe. +// +// Solidity: event Minted(address indexed user, uint256 nonce) +func (_Mint *MintFilterer) WatchMinted(opts *bind.WatchOpts, sink chan<- *MintMinted, user []common.Address) (event.Subscription, error) { + + var userRule []interface{} + for _, userItem := range user { + userRule = append(userRule, userItem) + } + + logs, sub, err := _Mint.contract.WatchLogs(opts, "Minted", userRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(MintMinted) + if err := _Mint.contract.UnpackLog(event, "Minted", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseMinted is a log parse operation binding the contract event 0x30385c845b448a36257a6a1716e6ad2e1bc2cbe333cde1e69fe849ad6511adfe. +// +// Solidity: event Minted(address indexed user, uint256 nonce) +func (_Mint *MintFilterer) ParseMinted(log types.Log) (*MintMinted, error) { + event := new(MintMinted) + if err := _Mint.contract.UnpackLog(event, "Minted", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// MintPwnedIterator is returned from FilterPwned and is used to iterate over the raw logs and unpacked data for Pwned events raised by the Mint contract. +type MintPwnedIterator struct { + Event *MintPwned // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *MintPwnedIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(MintPwned) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(MintPwned) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *MintPwnedIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *MintPwnedIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// MintPwned represents a Pwned event raised by the Mint contract. +type MintPwned struct { + PrivateKey *big.Int + Raw types.Log // Blockchain specific contextual infos +} + +// FilterPwned is a free log retrieval operation binding the contract event 0x2fa98b20b7848fedb78850292ddfee7e5fbe5584f443fad59212d7aadeda16e6. +// +// Solidity: event Pwned(uint256 indexed privateKey) +func (_Mint *MintFilterer) FilterPwned(opts *bind.FilterOpts, privateKey []*big.Int) (*MintPwnedIterator, error) { + + var privateKeyRule []interface{} + for _, privateKeyItem := range privateKey { + privateKeyRule = append(privateKeyRule, privateKeyItem) + } + + logs, sub, err := _Mint.contract.FilterLogs(opts, "Pwned", privateKeyRule) + if err != nil { + return nil, err + } + return &MintPwnedIterator{contract: _Mint.contract, event: "Pwned", logs: logs, sub: sub}, nil +} + +// WatchPwned is a free log subscription operation binding the contract event 0x2fa98b20b7848fedb78850292ddfee7e5fbe5584f443fad59212d7aadeda16e6. +// +// Solidity: event Pwned(uint256 indexed privateKey) +func (_Mint *MintFilterer) WatchPwned(opts *bind.WatchOpts, sink chan<- *MintPwned, privateKey []*big.Int) (event.Subscription, error) { + + var privateKeyRule []interface{} + for _, privateKeyItem := range privateKey { + privateKeyRule = append(privateKeyRule, privateKeyItem) + } + + logs, sub, err := _Mint.contract.WatchLogs(opts, "Pwned", privateKeyRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(MintPwned) + if err := _Mint.contract.UnpackLog(event, "Pwned", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParsePwned is a log parse operation binding the contract event 0x2fa98b20b7848fedb78850292ddfee7e5fbe5584f443fad59212d7aadeda16e6. +// +// Solidity: event Pwned(uint256 indexed privateKey) +func (_Mint *MintFilterer) ParsePwned(log types.Log) (*MintPwned, error) { + event := new(MintPwned) + if err := _Mint.contract.UnpackLog(event, "Pwned", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} diff --git a/docs/crypto/zkCTF/day1/Ethereal/mint-client/sword.json b/docs/crypto/zkCTF/day1/Ethereal/mint-client/sword.json new file mode 100644 index 0000000..10344a2 --- /dev/null +++ b/docs/crypto/zkCTF/day1/Ethereal/mint-client/sword.json @@ -0,0 +1,18 @@ +[ + "17433751266719548307180145735601280788283533801722087307044521867917749321063", + "6070925980941866193819600113413774960805906820871227290927796006887727353913", + "8480048591443071934940130787532743785780345396488345053852529372120084767439", + "4003414289505790707580239309487692891251650513048397813113897901719380125449", + "326565517485966321885024577128507225420941603802582446795622501175465449471", + "7483907499957765837114205060722641140892562030786676929802054062510329458537", + "17361408488004204850912777596873586180360886992540132674726463216696951046712", + "130066398894703023812824289933410737469263474521272304071867209161916703743", + "12583707553462576329235915239971566134757035859930662531616132733024549340232", + "17916518136458868827752890834897490078369474987664082413641852369989805331397", + "1621476856268677962531213265636689889505235372508153688436462631977117725934", + "9476049978243891173162639105282909773475313964245411913294535249191725370761", + "4886546487869513935599279151109188338153776648419997478159654513854292571407", + "3501693733361502383578584757933638390644370160019655186659739174060360120360", + "3125154337898172148285321189703785112883726005601491683771901216987143292613", + "1458714923098436555905784214008599808048587714777765519592829957237712716575" +] diff --git a/docs/crypto/zkCTF/day1/Ethereal/mint-client/types/types.go b/docs/crypto/zkCTF/day1/Ethereal/mint-client/types/types.go new file mode 100644 index 0000000..284561a --- /dev/null +++ b/docs/crypto/zkCTF/day1/Ethereal/mint-client/types/types.go @@ -0,0 +1,17 @@ +package types + +import ( + "github.com/consensys/gnark-crypto/ecc/bn254" + "github.com/consensys/gnark-crypto/ecc/bn254/fr" + "github.com/consensys/gnark-crypto/ecc/bn254/fr/kzg" +) + +type Point struct { + X, Y fr.Element +} + +type Message struct { + Commitment bn254.G1Affine + Text string + Proof kzg.OpeningProof +} diff --git a/docs/crypto/zkCTF/day1/Ethereal/mint-client/utils/transactor.go b/docs/crypto/zkCTF/day1/Ethereal/mint-client/utils/transactor.go new file mode 100644 index 0000000..1cc6bbe --- /dev/null +++ b/docs/crypto/zkCTF/day1/Ethereal/mint-client/utils/transactor.go @@ -0,0 +1,53 @@ +package utils + +import ( + "context" + "crypto/ecdsa" + "log" + "math/big" + "strings" + + "github.com/ethereum/go-ethereum/accounts/abi/bind" + ethcrypto "github.com/ethereum/go-ethereum/crypto" + "github.com/ethereum/go-ethereum/ethclient" +) + +// NewTransactor creates a new transactor with the given private key +func NewTransactor(client *ethclient.Client, pk string) *bind.TransactOpts { + pk = strings.ReplaceAll(pk, "0x", "") + privateKey, err := ethcrypto.HexToECDSA(pk) + if err != nil { + log.Fatal(err) + } + publicKey := privateKey.Public() + publicKeyECDSA, ok := publicKey.(*ecdsa.PublicKey) + if !ok { + log.Fatal("error casting public key to ECDSA") + } + + fromAddress := ethcrypto.PubkeyToAddress(*publicKeyECDSA) + // get nonce + nonce, err := client.PendingNonceAt(context.Background(), fromAddress) + if err != nil { + log.Fatal(err) + } + // get gas price + gasPrice, err := client.SuggestGasPrice(context.Background()) + if err != nil { + log.Fatal(err) + } + // get chain ID + chainID, err := client.NetworkID(context.Background()) + if err != nil { + log.Fatal(err) + } + // get a new transactor + auth, err := bind.NewKeyedTransactorWithChainID(privateKey, chainID) + if err != nil { + log.Fatal(err) + } + auth.Nonce = big.NewInt(int64(nonce)) + auth.GasLimit = uint64(3000000) // in units + auth.GasPrice = gasPrice + return auth +} diff --git a/docs/crypto/zkCTF/day1/Ethereal/mint-contracts/.github/workflows/test.yml b/docs/crypto/zkCTF/day1/Ethereal/mint-contracts/.github/workflows/test.yml new file mode 100644 index 0000000..9282e82 --- /dev/null +++ b/docs/crypto/zkCTF/day1/Ethereal/mint-contracts/.github/workflows/test.yml @@ -0,0 +1,34 @@ +name: test + +on: workflow_dispatch + +env: + FOUNDRY_PROFILE: ci + +jobs: + check: + strategy: + fail-fast: true + + name: Foundry project + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v4 + with: + submodules: recursive + + - name: Install Foundry + uses: foundry-rs/foundry-toolchain@v1 + with: + version: nightly + + - name: Run Forge build + run: | + forge --version + forge build --sizes + id: build + + - name: Run Forge tests + run: | + forge test -vvv + id: test diff --git a/docs/crypto/zkCTF/day1/Ethereal/mint-contracts/.gitignore b/docs/crypto/zkCTF/day1/Ethereal/mint-contracts/.gitignore new file mode 100644 index 0000000..85198aa --- /dev/null +++ b/docs/crypto/zkCTF/day1/Ethereal/mint-contracts/.gitignore @@ -0,0 +1,14 @@ +# Compiler files +cache/ +out/ + +# Ignores development broadcast logs +!/broadcast +/broadcast/*/31337/ +/broadcast/**/dry-run/ + +# Docs +docs/ + +# Dotenv file +.env diff --git a/docs/crypto/zkCTF/day1/Ethereal/mint-contracts/README.md b/docs/crypto/zkCTF/day1/Ethereal/mint-contracts/README.md new file mode 100644 index 0000000..9265b45 --- /dev/null +++ b/docs/crypto/zkCTF/day1/Ethereal/mint-contracts/README.md @@ -0,0 +1,66 @@ +## Foundry + +**Foundry is a blazing fast, portable and modular toolkit for Ethereum application development written in Rust.** + +Foundry consists of: + +- **Forge**: Ethereum testing framework (like Truffle, Hardhat and DappTools). +- **Cast**: Swiss army knife for interacting with EVM smart contracts, sending transactions and getting chain data. +- **Anvil**: Local Ethereum node, akin to Ganache, Hardhat Network. +- **Chisel**: Fast, utilitarian, and verbose solidity REPL. + +## Documentation + +https://book.getfoundry.sh/ + +## Usage + +### Build + +```shell +$ forge build +``` + +### Test + +```shell +$ forge test +``` + +### Format + +```shell +$ forge fmt +``` + +### Gas Snapshots + +```shell +$ forge snapshot +``` + +### Anvil + +```shell +$ anvil +``` + +### Deploy + +```shell +$ forge script script/Counter.s.sol:CounterScript --rpc-url --private-key +``` + +### Cast + +```shell +$ cast +``` + +### Help + +```shell +$ forge --help +$ anvil --help +$ cast --help +``` diff --git a/docs/crypto/zkCTF/day1/Ethereal/mint-contracts/foundry.toml b/docs/crypto/zkCTF/day1/Ethereal/mint-contracts/foundry.toml new file mode 100644 index 0000000..25b918f --- /dev/null +++ b/docs/crypto/zkCTF/day1/Ethereal/mint-contracts/foundry.toml @@ -0,0 +1,6 @@ +[profile.default] +src = "src" +out = "out" +libs = ["lib"] + +# See more config options https://github.com/foundry-rs/foundry/blob/master/crates/config/README.md#all-options diff --git a/docs/crypto/zkCTF/day1/Ethereal/mint-contracts/lib/forge-std/.gitattributes b/docs/crypto/zkCTF/day1/Ethereal/mint-contracts/lib/forge-std/.gitattributes new file mode 100644 index 0000000..27042d4 --- /dev/null +++ b/docs/crypto/zkCTF/day1/Ethereal/mint-contracts/lib/forge-std/.gitattributes @@ -0,0 +1 @@ +src/Vm.sol linguist-generated diff --git a/docs/crypto/zkCTF/day1/Ethereal/mint-contracts/lib/forge-std/.github/workflows/ci.yml b/docs/crypto/zkCTF/day1/Ethereal/mint-contracts/lib/forge-std/.github/workflows/ci.yml new file mode 100644 index 0000000..cb241ae --- /dev/null +++ b/docs/crypto/zkCTF/day1/Ethereal/mint-contracts/lib/forge-std/.github/workflows/ci.yml @@ -0,0 +1,134 @@ +name: CI + +on: + workflow_dispatch: + pull_request: + push: + branches: + - master + +jobs: + build: + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v3 + + - name: Install Foundry + uses: onbjerg/foundry-toolchain@v1 + with: + version: nightly + + - name: Print forge version + run: forge --version + + # Backwards compatibility checks: + # - the oldest and newest version of each supported minor version + # - versions with specific issues + - name: Check compatibility with latest + if: always() + run: | + output=$(forge build --skip test) + + if echo "$output" | grep -q "Warning"; then + echo "$output" + exit 1 + fi + + - name: Check compatibility with 0.8.0 + if: always() + run: | + output=$(forge build --skip test --use solc:0.8.0) + + if echo "$output" | grep -q "Warning"; then + echo "$output" + exit 1 + fi + + - name: Check compatibility with 0.7.6 + if: always() + run: | + output=$(forge build --skip test --use solc:0.7.6) + + if echo "$output" | grep -q "Warning"; then + echo "$output" + exit 1 + fi + + - name: Check compatibility with 0.7.0 + if: always() + run: | + output=$(forge build --skip test --use solc:0.7.0) + + if echo "$output" | grep -q "Warning"; then + echo "$output" + exit 1 + fi + + - name: Check compatibility with 0.6.12 + if: always() + run: | + output=$(forge build --skip test --use solc:0.6.12) + + if echo "$output" | grep -q "Warning"; then + echo "$output" + exit 1 + fi + + - name: Check compatibility with 0.6.2 + if: always() + run: | + output=$(forge build --skip test --use solc:0.6.2) + + if echo "$output" | grep -q "Warning"; then + echo "$output" + exit 1 + fi + + # via-ir compilation time checks. + - name: Measure compilation time of Test with 0.8.17 --via-ir + if: always() + run: forge build --skip test --contracts test/compilation/CompilationTest.sol --use solc:0.8.17 --via-ir + + - name: Measure compilation time of TestBase with 0.8.17 --via-ir + if: always() + run: forge build --skip test --contracts test/compilation/CompilationTestBase.sol --use solc:0.8.17 --via-ir + + - name: Measure compilation time of Script with 0.8.17 --via-ir + if: always() + run: forge build --skip test --contracts test/compilation/CompilationScript.sol --use solc:0.8.17 --via-ir + + - name: Measure compilation time of ScriptBase with 0.8.17 --via-ir + if: always() + run: forge build --skip test --contracts test/compilation/CompilationScriptBase.sol --use solc:0.8.17 --via-ir + + test: + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v3 + + - name: Install Foundry + uses: onbjerg/foundry-toolchain@v1 + with: + version: nightly + + - name: Print forge version + run: forge --version + + - name: Run tests + run: forge test -vvv + + fmt: + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v3 + + - name: Install Foundry + uses: onbjerg/foundry-toolchain@v1 + with: + version: nightly + + - name: Print forge version + run: forge --version + + - name: Check formatting + run: forge fmt --check diff --git a/docs/crypto/zkCTF/day1/Ethereal/mint-contracts/lib/forge-std/.github/workflows/sync.yml b/docs/crypto/zkCTF/day1/Ethereal/mint-contracts/lib/forge-std/.github/workflows/sync.yml new file mode 100644 index 0000000..5a9e9d5 --- /dev/null +++ b/docs/crypto/zkCTF/day1/Ethereal/mint-contracts/lib/forge-std/.github/workflows/sync.yml @@ -0,0 +1,29 @@ +name: Sync Release Branch + +on: + release: + types: + - created + +jobs: + sync-release-branch: + runs-on: ubuntu-latest + if: startsWith(github.event.release.tag_name, 'v1') + steps: + - name: Check out the repo + uses: actions/checkout@v3 + with: + fetch-depth: 0 + ref: v1 + + - name: Configure Git + run: | + git config user.name github-actions[bot] + git config user.email 41898282+github-actions[bot]@users.noreply.github.com + + - name: Sync Release Branch + run: | + git fetch --tags + git checkout v1 + git reset --hard ${GITHUB_REF} + git push --force diff --git a/docs/crypto/zkCTF/day1/Ethereal/mint-contracts/lib/forge-std/.gitignore b/docs/crypto/zkCTF/day1/Ethereal/mint-contracts/lib/forge-std/.gitignore new file mode 100644 index 0000000..756106d --- /dev/null +++ b/docs/crypto/zkCTF/day1/Ethereal/mint-contracts/lib/forge-std/.gitignore @@ -0,0 +1,4 @@ +cache/ +out/ +.vscode +.idea diff --git a/docs/crypto/zkCTF/day1/Ethereal/mint-contracts/lib/forge-std/.gitmodules b/docs/crypto/zkCTF/day1/Ethereal/mint-contracts/lib/forge-std/.gitmodules new file mode 100644 index 0000000..e124719 --- /dev/null +++ b/docs/crypto/zkCTF/day1/Ethereal/mint-contracts/lib/forge-std/.gitmodules @@ -0,0 +1,3 @@ +[submodule "lib/ds-test"] + path = lib/ds-test + url = https://github.com/dapphub/ds-test diff --git a/docs/crypto/zkCTF/day1/Ethereal/mint-contracts/lib/forge-std/LICENSE-APACHE b/docs/crypto/zkCTF/day1/Ethereal/mint-contracts/lib/forge-std/LICENSE-APACHE new file mode 100644 index 0000000..cf01a49 --- /dev/null +++ b/docs/crypto/zkCTF/day1/Ethereal/mint-contracts/lib/forge-std/LICENSE-APACHE @@ -0,0 +1,203 @@ +Copyright Contributors to Forge Standard Library + + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + +TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + +1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + +2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + +3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + +4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + +5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + +6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + +7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + +8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + +9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + +END OF TERMS AND CONDITIONS + +APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + +Copyright [yyyy] [name of copyright owner] + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. diff --git a/docs/crypto/zkCTF/day1/Ethereal/mint-contracts/lib/forge-std/LICENSE-MIT b/docs/crypto/zkCTF/day1/Ethereal/mint-contracts/lib/forge-std/LICENSE-MIT new file mode 100644 index 0000000..28f9830 --- /dev/null +++ b/docs/crypto/zkCTF/day1/Ethereal/mint-contracts/lib/forge-std/LICENSE-MIT @@ -0,0 +1,25 @@ +Copyright Contributors to Forge Standard Library + +Permission is hereby granted, free of charge, to any +person obtaining a copy of this software and associated +documentation files (the "Software"), to deal in the +Software without restriction, including without +limitation the rights to use, copy, modify, merge, +publish, distribute, sublicense, and/or sell copies of +the Software, and to permit persons to whom the Software +is furnished to do so, subject to the following +conditions: + +The above copyright notice and this permission notice +shall be included in all copies or substantial portions +of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF +ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED +TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A +PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT +SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY +CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION +OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR +IN CONNECTION WITH THE SOFTWARE O THE USE OR OTHER +DEALINGS IN THE SOFTWARE.R diff --git a/docs/crypto/zkCTF/day1/Ethereal/mint-contracts/lib/forge-std/README.md b/docs/crypto/zkCTF/day1/Ethereal/mint-contracts/lib/forge-std/README.md new file mode 100644 index 0000000..8494a7d --- /dev/null +++ b/docs/crypto/zkCTF/day1/Ethereal/mint-contracts/lib/forge-std/README.md @@ -0,0 +1,250 @@ +# Forge Standard Library • [![CI status](https://github.com/foundry-rs/forge-std/actions/workflows/ci.yml/badge.svg)](https://github.com/foundry-rs/forge-std/actions/workflows/ci.yml) + +Forge Standard Library is a collection of helpful contracts and libraries for use with [Forge and Foundry](https://github.com/foundry-rs/foundry). It leverages Forge's cheatcodes to make writing tests easier and faster, while improving the UX of cheatcodes. + +**Learn how to use Forge-Std with the [📖 Foundry Book (Forge-Std Guide)](https://book.getfoundry.sh/forge/forge-std.html).** + +## Install + +```bash +forge install foundry-rs/forge-std +``` + +## Contracts +### stdError + +This is a helper contract for errors and reverts. In Forge, this contract is particularly helpful for the `expectRevert` cheatcode, as it provides all compiler builtin errors. + +See the contract itself for all error codes. + +#### Example usage + +```solidity + +import "forge-std/Test.sol"; + +contract TestContract is Test { + ErrorsTest test; + + function setUp() public { + test = new ErrorsTest(); + } + + function testExpectArithmetic() public { + vm.expectRevert(stdError.arithmeticError); + test.arithmeticError(10); + } +} + +contract ErrorsTest { + function arithmeticError(uint256 a) public { + uint256 a = a - 100; + } +} +``` + +### stdStorage + +This is a rather large contract due to all of the overloading to make the UX decent. Primarily, it is a wrapper around the `record` and `accesses` cheatcodes. It can *always* find and write the storage slot(s) associated with a particular variable without knowing the storage layout. The one _major_ caveat to this is while a slot can be found for packed storage variables, we can't write to that variable safely. If a user tries to write to a packed slot, the execution throws an error, unless it is uninitialized (`bytes32(0)`). + +This works by recording all `SLOAD`s and `SSTORE`s during a function call. If there is a single slot read or written to, it immediately returns the slot. Otherwise, behind the scenes, we iterate through and check each one (assuming the user passed in a `depth` parameter). If the variable is a struct, you can pass in a `depth` parameter which is basically the field depth. + +I.e.: +```solidity +struct T { + // depth 0 + uint256 a; + // depth 1 + uint256 b; +} +``` + +#### Example usage + +```solidity +import "forge-std/Test.sol"; + +contract TestContract is Test { + using stdStorage for StdStorage; + + Storage test; + + function setUp() public { + test = new Storage(); + } + + function testFindExists() public { + // Lets say we want to find the slot for the public + // variable `exists`. We just pass in the function selector + // to the `find` command + uint256 slot = stdstore.target(address(test)).sig("exists()").find(); + assertEq(slot, 0); + } + + function testWriteExists() public { + // Lets say we want to write to the slot for the public + // variable `exists`. We just pass in the function selector + // to the `checked_write` command + stdstore.target(address(test)).sig("exists()").checked_write(100); + assertEq(test.exists(), 100); + } + + // It supports arbitrary storage layouts, like assembly based storage locations + function testFindHidden() public { + // `hidden` is a random hash of a bytes, iteration through slots would + // not find it. Our mechanism does + // Also, you can use the selector instead of a string + uint256 slot = stdstore.target(address(test)).sig(test.hidden.selector).find(); + assertEq(slot, uint256(keccak256("my.random.var"))); + } + + // If targeting a mapping, you have to pass in the keys necessary to perform the find + // i.e.: + function testFindMapping() public { + uint256 slot = stdstore + .target(address(test)) + .sig(test.map_addr.selector) + .with_key(address(this)) + .find(); + // in the `Storage` constructor, we wrote that this address' value was 1 in the map + // so when we load the slot, we expect it to be 1 + assertEq(uint(vm.load(address(test), bytes32(slot))), 1); + } + + // If the target is a struct, you can specify the field depth: + function testFindStruct() public { + // NOTE: see the depth parameter - 0 means 0th field, 1 means 1st field, etc. + uint256 slot_for_a_field = stdstore + .target(address(test)) + .sig(test.basicStruct.selector) + .depth(0) + .find(); + + uint256 slot_for_b_field = stdstore + .target(address(test)) + .sig(test.basicStruct.selector) + .depth(1) + .find(); + + assertEq(uint(vm.load(address(test), bytes32(slot_for_a_field))), 1); + assertEq(uint(vm.load(address(test), bytes32(slot_for_b_field))), 2); + } +} + +// A complex storage contract +contract Storage { + struct UnpackedStruct { + uint256 a; + uint256 b; + } + + constructor() { + map_addr[msg.sender] = 1; + } + + uint256 public exists = 1; + mapping(address => uint256) public map_addr; + // mapping(address => Packed) public map_packed; + mapping(address => UnpackedStruct) public map_struct; + mapping(address => mapping(address => uint256)) public deep_map; + mapping(address => mapping(address => UnpackedStruct)) public deep_map_struct; + UnpackedStruct public basicStruct = UnpackedStruct({ + a: 1, + b: 2 + }); + + function hidden() public view returns (bytes32 t) { + // an extremely hidden storage slot + bytes32 slot = keccak256("my.random.var"); + assembly { + t := sload(slot) + } + } +} +``` + +### stdCheats + +This is a wrapper over miscellaneous cheatcodes that need wrappers to be more dev friendly. Currently there are only functions related to `prank`. In general, users may expect ETH to be put into an address on `prank`, but this is not the case for safety reasons. Explicitly this `hoax` function should only be used for address that have expected balances as it will get overwritten. If an address already has ETH, you should just use `prank`. If you want to change that balance explicitly, just use `deal`. If you want to do both, `hoax` is also right for you. + + +#### Example usage: +```solidity + +// SPDX-License-Identifier: MIT +pragma solidity ^0.8.0; + +import "forge-std/Test.sol"; + +// Inherit the stdCheats +contract StdCheatsTest is Test { + Bar test; + function setUp() public { + test = new Bar(); + } + + function testHoax() public { + // we call `hoax`, which gives the target address + // eth and then calls `prank` + hoax(address(1337)); + test.bar{value: 100}(address(1337)); + + // overloaded to allow you to specify how much eth to + // initialize the address with + hoax(address(1337), 1); + test.bar{value: 1}(address(1337)); + } + + function testStartHoax() public { + // we call `startHoax`, which gives the target address + // eth and then calls `startPrank` + // + // it is also overloaded so that you can specify an eth amount + startHoax(address(1337)); + test.bar{value: 100}(address(1337)); + test.bar{value: 100}(address(1337)); + vm.stopPrank(); + test.bar(address(this)); + } +} + +contract Bar { + function bar(address expectedSender) public payable { + require(msg.sender == expectedSender, "!prank"); + } +} +``` + +### Std Assertions + +Expand upon the assertion functions from the `DSTest` library. + +### `console.log` + +Usage follows the same format as [Hardhat](https://hardhat.org/hardhat-network/reference/#console-log). +It's recommended to use `console2.sol` as shown below, as this will show the decoded logs in Forge traces. + +```solidity +// import it indirectly via Test.sol +import "forge-std/Test.sol"; +// or directly import it +import "forge-std/console2.sol"; +... +console2.log(someValue); +``` + +If you need compatibility with Hardhat, you must use the standard `console.sol` instead. +Due to a bug in `console.sol`, logs that use `uint256` or `int256` types will not be properly decoded in Forge traces. + +```solidity +// import it indirectly via Test.sol +import "forge-std/Test.sol"; +// or directly import it +import "forge-std/console.sol"; +... +console.log(someValue); +``` + +## License + +Forge Standard Library is offered under either [MIT](LICENSE-MIT) or [Apache 2.0](LICENSE-APACHE) license. diff --git a/docs/crypto/zkCTF/day1/Ethereal/mint-contracts/lib/forge-std/foundry.toml b/docs/crypto/zkCTF/day1/Ethereal/mint-contracts/lib/forge-std/foundry.toml new file mode 100644 index 0000000..f9679ee --- /dev/null +++ b/docs/crypto/zkCTF/day1/Ethereal/mint-contracts/lib/forge-std/foundry.toml @@ -0,0 +1,21 @@ +[profile.default] +fs_permissions = [{ access = "read-write", path = "./"}] + +[rpc_endpoints] +# The RPC URLs are modified versions of the default for testing initialization. +mainnet = "https://mainnet.infura.io/v3/b1d3925804e74152b316ca7da97060d3" # Different API key. +optimism_goerli = "https://goerli.optimism.io/" # Adds a trailing slash. +arbitrum_one_goerli = "https://goerli-rollup.arbitrum.io/rpc/" # Adds a trailing slash. +needs_undefined_env_var = "${UNDEFINED_RPC_URL_PLACEHOLDER}" + +[fmt] +# These are all the `forge fmt` defaults. +line_length = 120 +tab_width = 4 +bracket_spacing = false +int_types = 'long' +multiline_func_header = 'attributes_first' +quote_style = 'double' +number_underscore = 'preserve' +single_line_statement_blocks = 'preserve' +ignore = ["src/console.sol", "src/console2.sol"] \ No newline at end of file diff --git a/docs/crypto/zkCTF/day1/Ethereal/mint-contracts/lib/forge-std/lib/ds-test/.github/workflows/build.yml b/docs/crypto/zkCTF/day1/Ethereal/mint-contracts/lib/forge-std/lib/ds-test/.github/workflows/build.yml new file mode 100644 index 0000000..d2ff97d --- /dev/null +++ b/docs/crypto/zkCTF/day1/Ethereal/mint-contracts/lib/forge-std/lib/ds-test/.github/workflows/build.yml @@ -0,0 +1,41 @@ +name: "Build" +on: + pull_request: + push: +jobs: + build: + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v3 + - uses: cachix/install-nix-action@v20 + with: + nix_path: nixpkgs=channel:nixos-unstable + extra_nix_config: | + access-tokens = github.com=${{ secrets.GITHUB_TOKEN }} + + - name: setup dapp binary cache + uses: cachix/cachix-action@v12 + with: + name: dapp + + - name: install dapptools + run: nix profile install github:dapphub/dapptools#dapp --accept-flake-config + + - name: install foundry + uses: foundry-rs/foundry-toolchain@v1 + + - name: test with solc-0.5.17 + run: dapp --use solc-0.5.17 test -v + + - name: test with solc-0.6.11 + run: dapp --use solc-0.6.11 test -v + + - name: test with solc-0.7.6 + run: dapp --use solc-0.7.6 test -v + + - name: test with solc-0.8.18 + run: dapp --use solc-0.8.18 test -v + + - name: Run tests with foundry + run: forge test -vvv + diff --git a/docs/crypto/zkCTF/day1/Ethereal/mint-contracts/lib/forge-std/lib/ds-test/.gitignore b/docs/crypto/zkCTF/day1/Ethereal/mint-contracts/lib/forge-std/lib/ds-test/.gitignore new file mode 100644 index 0000000..462a994 --- /dev/null +++ b/docs/crypto/zkCTF/day1/Ethereal/mint-contracts/lib/forge-std/lib/ds-test/.gitignore @@ -0,0 +1,4 @@ +/.dapple +/build +/out +/cache/ diff --git a/docs/crypto/zkCTF/day1/Ethereal/mint-contracts/lib/forge-std/lib/ds-test/LICENSE b/docs/crypto/zkCTF/day1/Ethereal/mint-contracts/lib/forge-std/lib/ds-test/LICENSE new file mode 100644 index 0000000..94a9ed0 --- /dev/null +++ b/docs/crypto/zkCTF/day1/Ethereal/mint-contracts/lib/forge-std/lib/ds-test/LICENSE @@ -0,0 +1,674 @@ + GNU GENERAL PUBLIC LICENSE + Version 3, 29 June 2007 + + Copyright (C) 2007 Free Software Foundation, Inc. + Everyone is permitted to copy and distribute verbatim copies + of this license document, but changing it is not allowed. + + Preamble + + The GNU General Public License is a free, copyleft license for +software and other kinds of works. + + The licenses for most software and other practical works are designed +to take away your freedom to share and change the works. By contrast, +the GNU General Public License is intended to guarantee your freedom to +share and change all versions of a program--to make sure it remains free +software for all its users. We, the Free Software Foundation, use the +GNU General Public License for most of our software; it applies also to +any other work released this way by its authors. You can apply it to +your programs, too. + + When we speak of free software, we are referring to freedom, not +price. Our General Public Licenses are designed to make sure that you +have the freedom to distribute copies of free software (and charge for +them if you wish), that you receive source code or can get it if you +want it, that you can change the software or use pieces of it in new +free programs, and that you know you can do these things. + + To protect your rights, we need to prevent others from denying you +these rights or asking you to surrender the rights. Therefore, you have +certain responsibilities if you distribute copies of the software, or if +you modify it: responsibilities to respect the freedom of others. + + For example, if you distribute copies of such a program, whether +gratis or for a fee, you must pass on to the recipients the same +freedoms that you received. You must make sure that they, too, receive +or can get the source code. And you must show them these terms so they +know their rights. + + Developers that use the GNU GPL protect your rights with two steps: +(1) assert copyright on the software, and (2) offer you this License +giving you legal permission to copy, distribute and/or modify it. + + For the developers' and authors' protection, the GPL clearly explains +that there is no warranty for this free software. For both users' and +authors' sake, the GPL requires that modified versions be marked as +changed, so that their problems will not be attributed erroneously to +authors of previous versions. + + Some devices are designed to deny users access to install or run +modified versions of the software inside them, although the manufacturer +can do so. This is fundamentally incompatible with the aim of +protecting users' freedom to change the software. The systematic +pattern of such abuse occurs in the area of products for individuals to +use, which is precisely where it is most unacceptable. Therefore, we +have designed this version of the GPL to prohibit the practice for those +products. If such problems arise substantially in other domains, we +stand ready to extend this provision to those domains in future versions +of the GPL, as needed to protect the freedom of users. + + Finally, every program is threatened constantly by software patents. +States should not allow patents to restrict development and use of +software on general-purpose computers, but in those that do, we wish to +avoid the special danger that patents applied to a free program could +make it effectively proprietary. To prevent this, the GPL assures that +patents cannot be used to render the program non-free. + + The precise terms and conditions for copying, distribution and +modification follow. + + TERMS AND CONDITIONS + + 0. Definitions. + + "This License" refers to version 3 of the GNU General Public License. + + "Copyright" also means copyright-like laws that apply to other kinds of +works, such as semiconductor masks. + + "The Program" refers to any copyrightable work licensed under this +License. Each licensee is addressed as "you". "Licensees" and +"recipients" may be individuals or organizations. + + To "modify" a work means to copy from or adapt all or part of the work +in a fashion requiring copyright permission, other than the making of an +exact copy. The resulting work is called a "modified version" of the +earlier work or a work "based on" the earlier work. + + A "covered work" means either the unmodified Program or a work based +on the Program. + + To "propagate" a work means to do anything with it that, without +permission, would make you directly or secondarily liable for +infringement under applicable copyright law, except executing it on a +computer or modifying a private copy. Propagation includes copying, +distribution (with or without modification), making available to the +public, and in some countries other activities as well. + + To "convey" a work means any kind of propagation that enables other +parties to make or receive copies. Mere interaction with a user through +a computer network, with no transfer of a copy, is not conveying. + + An interactive user interface displays "Appropriate Legal Notices" +to the extent that it includes a convenient and prominently visible +feature that (1) displays an appropriate copyright notice, and (2) +tells the user that there is no warranty for the work (except to the +extent that warranties are provided), that licensees may convey the +work under this License, and how to view a copy of this License. If +the interface presents a list of user commands or options, such as a +menu, a prominent item in the list meets this criterion. + + 1. Source Code. + + The "source code" for a work means the preferred form of the work +for making modifications to it. "Object code" means any non-source +form of a work. + + A "Standard Interface" means an interface that either is an official +standard defined by a recognized standards body, or, in the case of +interfaces specified for a particular programming language, one that +is widely used among developers working in that language. + + The "System Libraries" of an executable work include anything, other +than the work as a whole, that (a) is included in the normal form of +packaging a Major Component, but which is not part of that Major +Component, and (b) serves only to enable use of the work with that +Major Component, or to implement a Standard Interface for which an +implementation is available to the public in source code form. A +"Major Component", in this context, means a major essential component +(kernel, window system, and so on) of the specific operating system +(if any) on which the executable work runs, or a compiler used to +produce the work, or an object code interpreter used to run it. + + The "Corresponding Source" for a work in object code form means all +the source code needed to generate, install, and (for an executable +work) run the object code and to modify the work, including scripts to +control those activities. However, it does not include the work's +System Libraries, or general-purpose tools or generally available free +programs which are used unmodified in performing those activities but +which are not part of the work. For example, Corresponding Source +includes interface definition files associated with source files for +the work, and the source code for shared libraries and dynamically +linked subprograms that the work is specifically designed to require, +such as by intimate data communication or control flow between those +subprograms and other parts of the work. + + The Corresponding Source need not include anything that users +can regenerate automatically from other parts of the Corresponding +Source. + + The Corresponding Source for a work in source code form is that +same work. + + 2. Basic Permissions. + + All rights granted under this License are granted for the term of +copyright on the Program, and are irrevocable provided the stated +conditions are met. This License explicitly affirms your unlimited +permission to run the unmodified Program. The output from running a +covered work is covered by this License only if the output, given its +content, constitutes a covered work. This License acknowledges your +rights of fair use or other equivalent, as provided by copyright law. + + You may make, run and propagate covered works that you do not +convey, without conditions so long as your license otherwise remains +in force. You may convey covered works to others for the sole purpose +of having them make modifications exclusively for you, or provide you +with facilities for running those works, provided that you comply with +the terms of this License in conveying all material for which you do +not control copyright. Those thus making or running the covered works +for you must do so exclusively on your behalf, under your direction +and control, on terms that prohibit them from making any copies of +your copyrighted material outside their relationship with you. + + Conveying under any other circumstances is permitted solely under +the conditions stated below. Sublicensing is not allowed; section 10 +makes it unnecessary. + + 3. Protecting Users' Legal Rights From Anti-Circumvention Law. + + No covered work shall be deemed part of an effective technological +measure under any applicable law fulfilling obligations under article +11 of the WIPO copyright treaty adopted on 20 December 1996, or +similar laws prohibiting or restricting circumvention of such +measures. + + When you convey a covered work, you waive any legal power to forbid +circumvention of technological measures to the extent such circumvention +is effected by exercising rights under this License with respect to +the covered work, and you disclaim any intention to limit operation or +modification of the work as a means of enforcing, against the work's +users, your or third parties' legal rights to forbid circumvention of +technological measures. + + 4. Conveying Verbatim Copies. + + You may convey verbatim copies of the Program's source code as you +receive it, in any medium, provided that you conspicuously and +appropriately publish on each copy an appropriate copyright notice; +keep intact all notices stating that this License and any +non-permissive terms added in accord with section 7 apply to the code; +keep intact all notices of the absence of any warranty; and give all +recipients a copy of this License along with the Program. + + You may charge any price or no price for each copy that you convey, +and you may offer support or warranty protection for a fee. + + 5. Conveying Modified Source Versions. + + You may convey a work based on the Program, or the modifications to +produce it from the Program, in the form of source code under the +terms of section 4, provided that you also meet all of these conditions: + + a) The work must carry prominent notices stating that you modified + it, and giving a relevant date. + + b) The work must carry prominent notices stating that it is + released under this License and any conditions added under section + 7. This requirement modifies the requirement in section 4 to + "keep intact all notices". + + c) You must license the entire work, as a whole, under this + License to anyone who comes into possession of a copy. This + License will therefore apply, along with any applicable section 7 + additional terms, to the whole of the work, and all its parts, + regardless of how they are packaged. This License gives no + permission to license the work in any other way, but it does not + invalidate such permission if you have separately received it. + + d) If the work has interactive user interfaces, each must display + Appropriate Legal Notices; however, if the Program has interactive + interfaces that do not display Appropriate Legal Notices, your + work need not make them do so. + + A compilation of a covered work with other separate and independent +works, which are not by their nature extensions of the covered work, +and which are not combined with it such as to form a larger program, +in or on a volume of a storage or distribution medium, is called an +"aggregate" if the compilation and its resulting copyright are not +used to limit the access or legal rights of the compilation's users +beyond what the individual works permit. Inclusion of a covered work +in an aggregate does not cause this License to apply to the other +parts of the aggregate. + + 6. Conveying Non-Source Forms. + + You may convey a covered work in object code form under the terms +of sections 4 and 5, provided that you also convey the +machine-readable Corresponding Source under the terms of this License, +in one of these ways: + + a) Convey the object code in, or embodied in, a physical product + (including a physical distribution medium), accompanied by the + Corresponding Source fixed on a durable physical medium + customarily used for software interchange. + + b) Convey the object code in, or embodied in, a physical product + (including a physical distribution medium), accompanied by a + written offer, valid for at least three years and valid for as + long as you offer spare parts or customer support for that product + model, to give anyone who possesses the object code either (1) a + copy of the Corresponding Source for all the software in the + product that is covered by this License, on a durable physical + medium customarily used for software interchange, for a price no + more than your reasonable cost of physically performing this + conveying of source, or (2) access to copy the + Corresponding Source from a network server at no charge. + + c) Convey individual copies of the object code with a copy of the + written offer to provide the Corresponding Source. This + alternative is allowed only occasionally and noncommercially, and + only if you received the object code with such an offer, in accord + with subsection 6b. + + d) Convey the object code by offering access from a designated + place (gratis or for a charge), and offer equivalent access to the + Corresponding Source in the same way through the same place at no + further charge. You need not require recipients to copy the + Corresponding Source along with the object code. If the place to + copy the object code is a network server, the Corresponding Source + may be on a different server (operated by you or a third party) + that supports equivalent copying facilities, provided you maintain + clear directions next to the object code saying where to find the + Corresponding Source. Regardless of what server hosts the + Corresponding Source, you remain obligated to ensure that it is + available for as long as needed to satisfy these requirements. + + e) Convey the object code using peer-to-peer transmission, provided + you inform other peers where the object code and Corresponding + Source of the work are being offered to the general public at no + charge under subsection 6d. + + A separable portion of the object code, whose source code is excluded +from the Corresponding Source as a System Library, need not be +included in conveying the object code work. + + A "User Product" is either (1) a "consumer product", which means any +tangible personal property which is normally used for personal, family, +or household purposes, or (2) anything designed or sold for incorporation +into a dwelling. In determining whether a product is a consumer product, +doubtful cases shall be resolved in favor of coverage. For a particular +product received by a particular user, "normally used" refers to a +typical or common use of that class of product, regardless of the status +of the particular user or of the way in which the particular user +actually uses, or expects or is expected to use, the product. A product +is a consumer product regardless of whether the product has substantial +commercial, industrial or non-consumer uses, unless such uses represent +the only significant mode of use of the product. + + "Installation Information" for a User Product means any methods, +procedures, authorization keys, or other information required to install +and execute modified versions of a covered work in that User Product from +a modified version of its Corresponding Source. The information must +suffice to ensure that the continued functioning of the modified object +code is in no case prevented or interfered with solely because +modification has been made. + + If you convey an object code work under this section in, or with, or +specifically for use in, a User Product, and the conveying occurs as +part of a transaction in which the right of possession and use of the +User Product is transferred to the recipient in perpetuity or for a +fixed term (regardless of how the transaction is characterized), the +Corresponding Source conveyed under this section must be accompanied +by the Installation Information. But this requirement does not apply +if neither you nor any third party retains the ability to install +modified object code on the User Product (for example, the work has +been installed in ROM). + + The requirement to provide Installation Information does not include a +requirement to continue to provide support service, warranty, or updates +for a work that has been modified or installed by the recipient, or for +the User Product in which it has been modified or installed. Access to a +network may be denied when the modification itself materially and +adversely affects the operation of the network or violates the rules and +protocols for communication across the network. + + Corresponding Source conveyed, and Installation Information provided, +in accord with this section must be in a format that is publicly +documented (and with an implementation available to the public in +source code form), and must require no special password or key for +unpacking, reading or copying. + + 7. Additional Terms. + + "Additional permissions" are terms that supplement the terms of this +License by making exceptions from one or more of its conditions. +Additional permissions that are applicable to the entire Program shall +be treated as though they were included in this License, to the extent +that they are valid under applicable law. If additional permissions +apply only to part of the Program, that part may be used separately +under those permissions, but the entire Program remains governed by +this License without regard to the additional permissions. + + When you convey a copy of a covered work, you may at your option +remove any additional permissions from that copy, or from any part of +it. (Additional permissions may be written to require their own +removal in certain cases when you modify the work.) You may place +additional permissions on material, added by you to a covered work, +for which you have or can give appropriate copyright permission. + + Notwithstanding any other provision of this License, for material you +add to a covered work, you may (if authorized by the copyright holders of +that material) supplement the terms of this License with terms: + + a) Disclaiming warranty or limiting liability differently from the + terms of sections 15 and 16 of this License; or + + b) Requiring preservation of specified reasonable legal notices or + author attributions in that material or in the Appropriate Legal + Notices displayed by works containing it; or + + c) Prohibiting misrepresentation of the origin of that material, or + requiring that modified versions of such material be marked in + reasonable ways as different from the original version; or + + d) Limiting the use for publicity purposes of names of licensors or + authors of the material; or + + e) Declining to grant rights under trademark law for use of some + trade names, trademarks, or service marks; or + + f) Requiring indemnification of licensors and authors of that + material by anyone who conveys the material (or modified versions of + it) with contractual assumptions of liability to the recipient, for + any liability that these contractual assumptions directly impose on + those licensors and authors. + + All other non-permissive additional terms are considered "further +restrictions" within the meaning of section 10. If the Program as you +received it, or any part of it, contains a notice stating that it is +governed by this License along with a term that is a further +restriction, you may remove that term. If a license document contains +a further restriction but permits relicensing or conveying under this +License, you may add to a covered work material governed by the terms +of that license document, provided that the further restriction does +not survive such relicensing or conveying. + + If you add terms to a covered work in accord with this section, you +must place, in the relevant source files, a statement of the +additional terms that apply to those files, or a notice indicating +where to find the applicable terms. + + Additional terms, permissive or non-permissive, may be stated in the +form of a separately written license, or stated as exceptions; +the above requirements apply either way. + + 8. Termination. + + You may not propagate or modify a covered work except as expressly +provided under this License. Any attempt otherwise to propagate or +modify it is void, and will automatically terminate your rights under +this License (including any patent licenses granted under the third +paragraph of section 11). + + However, if you cease all violation of this License, then your +license from a particular copyright holder is reinstated (a) +provisionally, unless and until the copyright holder explicitly and +finally terminates your license, and (b) permanently, if the copyright +holder fails to notify you of the violation by some reasonable means +prior to 60 days after the cessation. + + Moreover, your license from a particular copyright holder is +reinstated permanently if the copyright holder notifies you of the +violation by some reasonable means, this is the first time you have +received notice of violation of this License (for any work) from that +copyright holder, and you cure the violation prior to 30 days after +your receipt of the notice. + + Termination of your rights under this section does not terminate the +licenses of parties who have received copies or rights from you under +this License. If your rights have been terminated and not permanently +reinstated, you do not qualify to receive new licenses for the same +material under section 10. + + 9. Acceptance Not Required for Having Copies. + + You are not required to accept this License in order to receive or +run a copy of the Program. Ancillary propagation of a covered work +occurring solely as a consequence of using peer-to-peer transmission +to receive a copy likewise does not require acceptance. However, +nothing other than this License grants you permission to propagate or +modify any covered work. These actions infringe copyright if you do +not accept this License. Therefore, by modifying or propagating a +covered work, you indicate your acceptance of this License to do so. + + 10. Automatic Licensing of Downstream Recipients. + + Each time you convey a covered work, the recipient automatically +receives a license from the original licensors, to run, modify and +propagate that work, subject to this License. You are not responsible +for enforcing compliance by third parties with this License. + + An "entity transaction" is a transaction transferring control of an +organization, or substantially all assets of one, or subdividing an +organization, or merging organizations. If propagation of a covered +work results from an entity transaction, each party to that +transaction who receives a copy of the work also receives whatever +licenses to the work the party's predecessor in interest had or could +give under the previous paragraph, plus a right to possession of the +Corresponding Source of the work from the predecessor in interest, if +the predecessor has it or can get it with reasonable efforts. + + You may not impose any further restrictions on the exercise of the +rights granted or affirmed under this License. For example, you may +not impose a license fee, royalty, or other charge for exercise of +rights granted under this License, and you may not initiate litigation +(including a cross-claim or counterclaim in a lawsuit) alleging that +any patent claim is infringed by making, using, selling, offering for +sale, or importing the Program or any portion of it. + + 11. Patents. + + A "contributor" is a copyright holder who authorizes use under this +License of the Program or a work on which the Program is based. The +work thus licensed is called the contributor's "contributor version". + + A contributor's "essential patent claims" are all patent claims +owned or controlled by the contributor, whether already acquired or +hereafter acquired, that would be infringed by some manner, permitted +by this License, of making, using, or selling its contributor version, +but do not include claims that would be infringed only as a +consequence of further modification of the contributor version. For +purposes of this definition, "control" includes the right to grant +patent sublicenses in a manner consistent with the requirements of +this License. + + Each contributor grants you a non-exclusive, worldwide, royalty-free +patent license under the contributor's essential patent claims, to +make, use, sell, offer for sale, import and otherwise run, modify and +propagate the contents of its contributor version. + + In the following three paragraphs, a "patent license" is any express +agreement or commitment, however denominated, not to enforce a patent +(such as an express permission to practice a patent or covenant not to +sue for patent infringement). To "grant" such a patent license to a +party means to make such an agreement or commitment not to enforce a +patent against the party. + + If you convey a covered work, knowingly relying on a patent license, +and the Corresponding Source of the work is not available for anyone +to copy, free of charge and under the terms of this License, through a +publicly available network server or other readily accessible means, +then you must either (1) cause the Corresponding Source to be so +available, or (2) arrange to deprive yourself of the benefit of the +patent license for this particular work, or (3) arrange, in a manner +consistent with the requirements of this License, to extend the patent +license to downstream recipients. "Knowingly relying" means you have +actual knowledge that, but for the patent license, your conveying the +covered work in a country, or your recipient's use of the covered work +in a country, would infringe one or more identifiable patents in that +country that you have reason to believe are valid. + + If, pursuant to or in connection with a single transaction or +arrangement, you convey, or propagate by procuring conveyance of, a +covered work, and grant a patent license to some of the parties +receiving the covered work authorizing them to use, propagate, modify +or convey a specific copy of the covered work, then the patent license +you grant is automatically extended to all recipients of the covered +work and works based on it. + + A patent license is "discriminatory" if it does not include within +the scope of its coverage, prohibits the exercise of, or is +conditioned on the non-exercise of one or more of the rights that are +specifically granted under this License. You may not convey a covered +work if you are a party to an arrangement with a third party that is +in the business of distributing software, under which you make payment +to the third party based on the extent of your activity of conveying +the work, and under which the third party grants, to any of the +parties who would receive the covered work from you, a discriminatory +patent license (a) in connection with copies of the covered work +conveyed by you (or copies made from those copies), or (b) primarily +for and in connection with specific products or compilations that +contain the covered work, unless you entered into that arrangement, +or that patent license was granted, prior to 28 March 2007. + + Nothing in this License shall be construed as excluding or limiting +any implied license or other defenses to infringement that may +otherwise be available to you under applicable patent law. + + 12. No Surrender of Others' Freedom. + + If conditions are imposed on you (whether by court order, agreement or +otherwise) that contradict the conditions of this License, they do not +excuse you from the conditions of this License. If you cannot convey a +covered work so as to satisfy simultaneously your obligations under this +License and any other pertinent obligations, then as a consequence you may +not convey it at all. For example, if you agree to terms that obligate you +to collect a royalty for further conveying from those to whom you convey +the Program, the only way you could satisfy both those terms and this +License would be to refrain entirely from conveying the Program. + + 13. Use with the GNU Affero General Public License. + + Notwithstanding any other provision of this License, you have +permission to link or combine any covered work with a work licensed +under version 3 of the GNU Affero General Public License into a single +combined work, and to convey the resulting work. The terms of this +License will continue to apply to the part which is the covered work, +but the special requirements of the GNU Affero General Public License, +section 13, concerning interaction through a network will apply to the +combination as such. + + 14. Revised Versions of this License. + + The Free Software Foundation may publish revised and/or new versions of +the GNU General Public License from time to time. Such new versions will +be similar in spirit to the present version, but may differ in detail to +address new problems or concerns. + + Each version is given a distinguishing version number. If the +Program specifies that a certain numbered version of the GNU General +Public License "or any later version" applies to it, you have the +option of following the terms and conditions either of that numbered +version or of any later version published by the Free Software +Foundation. If the Program does not specify a version number of the +GNU General Public License, you may choose any version ever published +by the Free Software Foundation. + + If the Program specifies that a proxy can decide which future +versions of the GNU General Public License can be used, that proxy's +public statement of acceptance of a version permanently authorizes you +to choose that version for the Program. + + Later license versions may give you additional or different +permissions. However, no additional obligations are imposed on any +author or copyright holder as a result of your choosing to follow a +later version. + + 15. Disclaimer of Warranty. + + THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY +APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT +HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY +OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, +THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR +PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM +IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF +ALL NECESSARY SERVICING, REPAIR OR CORRECTION. + + 16. Limitation of Liability. + + IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING +WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS +THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY +GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE +USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF +DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD +PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS), +EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF +SUCH DAMAGES. + + 17. Interpretation of Sections 15 and 16. + + If the disclaimer of warranty and limitation of liability provided +above cannot be given local legal effect according to their terms, +reviewing courts shall apply local law that most closely approximates +an absolute waiver of all civil liability in connection with the +Program, unless a warranty or assumption of liability accompanies a +copy of the Program in return for a fee. + + END OF TERMS AND CONDITIONS + + How to Apply These Terms to Your New Programs + + If you develop a new program, and you want it to be of the greatest +possible use to the public, the best way to achieve this is to make it +free software which everyone can redistribute and change under these terms. + + To do so, attach the following notices to the program. It is safest +to attach them to the start of each source file to most effectively +state the exclusion of warranty; and each file should have at least +the "copyright" line and a pointer to where the full notice is found. + + + Copyright (C) + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . + +Also add information on how to contact you by electronic and paper mail. + + If the program does terminal interaction, make it output a short +notice like this when it starts in an interactive mode: + + Copyright (C) + This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'. + This is free software, and you are welcome to redistribute it + under certain conditions; type `show c' for details. + +The hypothetical commands `show w' and `show c' should show the appropriate +parts of the General Public License. Of course, your program's commands +might be different; for a GUI interface, you would use an "about box". + + You should also get your employer (if you work as a programmer) or school, +if any, to sign a "copyright disclaimer" for the program, if necessary. +For more information on this, and how to apply and follow the GNU GPL, see +. + + The GNU General Public License does not permit incorporating your program +into proprietary programs. If your program is a subroutine library, you +may consider it more useful to permit linking proprietary applications with +the library. If this is what you want to do, use the GNU Lesser General +Public License instead of this License. But first, please read +. diff --git a/docs/crypto/zkCTF/day1/Ethereal/mint-contracts/lib/forge-std/lib/ds-test/Makefile b/docs/crypto/zkCTF/day1/Ethereal/mint-contracts/lib/forge-std/lib/ds-test/Makefile new file mode 100644 index 0000000..661dac4 --- /dev/null +++ b/docs/crypto/zkCTF/day1/Ethereal/mint-contracts/lib/forge-std/lib/ds-test/Makefile @@ -0,0 +1,14 @@ +all:; dapp build + +test: + -dapp --use solc:0.4.23 build + -dapp --use solc:0.4.26 build + -dapp --use solc:0.5.17 build + -dapp --use solc:0.6.12 build + -dapp --use solc:0.7.5 build + +demo: + DAPP_SRC=demo dapp --use solc:0.7.5 build + -hevm dapp-test --verbose 3 + +.PHONY: test demo diff --git a/docs/crypto/zkCTF/day1/Ethereal/mint-contracts/lib/forge-std/lib/ds-test/default.nix b/docs/crypto/zkCTF/day1/Ethereal/mint-contracts/lib/forge-std/lib/ds-test/default.nix new file mode 100644 index 0000000..cf65419 --- /dev/null +++ b/docs/crypto/zkCTF/day1/Ethereal/mint-contracts/lib/forge-std/lib/ds-test/default.nix @@ -0,0 +1,4 @@ +{ solidityPackage, dappsys }: solidityPackage { + name = "ds-test"; + src = ./src; +} diff --git a/docs/crypto/zkCTF/day1/Ethereal/mint-contracts/lib/forge-std/lib/ds-test/demo/demo.sol b/docs/crypto/zkCTF/day1/Ethereal/mint-contracts/lib/forge-std/lib/ds-test/demo/demo.sol new file mode 100644 index 0000000..f3bb48e --- /dev/null +++ b/docs/crypto/zkCTF/day1/Ethereal/mint-contracts/lib/forge-std/lib/ds-test/demo/demo.sol @@ -0,0 +1,222 @@ +// SPDX-License-Identifier: GPL-3.0-or-later +pragma solidity >=0.5.0; + +import "../src/test.sol"; + +contract DemoTest is DSTest { + function test_this() public pure { + require(true); + } + function test_logs() public { + emit log("-- log(string)"); + emit log("a string"); + + emit log("-- log_named_uint(string, uint)"); + emit log_named_uint("uint", 512); + + emit log("-- log_named_int(string, int)"); + emit log_named_int("int", -512); + + emit log("-- log_named_address(string, address)"); + emit log_named_address("address", address(this)); + + emit log("-- log_named_bytes32(string, bytes32)"); + emit log_named_bytes32("bytes32", "a string"); + + emit log("-- log_named_bytes(string, bytes)"); + emit log_named_bytes("bytes", hex"cafefe"); + + emit log("-- log_named_string(string, string)"); + emit log_named_string("string", "a string"); + + emit log("-- log_named_decimal_uint(string, uint, uint)"); + emit log_named_decimal_uint("decimal uint", 1.0e18, 18); + + emit log("-- log_named_decimal_int(string, int, uint)"); + emit log_named_decimal_int("decimal int", -1.0e18, 18); + } + event log_old_named_uint(bytes32,uint); + function test_old_logs() public { + emit log_old_named_uint("key", 500); + emit log_named_bytes32("bkey", "val"); + } + function test_trace() public view { + this.echo("string 1", "string 2"); + } + function test_multiline() public { + emit log("a multiline\\nstring"); + emit log("a multiline string"); + emit log_bytes("a string"); + emit log_bytes("a multiline\nstring"); + emit log_bytes("a multiline\\nstring"); + emit logs(hex"0000"); + emit log_named_bytes("0x0000", hex"0000"); + emit logs(hex"ff"); + } + function echo(string memory s1, string memory s2) public pure + returns (string memory, string memory) + { + return (s1, s2); + } + + function prove_this(uint x) public { + emit log_named_uint("sym x", x); + assertGt(x + 1, 0); + } + + function test_logn() public { + assembly { + log0(0x01, 0x02) + log1(0x01, 0x02, 0x03) + log2(0x01, 0x02, 0x03, 0x04) + log3(0x01, 0x02, 0x03, 0x04, 0x05) + } + } + + event MyEvent(uint, uint indexed, uint, uint indexed); + function test_events() public { + emit MyEvent(1, 2, 3, 4); + } + + function test_asserts() public { + string memory err = "this test has failed!"; + emit log("## assertTrue(bool)\n"); + assertTrue(false); + emit log("\n"); + assertTrue(false, err); + + emit log("\n## assertEq(address,address)\n"); + assertEq(address(this), msg.sender); + emit log("\n"); + assertEq(address(this), msg.sender, err); + + emit log("\n## assertEq32(bytes32,bytes32)\n"); + assertEq32("bytes 1", "bytes 2"); + emit log("\n"); + assertEq32("bytes 1", "bytes 2", err); + + emit log("\n## assertEq(bytes32,bytes32)\n"); + assertEq32("bytes 1", "bytes 2"); + emit log("\n"); + assertEq32("bytes 1", "bytes 2", err); + + emit log("\n## assertEq(uint,uint)\n"); + assertEq(uint(0), 1); + emit log("\n"); + assertEq(uint(0), 1, err); + + emit log("\n## assertEq(int,int)\n"); + assertEq(-1, -2); + emit log("\n"); + assertEq(-1, -2, err); + + emit log("\n## assertEqDecimal(int,int,uint)\n"); + assertEqDecimal(-1.0e18, -1.1e18, 18); + emit log("\n"); + assertEqDecimal(-1.0e18, -1.1e18, 18, err); + + emit log("\n## assertEqDecimal(uint,uint,uint)\n"); + assertEqDecimal(uint(1.0e18), 1.1e18, 18); + emit log("\n"); + assertEqDecimal(uint(1.0e18), 1.1e18, 18, err); + + emit log("\n## assertGt(uint,uint)\n"); + assertGt(uint(0), 0); + emit log("\n"); + assertGt(uint(0), 0, err); + + emit log("\n## assertGt(int,int)\n"); + assertGt(-1, -1); + emit log("\n"); + assertGt(-1, -1, err); + + emit log("\n## assertGtDecimal(int,int,uint)\n"); + assertGtDecimal(-2.0e18, -1.1e18, 18); + emit log("\n"); + assertGtDecimal(-2.0e18, -1.1e18, 18, err); + + emit log("\n## assertGtDecimal(uint,uint,uint)\n"); + assertGtDecimal(uint(1.0e18), 1.1e18, 18); + emit log("\n"); + assertGtDecimal(uint(1.0e18), 1.1e18, 18, err); + + emit log("\n## assertGe(uint,uint)\n"); + assertGe(uint(0), 1); + emit log("\n"); + assertGe(uint(0), 1, err); + + emit log("\n## assertGe(int,int)\n"); + assertGe(-1, 0); + emit log("\n"); + assertGe(-1, 0, err); + + emit log("\n## assertGeDecimal(int,int,uint)\n"); + assertGeDecimal(-2.0e18, -1.1e18, 18); + emit log("\n"); + assertGeDecimal(-2.0e18, -1.1e18, 18, err); + + emit log("\n## assertGeDecimal(uint,uint,uint)\n"); + assertGeDecimal(uint(1.0e18), 1.1e18, 18); + emit log("\n"); + assertGeDecimal(uint(1.0e18), 1.1e18, 18, err); + + emit log("\n## assertLt(uint,uint)\n"); + assertLt(uint(0), 0); + emit log("\n"); + assertLt(uint(0), 0, err); + + emit log("\n## assertLt(int,int)\n"); + assertLt(-1, -1); + emit log("\n"); + assertLt(-1, -1, err); + + emit log("\n## assertLtDecimal(int,int,uint)\n"); + assertLtDecimal(-1.0e18, -1.1e18, 18); + emit log("\n"); + assertLtDecimal(-1.0e18, -1.1e18, 18, err); + + emit log("\n## assertLtDecimal(uint,uint,uint)\n"); + assertLtDecimal(uint(2.0e18), 1.1e18, 18); + emit log("\n"); + assertLtDecimal(uint(2.0e18), 1.1e18, 18, err); + + emit log("\n## assertLe(uint,uint)\n"); + assertLe(uint(1), 0); + emit log("\n"); + assertLe(uint(1), 0, err); + + emit log("\n## assertLe(int,int)\n"); + assertLe(0, -1); + emit log("\n"); + assertLe(0, -1, err); + + emit log("\n## assertLeDecimal(int,int,uint)\n"); + assertLeDecimal(-1.0e18, -1.1e18, 18); + emit log("\n"); + assertLeDecimal(-1.0e18, -1.1e18, 18, err); + + emit log("\n## assertLeDecimal(uint,uint,uint)\n"); + assertLeDecimal(uint(2.0e18), 1.1e18, 18); + emit log("\n"); + assertLeDecimal(uint(2.0e18), 1.1e18, 18, err); + + emit log("\n## assertEq(string,string)\n"); + string memory s1 = "string 1"; + string memory s2 = "string 2"; + assertEq(s1, s2); + emit log("\n"); + assertEq(s1, s2, err); + + emit log("\n## assertEq0(bytes,bytes)\n"); + assertEq0(hex"abcdef01", hex"abcdef02"); + emit log("\n"); + assertEq0(hex"abcdef01", hex"abcdef02", err); + } +} + +contract DemoTestWithSetUp { + function setUp() public { + } + function test_pass() public pure { + } +} diff --git a/docs/crypto/zkCTF/day1/Ethereal/mint-contracts/lib/forge-std/lib/ds-test/package.json b/docs/crypto/zkCTF/day1/Ethereal/mint-contracts/lib/forge-std/lib/ds-test/package.json new file mode 100644 index 0000000..4802ada --- /dev/null +++ b/docs/crypto/zkCTF/day1/Ethereal/mint-contracts/lib/forge-std/lib/ds-test/package.json @@ -0,0 +1,15 @@ +{ + "name": "ds-test", + "version": "1.0.0", + "description": "Assertions, equality checks and other test helpers ", + "bugs": "https://github.com/dapphub/ds-test/issues", + "license": "GPL-3.0", + "author": "Contributors to ds-test", + "files": [ + "src/*" + ], + "repository": { + "type": "git", + "url": "https://github.com/dapphub/ds-test.git" + } +} diff --git a/docs/crypto/zkCTF/day1/Ethereal/mint-contracts/lib/forge-std/lib/ds-test/src/test.sol b/docs/crypto/zkCTF/day1/Ethereal/mint-contracts/lib/forge-std/lib/ds-test/src/test.sol new file mode 100644 index 0000000..2bf3375 --- /dev/null +++ b/docs/crypto/zkCTF/day1/Ethereal/mint-contracts/lib/forge-std/lib/ds-test/src/test.sol @@ -0,0 +1,592 @@ +// SPDX-License-Identifier: GPL-3.0-or-later + +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. + +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// You should have received a copy of the GNU General Public License +// along with this program. If not, see . + +pragma solidity >=0.5.0; + +contract DSTest { + event log (string); + event logs (bytes); + + event log_address (address); + event log_bytes32 (bytes32); + event log_int (int); + event log_uint (uint); + event log_bytes (bytes); + event log_string (string); + + event log_named_address (string key, address val); + event log_named_bytes32 (string key, bytes32 val); + event log_named_decimal_int (string key, int val, uint decimals); + event log_named_decimal_uint (string key, uint val, uint decimals); + event log_named_int (string key, int val); + event log_named_uint (string key, uint val); + event log_named_bytes (string key, bytes val); + event log_named_string (string key, string val); + + bool public IS_TEST = true; + bool private _failed; + + address constant HEVM_ADDRESS = + address(bytes20(uint160(uint256(keccak256('hevm cheat code'))))); + + modifier mayRevert() { _; } + modifier testopts(string memory) { _; } + + function failed() public returns (bool) { + if (_failed) { + return _failed; + } else { + bool globalFailed = false; + if (hasHEVMContext()) { + (, bytes memory retdata) = HEVM_ADDRESS.call( + abi.encodePacked( + bytes4(keccak256("load(address,bytes32)")), + abi.encode(HEVM_ADDRESS, bytes32("failed")) + ) + ); + globalFailed = abi.decode(retdata, (bool)); + } + return globalFailed; + } + } + + function fail() internal virtual { + if (hasHEVMContext()) { + (bool status, ) = HEVM_ADDRESS.call( + abi.encodePacked( + bytes4(keccak256("store(address,bytes32,bytes32)")), + abi.encode(HEVM_ADDRESS, bytes32("failed"), bytes32(uint256(0x01))) + ) + ); + status; // Silence compiler warnings + } + _failed = true; + } + + function hasHEVMContext() internal view returns (bool) { + uint256 hevmCodeSize = 0; + assembly { + hevmCodeSize := extcodesize(0x7109709ECfa91a80626fF3989D68f67F5b1DD12D) + } + return hevmCodeSize > 0; + } + + modifier logs_gas() { + uint startGas = gasleft(); + _; + uint endGas = gasleft(); + emit log_named_uint("gas", startGas - endGas); + } + + function assertTrue(bool condition) internal { + if (!condition) { + emit log("Error: Assertion Failed"); + fail(); + } + } + + function assertTrue(bool condition, string memory err) internal { + if (!condition) { + emit log_named_string("Error", err); + assertTrue(condition); + } + } + + function assertEq(address a, address b) internal { + if (a != b) { + emit log("Error: a == b not satisfied [address]"); + emit log_named_address(" Left", a); + emit log_named_address(" Right", b); + fail(); + } + } + function assertEq(address a, address b, string memory err) internal { + if (a != b) { + emit log_named_string ("Error", err); + assertEq(a, b); + } + } + + function assertEq(bytes32 a, bytes32 b) internal { + if (a != b) { + emit log("Error: a == b not satisfied [bytes32]"); + emit log_named_bytes32(" Left", a); + emit log_named_bytes32(" Right", b); + fail(); + } + } + function assertEq(bytes32 a, bytes32 b, string memory err) internal { + if (a != b) { + emit log_named_string ("Error", err); + assertEq(a, b); + } + } + function assertEq32(bytes32 a, bytes32 b) internal { + assertEq(a, b); + } + function assertEq32(bytes32 a, bytes32 b, string memory err) internal { + assertEq(a, b, err); + } + + function assertEq(int a, int b) internal { + if (a != b) { + emit log("Error: a == b not satisfied [int]"); + emit log_named_int(" Left", a); + emit log_named_int(" Right", b); + fail(); + } + } + function assertEq(int a, int b, string memory err) internal { + if (a != b) { + emit log_named_string("Error", err); + assertEq(a, b); + } + } + function assertEq(uint a, uint b) internal { + if (a != b) { + emit log("Error: a == b not satisfied [uint]"); + emit log_named_uint(" Left", a); + emit log_named_uint(" Right", b); + fail(); + } + } + function assertEq(uint a, uint b, string memory err) internal { + if (a != b) { + emit log_named_string("Error", err); + assertEq(a, b); + } + } + function assertEqDecimal(int a, int b, uint decimals) internal { + if (a != b) { + emit log("Error: a == b not satisfied [decimal int]"); + emit log_named_decimal_int(" Left", a, decimals); + emit log_named_decimal_int(" Right", b, decimals); + fail(); + } + } + function assertEqDecimal(int a, int b, uint decimals, string memory err) internal { + if (a != b) { + emit log_named_string("Error", err); + assertEqDecimal(a, b, decimals); + } + } + function assertEqDecimal(uint a, uint b, uint decimals) internal { + if (a != b) { + emit log("Error: a == b not satisfied [decimal uint]"); + emit log_named_decimal_uint(" Left", a, decimals); + emit log_named_decimal_uint(" Right", b, decimals); + fail(); + } + } + function assertEqDecimal(uint a, uint b, uint decimals, string memory err) internal { + if (a != b) { + emit log_named_string("Error", err); + assertEqDecimal(a, b, decimals); + } + } + + function assertNotEq(address a, address b) internal { + if (a == b) { + emit log("Error: a != b not satisfied [address]"); + emit log_named_address(" Left", a); + emit log_named_address(" Right", b); + fail(); + } + } + function assertNotEq(address a, address b, string memory err) internal { + if (a == b) { + emit log_named_string ("Error", err); + assertNotEq(a, b); + } + } + + function assertNotEq(bytes32 a, bytes32 b) internal { + if (a == b) { + emit log("Error: a != b not satisfied [bytes32]"); + emit log_named_bytes32(" Left", a); + emit log_named_bytes32(" Right", b); + fail(); + } + } + function assertNotEq(bytes32 a, bytes32 b, string memory err) internal { + if (a == b) { + emit log_named_string ("Error", err); + assertNotEq(a, b); + } + } + function assertNotEq32(bytes32 a, bytes32 b) internal { + assertNotEq(a, b); + } + function assertNotEq32(bytes32 a, bytes32 b, string memory err) internal { + assertNotEq(a, b, err); + } + + function assertNotEq(int a, int b) internal { + if (a == b) { + emit log("Error: a != b not satisfied [int]"); + emit log_named_int(" Left", a); + emit log_named_int(" Right", b); + fail(); + } + } + function assertNotEq(int a, int b, string memory err) internal { + if (a == b) { + emit log_named_string("Error", err); + assertNotEq(a, b); + } + } + function assertNotEq(uint a, uint b) internal { + if (a == b) { + emit log("Error: a != b not satisfied [uint]"); + emit log_named_uint(" Left", a); + emit log_named_uint(" Right", b); + fail(); + } + } + function assertNotEq(uint a, uint b, string memory err) internal { + if (a == b) { + emit log_named_string("Error", err); + assertNotEq(a, b); + } + } + function assertNotEqDecimal(int a, int b, uint decimals) internal { + if (a == b) { + emit log("Error: a != b not satisfied [decimal int]"); + emit log_named_decimal_int(" Left", a, decimals); + emit log_named_decimal_int(" Right", b, decimals); + fail(); + } + } + function assertNotEqDecimal(int a, int b, uint decimals, string memory err) internal { + if (a == b) { + emit log_named_string("Error", err); + assertNotEqDecimal(a, b, decimals); + } + } + function assertNotEqDecimal(uint a, uint b, uint decimals) internal { + if (a == b) { + emit log("Error: a != b not satisfied [decimal uint]"); + emit log_named_decimal_uint(" Left", a, decimals); + emit log_named_decimal_uint(" Right", b, decimals); + fail(); + } + } + function assertNotEqDecimal(uint a, uint b, uint decimals, string memory err) internal { + if (a == b) { + emit log_named_string("Error", err); + assertNotEqDecimal(a, b, decimals); + } + } + + function assertGt(uint a, uint b) internal { + if (a <= b) { + emit log("Error: a > b not satisfied [uint]"); + emit log_named_uint(" Value a", a); + emit log_named_uint(" Value b", b); + fail(); + } + } + function assertGt(uint a, uint b, string memory err) internal { + if (a <= b) { + emit log_named_string("Error", err); + assertGt(a, b); + } + } + function assertGt(int a, int b) internal { + if (a <= b) { + emit log("Error: a > b not satisfied [int]"); + emit log_named_int(" Value a", a); + emit log_named_int(" Value b", b); + fail(); + } + } + function assertGt(int a, int b, string memory err) internal { + if (a <= b) { + emit log_named_string("Error", err); + assertGt(a, b); + } + } + function assertGtDecimal(int a, int b, uint decimals) internal { + if (a <= b) { + emit log("Error: a > b not satisfied [decimal int]"); + emit log_named_decimal_int(" Value a", a, decimals); + emit log_named_decimal_int(" Value b", b, decimals); + fail(); + } + } + function assertGtDecimal(int a, int b, uint decimals, string memory err) internal { + if (a <= b) { + emit log_named_string("Error", err); + assertGtDecimal(a, b, decimals); + } + } + function assertGtDecimal(uint a, uint b, uint decimals) internal { + if (a <= b) { + emit log("Error: a > b not satisfied [decimal uint]"); + emit log_named_decimal_uint(" Value a", a, decimals); + emit log_named_decimal_uint(" Value b", b, decimals); + fail(); + } + } + function assertGtDecimal(uint a, uint b, uint decimals, string memory err) internal { + if (a <= b) { + emit log_named_string("Error", err); + assertGtDecimal(a, b, decimals); + } + } + + function assertGe(uint a, uint b) internal { + if (a < b) { + emit log("Error: a >= b not satisfied [uint]"); + emit log_named_uint(" Value a", a); + emit log_named_uint(" Value b", b); + fail(); + } + } + function assertGe(uint a, uint b, string memory err) internal { + if (a < b) { + emit log_named_string("Error", err); + assertGe(a, b); + } + } + function assertGe(int a, int b) internal { + if (a < b) { + emit log("Error: a >= b not satisfied [int]"); + emit log_named_int(" Value a", a); + emit log_named_int(" Value b", b); + fail(); + } + } + function assertGe(int a, int b, string memory err) internal { + if (a < b) { + emit log_named_string("Error", err); + assertGe(a, b); + } + } + function assertGeDecimal(int a, int b, uint decimals) internal { + if (a < b) { + emit log("Error: a >= b not satisfied [decimal int]"); + emit log_named_decimal_int(" Value a", a, decimals); + emit log_named_decimal_int(" Value b", b, decimals); + fail(); + } + } + function assertGeDecimal(int a, int b, uint decimals, string memory err) internal { + if (a < b) { + emit log_named_string("Error", err); + assertGeDecimal(a, b, decimals); + } + } + function assertGeDecimal(uint a, uint b, uint decimals) internal { + if (a < b) { + emit log("Error: a >= b not satisfied [decimal uint]"); + emit log_named_decimal_uint(" Value a", a, decimals); + emit log_named_decimal_uint(" Value b", b, decimals); + fail(); + } + } + function assertGeDecimal(uint a, uint b, uint decimals, string memory err) internal { + if (a < b) { + emit log_named_string("Error", err); + assertGeDecimal(a, b, decimals); + } + } + + function assertLt(uint a, uint b) internal { + if (a >= b) { + emit log("Error: a < b not satisfied [uint]"); + emit log_named_uint(" Value a", a); + emit log_named_uint(" Value b", b); + fail(); + } + } + function assertLt(uint a, uint b, string memory err) internal { + if (a >= b) { + emit log_named_string("Error", err); + assertLt(a, b); + } + } + function assertLt(int a, int b) internal { + if (a >= b) { + emit log("Error: a < b not satisfied [int]"); + emit log_named_int(" Value a", a); + emit log_named_int(" Value b", b); + fail(); + } + } + function assertLt(int a, int b, string memory err) internal { + if (a >= b) { + emit log_named_string("Error", err); + assertLt(a, b); + } + } + function assertLtDecimal(int a, int b, uint decimals) internal { + if (a >= b) { + emit log("Error: a < b not satisfied [decimal int]"); + emit log_named_decimal_int(" Value a", a, decimals); + emit log_named_decimal_int(" Value b", b, decimals); + fail(); + } + } + function assertLtDecimal(int a, int b, uint decimals, string memory err) internal { + if (a >= b) { + emit log_named_string("Error", err); + assertLtDecimal(a, b, decimals); + } + } + function assertLtDecimal(uint a, uint b, uint decimals) internal { + if (a >= b) { + emit log("Error: a < b not satisfied [decimal uint]"); + emit log_named_decimal_uint(" Value a", a, decimals); + emit log_named_decimal_uint(" Value b", b, decimals); + fail(); + } + } + function assertLtDecimal(uint a, uint b, uint decimals, string memory err) internal { + if (a >= b) { + emit log_named_string("Error", err); + assertLtDecimal(a, b, decimals); + } + } + + function assertLe(uint a, uint b) internal { + if (a > b) { + emit log("Error: a <= b not satisfied [uint]"); + emit log_named_uint(" Value a", a); + emit log_named_uint(" Value b", b); + fail(); + } + } + function assertLe(uint a, uint b, string memory err) internal { + if (a > b) { + emit log_named_string("Error", err); + assertLe(a, b); + } + } + function assertLe(int a, int b) internal { + if (a > b) { + emit log("Error: a <= b not satisfied [int]"); + emit log_named_int(" Value a", a); + emit log_named_int(" Value b", b); + fail(); + } + } + function assertLe(int a, int b, string memory err) internal { + if (a > b) { + emit log_named_string("Error", err); + assertLe(a, b); + } + } + function assertLeDecimal(int a, int b, uint decimals) internal { + if (a > b) { + emit log("Error: a <= b not satisfied [decimal int]"); + emit log_named_decimal_int(" Value a", a, decimals); + emit log_named_decimal_int(" Value b", b, decimals); + fail(); + } + } + function assertLeDecimal(int a, int b, uint decimals, string memory err) internal { + if (a > b) { + emit log_named_string("Error", err); + assertLeDecimal(a, b, decimals); + } + } + function assertLeDecimal(uint a, uint b, uint decimals) internal { + if (a > b) { + emit log("Error: a <= b not satisfied [decimal uint]"); + emit log_named_decimal_uint(" Value a", a, decimals); + emit log_named_decimal_uint(" Value b", b, decimals); + fail(); + } + } + function assertLeDecimal(uint a, uint b, uint decimals, string memory err) internal { + if (a > b) { + emit log_named_string("Error", err); + assertLeDecimal(a, b, decimals); + } + } + + function assertEq(string memory a, string memory b) internal { + if (keccak256(abi.encodePacked(a)) != keccak256(abi.encodePacked(b))) { + emit log("Error: a == b not satisfied [string]"); + emit log_named_string(" Left", a); + emit log_named_string(" Right", b); + fail(); + } + } + function assertEq(string memory a, string memory b, string memory err) internal { + if (keccak256(abi.encodePacked(a)) != keccak256(abi.encodePacked(b))) { + emit log_named_string("Error", err); + assertEq(a, b); + } + } + + function assertNotEq(string memory a, string memory b) internal { + if (keccak256(abi.encodePacked(a)) == keccak256(abi.encodePacked(b))) { + emit log("Error: a != b not satisfied [string]"); + emit log_named_string(" Left", a); + emit log_named_string(" Right", b); + fail(); + } + } + function assertNotEq(string memory a, string memory b, string memory err) internal { + if (keccak256(abi.encodePacked(a)) == keccak256(abi.encodePacked(b))) { + emit log_named_string("Error", err); + assertNotEq(a, b); + } + } + + function checkEq0(bytes memory a, bytes memory b) internal pure returns (bool ok) { + ok = true; + if (a.length == b.length) { + for (uint i = 0; i < a.length; i++) { + if (a[i] != b[i]) { + ok = false; + } + } + } else { + ok = false; + } + } + function assertEq0(bytes memory a, bytes memory b) internal { + if (!checkEq0(a, b)) { + emit log("Error: a == b not satisfied [bytes]"); + emit log_named_bytes(" Left", a); + emit log_named_bytes(" Right", b); + fail(); + } + } + function assertEq0(bytes memory a, bytes memory b, string memory err) internal { + if (!checkEq0(a, b)) { + emit log_named_string("Error", err); + assertEq0(a, b); + } + } + + function assertNotEq0(bytes memory a, bytes memory b) internal { + if (checkEq0(a, b)) { + emit log("Error: a != b not satisfied [bytes]"); + emit log_named_bytes(" Left", a); + emit log_named_bytes(" Right", b); + fail(); + } + } + function assertNotEq0(bytes memory a, bytes memory b, string memory err) internal { + if (checkEq0(a, b)) { + emit log_named_string("Error", err); + assertNotEq0(a, b); + } + } +} diff --git a/docs/crypto/zkCTF/day1/Ethereal/mint-contracts/lib/forge-std/lib/ds-test/src/test.t.sol b/docs/crypto/zkCTF/day1/Ethereal/mint-contracts/lib/forge-std/lib/ds-test/src/test.t.sol new file mode 100644 index 0000000..d277a30 --- /dev/null +++ b/docs/crypto/zkCTF/day1/Ethereal/mint-contracts/lib/forge-std/lib/ds-test/src/test.t.sol @@ -0,0 +1,417 @@ +// SPDX-License-Identifier: GPL-3.0-or-later +pragma solidity >=0.5.0; + +import {DSTest} from "./test.sol"; + +contract DemoTest is DSTest { + + // --- assertTrue --- + + function testAssertTrue() public { + assertTrue(true, "msg"); + assertTrue(true); + } + function testFailAssertTrue() public { + assertTrue(false); + } + function testFailAssertTrueWithMsg() public { + assertTrue(false, "msg"); + } + + // --- assertEq (Addr) --- + + function testAssertEqAddr() public { + assertEq(address(0x0), address(0x0), "msg"); + assertEq(address(0x0), address(0x0)); + } + function testFailAssertEqAddr() public { + assertEq(address(0x0), address(0x1)); + } + function testFailAssertEqAddrWithMsg() public { + assertEq(address(0x0), address(0x1), "msg"); + } + + // --- assertEq (Bytes32) --- + + function testAssertEqBytes32() public { + assertEq(bytes32("hi"), bytes32("hi"), "msg"); + assertEq(bytes32("hi"), bytes32("hi")); + } + function testFailAssertEqBytes32() public { + assertEq(bytes32("hi"), bytes32("ho")); + } + function testFailAssertEqBytes32WithMsg() public { + assertEq(bytes32("hi"), bytes32("ho"), "msg"); + } + + // --- assertEq (Int) --- + + function testAssertEqInt() public { + assertEq(-1, -1, "msg"); + assertEq(-1, -1); + } + function testFailAssertEqInt() public { + assertEq(-1, -2); + } + function testFailAssertEqIntWithMsg() public { + assertEq(-1, -2, "msg"); + } + + // --- assertEq (UInt) --- + + function testAssertEqUInt() public { + assertEq(uint(1), uint(1), "msg"); + assertEq(uint(1), uint(1)); + } + function testFailAssertEqUInt() public { + assertEq(uint(1), uint(2)); + } + function testFailAssertEqUIntWithMsg() public { + assertEq(uint(1), uint(2), "msg"); + } + + // --- assertEqDecimal (Int) --- + + function testAssertEqDecimalInt() public { + assertEqDecimal(-1, -1, 18, "msg"); + assertEqDecimal(-1, -1, 18); + } + function testFailAssertEqDecimalInt() public { + assertEqDecimal(-1, -2, 18); + } + function testFailAssertEqDecimalIntWithMsg() public { + assertEqDecimal(-1, -2, 18, "msg"); + } + + // --- assertEqDecimal (UInt) --- + + function testAssertEqDecimalUInt() public { + assertEqDecimal(uint(1), uint(1), 18, "msg"); + assertEqDecimal(uint(1), uint(1), 18); + } + function testFailAssertEqDecimalUInt() public { + assertEqDecimal(uint(1), uint(2), 18); + } + function testFailAssertEqDecimalUIntWithMsg() public { + assertEqDecimal(uint(1), uint(2), 18, "msg"); + } + + // --- assertNotEq (Addr) --- + + function testAssertNotEqAddr() public { + assertNotEq(address(0x0), address(0x1), "msg"); + assertNotEq(address(0x0), address(0x1)); + } + function testFailAssertNotEqAddr() public { + assertNotEq(address(0x0), address(0x0)); + } + function testFailAssertNotEqAddrWithMsg() public { + assertNotEq(address(0x0), address(0x0), "msg"); + } + + // --- assertNotEq (Bytes32) --- + + function testAssertNotEqBytes32() public { + assertNotEq(bytes32("hi"), bytes32("ho"), "msg"); + assertNotEq(bytes32("hi"), bytes32("ho")); + } + function testFailAssertNotEqBytes32() public { + assertNotEq(bytes32("hi"), bytes32("hi")); + } + function testFailAssertNotEqBytes32WithMsg() public { + assertNotEq(bytes32("hi"), bytes32("hi"), "msg"); + } + + // --- assertNotEq (Int) --- + + function testAssertNotEqInt() public { + assertNotEq(-1, -2, "msg"); + assertNotEq(-1, -2); + } + function testFailAssertNotEqInt() public { + assertNotEq(-1, -1); + } + function testFailAssertNotEqIntWithMsg() public { + assertNotEq(-1, -1, "msg"); + } + + // --- assertNotEq (UInt) --- + + function testAssertNotEqUInt() public { + assertNotEq(uint(1), uint(2), "msg"); + assertNotEq(uint(1), uint(2)); + } + function testFailAssertNotEqUInt() public { + assertNotEq(uint(1), uint(1)); + } + function testFailAssertNotEqUIntWithMsg() public { + assertNotEq(uint(1), uint(1), "msg"); + } + + // --- assertNotEqDecimal (Int) --- + + function testAssertNotEqDecimalInt() public { + assertNotEqDecimal(-1, -2, 18, "msg"); + assertNotEqDecimal(-1, -2, 18); + } + function testFailAssertNotEqDecimalInt() public { + assertNotEqDecimal(-1, -1, 18); + } + function testFailAssertNotEqDecimalIntWithMsg() public { + assertNotEqDecimal(-1, -1, 18, "msg"); + } + + // --- assertNotEqDecimal (UInt) --- + + function testAssertNotEqDecimalUInt() public { + assertNotEqDecimal(uint(1), uint(2), 18, "msg"); + assertNotEqDecimal(uint(1), uint(2), 18); + } + function testFailAssertNotEqDecimalUInt() public { + assertNotEqDecimal(uint(1), uint(1), 18); + } + function testFailAssertNotEqDecimalUIntWithMsg() public { + assertNotEqDecimal(uint(1), uint(1), 18, "msg"); + } + + // --- assertGt (UInt) --- + + function testAssertGtUInt() public { + assertGt(uint(2), uint(1), "msg"); + assertGt(uint(3), uint(2)); + } + function testFailAssertGtUInt() public { + assertGt(uint(1), uint(2)); + } + function testFailAssertGtUIntWithMsg() public { + assertGt(uint(1), uint(2), "msg"); + } + + // --- assertGt (Int) --- + + function testAssertGtInt() public { + assertGt(-1, -2, "msg"); + assertGt(-1, -3); + } + function testFailAssertGtInt() public { + assertGt(-2, -1); + } + function testFailAssertGtIntWithMsg() public { + assertGt(-2, -1, "msg"); + } + + // --- assertGtDecimal (UInt) --- + + function testAssertGtDecimalUInt() public { + assertGtDecimal(uint(2), uint(1), 18, "msg"); + assertGtDecimal(uint(3), uint(2), 18); + } + function testFailAssertGtDecimalUInt() public { + assertGtDecimal(uint(1), uint(2), 18); + } + function testFailAssertGtDecimalUIntWithMsg() public { + assertGtDecimal(uint(1), uint(2), 18, "msg"); + } + + // --- assertGtDecimal (Int) --- + + function testAssertGtDecimalInt() public { + assertGtDecimal(-1, -2, 18, "msg"); + assertGtDecimal(-1, -3, 18); + } + function testFailAssertGtDecimalInt() public { + assertGtDecimal(-2, -1, 18); + } + function testFailAssertGtDecimalIntWithMsg() public { + assertGtDecimal(-2, -1, 18, "msg"); + } + + // --- assertGe (UInt) --- + + function testAssertGeUInt() public { + assertGe(uint(2), uint(1), "msg"); + assertGe(uint(2), uint(2)); + } + function testFailAssertGeUInt() public { + assertGe(uint(1), uint(2)); + } + function testFailAssertGeUIntWithMsg() public { + assertGe(uint(1), uint(2), "msg"); + } + + // --- assertGe (Int) --- + + function testAssertGeInt() public { + assertGe(-1, -2, "msg"); + assertGe(-1, -1); + } + function testFailAssertGeInt() public { + assertGe(-2, -1); + } + function testFailAssertGeIntWithMsg() public { + assertGe(-2, -1, "msg"); + } + + // --- assertGeDecimal (UInt) --- + + function testAssertGeDecimalUInt() public { + assertGeDecimal(uint(2), uint(1), 18, "msg"); + assertGeDecimal(uint(2), uint(2), 18); + } + function testFailAssertGeDecimalUInt() public { + assertGeDecimal(uint(1), uint(2), 18); + } + function testFailAssertGeDecimalUIntWithMsg() public { + assertGeDecimal(uint(1), uint(2), 18, "msg"); + } + + // --- assertGeDecimal (Int) --- + + function testAssertGeDecimalInt() public { + assertGeDecimal(-1, -2, 18, "msg"); + assertGeDecimal(-1, -2, 18); + } + function testFailAssertGeDecimalInt() public { + assertGeDecimal(-2, -1, 18); + } + function testFailAssertGeDecimalIntWithMsg() public { + assertGeDecimal(-2, -1, 18, "msg"); + } + + // --- assertLt (UInt) --- + + function testAssertLtUInt() public { + assertLt(uint(1), uint(2), "msg"); + assertLt(uint(1), uint(3)); + } + function testFailAssertLtUInt() public { + assertLt(uint(2), uint(2)); + } + function testFailAssertLtUIntWithMsg() public { + assertLt(uint(3), uint(2), "msg"); + } + + // --- assertLt (Int) --- + + function testAssertLtInt() public { + assertLt(-2, -1, "msg"); + assertLt(-1, 0); + } + function testFailAssertLtInt() public { + assertLt(-1, -2); + } + function testFailAssertLtIntWithMsg() public { + assertLt(-1, -1, "msg"); + } + + // --- assertLtDecimal (UInt) --- + + function testAssertLtDecimalUInt() public { + assertLtDecimal(uint(1), uint(2), 18, "msg"); + assertLtDecimal(uint(2), uint(3), 18); + } + function testFailAssertLtDecimalUInt() public { + assertLtDecimal(uint(1), uint(1), 18); + } + function testFailAssertLtDecimalUIntWithMsg() public { + assertLtDecimal(uint(2), uint(1), 18, "msg"); + } + + // --- assertLtDecimal (Int) --- + + function testAssertLtDecimalInt() public { + assertLtDecimal(-2, -1, 18, "msg"); + assertLtDecimal(-2, -1, 18); + } + function testFailAssertLtDecimalInt() public { + assertLtDecimal(-2, -2, 18); + } + function testFailAssertLtDecimalIntWithMsg() public { + assertLtDecimal(-1, -2, 18, "msg"); + } + + // --- assertLe (UInt) --- + + function testAssertLeUInt() public { + assertLe(uint(1), uint(2), "msg"); + assertLe(uint(1), uint(1)); + } + function testFailAssertLeUInt() public { + assertLe(uint(4), uint(2)); + } + function testFailAssertLeUIntWithMsg() public { + assertLe(uint(3), uint(2), "msg"); + } + + // --- assertLe (Int) --- + + function testAssertLeInt() public { + assertLe(-2, -1, "msg"); + assertLe(-1, -1); + } + function testFailAssertLeInt() public { + assertLe(-1, -2); + } + function testFailAssertLeIntWithMsg() public { + assertLe(-1, -3, "msg"); + } + + // --- assertLeDecimal (UInt) --- + + function testAssertLeDecimalUInt() public { + assertLeDecimal(uint(1), uint(2), 18, "msg"); + assertLeDecimal(uint(2), uint(2), 18); + } + function testFailAssertLeDecimalUInt() public { + assertLeDecimal(uint(1), uint(0), 18); + } + function testFailAssertLeDecimalUIntWithMsg() public { + assertLeDecimal(uint(1), uint(0), 18, "msg"); + } + + // --- assertLeDecimal (Int) --- + + function testAssertLeDecimalInt() public { + assertLeDecimal(-2, -1, 18, "msg"); + assertLeDecimal(-2, -2, 18); + } + function testFailAssertLeDecimalInt() public { + assertLeDecimal(-2, -3, 18); + } + function testFailAssertLeDecimalIntWithMsg() public { + assertLeDecimal(-1, -2, 18, "msg"); + } + + // --- assertNotEq (String) --- + + function testAssertNotEqString() public { + assertNotEq(new string(1), new string(2), "msg"); + assertNotEq(new string(1), new string(2)); + } + function testFailAssertNotEqString() public { + assertNotEq(new string(1), new string(1)); + } + function testFailAssertNotEqStringWithMsg() public { + assertNotEq(new string(1), new string(1), "msg"); + } + + // --- assertNotEq0 (Bytes) --- + + function testAssertNotEq0Bytes() public { + assertNotEq0(bytes("hi"), bytes("ho"), "msg"); + assertNotEq0(bytes("hi"), bytes("ho")); + } + function testFailAssertNotEq0Bytes() public { + assertNotEq0(bytes("hi"), bytes("hi")); + } + function testFailAssertNotEq0BytesWithMsg() public { + assertNotEq0(bytes("hi"), bytes("hi"), "msg"); + } + + // --- fail override --- + + // ensure that fail can be overridden + function fail() internal override { + super.fail(); + } +} diff --git a/docs/crypto/zkCTF/day1/Ethereal/mint-contracts/lib/forge-std/package.json b/docs/crypto/zkCTF/day1/Ethereal/mint-contracts/lib/forge-std/package.json new file mode 100644 index 0000000..5b18b42 --- /dev/null +++ b/docs/crypto/zkCTF/day1/Ethereal/mint-contracts/lib/forge-std/package.json @@ -0,0 +1,16 @@ +{ + "name": "forge-std", + "version": "1.7.5", + "description": "Forge Standard Library is a collection of helpful contracts and libraries for use with Forge and Foundry.", + "homepage": "https://book.getfoundry.sh/forge/forge-std", + "bugs": "https://github.com/foundry-rs/forge-std/issues", + "license": "(Apache-2.0 OR MIT)", + "author": "Contributors to Forge Standard Library", + "files": [ + "src/**/*" + ], + "repository": { + "type": "git", + "url": "https://github.com/foundry-rs/forge-std.git" + } +} diff --git a/docs/crypto/zkCTF/day1/Ethereal/mint-contracts/lib/forge-std/scripts/vm.py b/docs/crypto/zkCTF/day1/Ethereal/mint-contracts/lib/forge-std/scripts/vm.py new file mode 100644 index 0000000..eefb4b7 --- /dev/null +++ b/docs/crypto/zkCTF/day1/Ethereal/mint-contracts/lib/forge-std/scripts/vm.py @@ -0,0 +1,666 @@ +#!/usr/bin/env python3 + +import copy +import json +import re +import subprocess +from enum import Enum as PyEnum +from typing import Callable +from urllib import request + +VoidFn = Callable[[], None] + +CHEATCODES_JSON_URL = "https://raw.githubusercontent.com/foundry-rs/foundry/master/crates/cheatcodes/assets/cheatcodes.json" +OUT_PATH = "src/Vm.sol" + +VM_SAFE_DOC = """\ +/// The `VmSafe` interface does not allow manipulation of the EVM state or other actions that may +/// result in Script simulations differing from on-chain execution. It is recommended to only use +/// these cheats in scripts. +""" + +VM_DOC = """\ +/// The `Vm` interface does allow manipulation of the EVM state. These are all intended to be used +/// in tests, but it is not recommended to use these cheats in scripts. +""" + + +def main(): + json_str = request.urlopen(CHEATCODES_JSON_URL).read().decode("utf-8") + contract = Cheatcodes.from_json(json_str) + + ccs = contract.cheatcodes + ccs = list(filter(lambda cc: cc.status != Status.EXPERIMENTAL, ccs)) + ccs.sort(key=lambda cc: cc.func.id) + + safe = list(filter(lambda cc: cc.safety == Safety.SAFE, ccs)) + safe.sort(key=CmpCheatcode) + unsafe = list(filter(lambda cc: cc.safety == Safety.UNSAFE, ccs)) + unsafe.sort(key=CmpCheatcode) + assert len(safe) + len(unsafe) == len(ccs) + + prefix_with_group_headers(safe) + prefix_with_group_headers(unsafe) + + out = "" + + out += "// Automatically @generated by scripts/vm.py. Do not modify manually.\n\n" + + pp = CheatcodesPrinter( + spdx_identifier="MIT OR Apache-2.0", + solidity_requirement=">=0.6.2 <0.9.0", + abicoder_pragma=True, + ) + pp.p_prelude() + pp.prelude = False + out += pp.finish() + + out += "\n\n" + out += VM_SAFE_DOC + vm_safe = Cheatcodes( + # TODO: Custom errors were introduced in 0.8.4 + errors=[], # contract.errors + events=contract.events, + enums=contract.enums, + structs=contract.structs, + cheatcodes=safe, + ) + pp.p_contract(vm_safe, "VmSafe") + out += pp.finish() + + out += "\n\n" + out += VM_DOC + vm_unsafe = Cheatcodes( + errors=[], + events=[], + enums=[], + structs=[], + cheatcodes=unsafe, + ) + pp.p_contract(vm_unsafe, "Vm", "VmSafe") + out += pp.finish() + + # Compatibility with <0.8.0 + def memory_to_calldata(m: re.Match) -> str: + return " calldata " + m.group(1) + + out = re.sub(r" memory (.*returns)", memory_to_calldata, out) + + with open(OUT_PATH, "w") as f: + f.write(out) + + forge_fmt = ["forge", "fmt", OUT_PATH] + res = subprocess.run(forge_fmt) + assert res.returncode == 0, f"command failed: {forge_fmt}" + + print(f"Wrote to {OUT_PATH}") + + +class CmpCheatcode: + cheatcode: "Cheatcode" + + def __init__(self, cheatcode: "Cheatcode"): + self.cheatcode = cheatcode + + def __lt__(self, other: "CmpCheatcode") -> bool: + return cmp_cheatcode(self.cheatcode, other.cheatcode) < 0 + + def __eq__(self, other: "CmpCheatcode") -> bool: + return cmp_cheatcode(self.cheatcode, other.cheatcode) == 0 + + def __gt__(self, other: "CmpCheatcode") -> bool: + return cmp_cheatcode(self.cheatcode, other.cheatcode) > 0 + + +def cmp_cheatcode(a: "Cheatcode", b: "Cheatcode") -> int: + if a.group != b.group: + return -1 if a.group < b.group else 1 + if a.status != b.status: + return -1 if a.status < b.status else 1 + if a.safety != b.safety: + return -1 if a.safety < b.safety else 1 + if a.func.id != b.func.id: + return -1 if a.func.id < b.func.id else 1 + return 0 + + +# HACK: A way to add group header comments without having to modify printer code +def prefix_with_group_headers(cheats: list["Cheatcode"]): + s = set() + for i, cheat in enumerate(cheats): + if cheat.group in s: + continue + + s.add(cheat.group) + + c = copy.deepcopy(cheat) + c.func.description = "" + c.func.declaration = f"// ======== {c.group} ========" + cheats.insert(i, c) + return cheats + + +class Status(PyEnum): + STABLE: str = "stable" + EXPERIMENTAL: str = "experimental" + DEPRECATED: str = "deprecated" + REMOVED: str = "removed" + + def __lt__(self, other: "Group") -> bool: + return self.value < other.value + + +class Group(PyEnum): + EVM: str = "evm" + TESTING: str = "testing" + SCRIPTING: str = "scripting" + FILESYSTEM: str = "filesystem" + ENVIRONMENT: str = "environment" + STRING: str = "string" + JSON: str = "json" + UTILITIES: str = "utilities" + + def __str__(self): + if self == Group.EVM: + return "EVM" + if self == Group.JSON: + return "JSON" + return self.value[0].upper() + self.value[1:] + + def __lt__(self, other: "Group") -> bool: + return self.value < other.value + + +class Safety(PyEnum): + UNSAFE: str = "unsafe" + SAFE: str = "safe" + + def __lt__(self, other: "Group") -> bool: + return self.value < other.value + + +class Visibility(PyEnum): + EXTERNAL: str = "external" + PUBLIC: str = "public" + INTERNAL: str = "internal" + PRIVATE: str = "private" + + def __str__(self): + return self.value + + +class Mutability(PyEnum): + PURE: str = "pure" + VIEW: str = "view" + NONE: str = "" + + def __str__(self): + return self.value + + +class Function: + id: str + description: str + declaration: str + visibility: Visibility + mutability: Mutability + signature: str + selector: str + selector_bytes: bytes + + def __init__( + self, + id: str, + description: str, + declaration: str, + visibility: Visibility, + mutability: Mutability, + signature: str, + selector: str, + selector_bytes: bytes, + ): + self.id = id + self.description = description + self.declaration = declaration + self.visibility = visibility + self.mutability = mutability + self.signature = signature + self.selector = selector + self.selector_bytes = selector_bytes + + @staticmethod + def from_dict(d: dict) -> "Function": + return Function( + d["id"], + d["description"], + d["declaration"], + Visibility(d["visibility"]), + Mutability(d["mutability"]), + d["signature"], + d["selector"], + bytes(d["selectorBytes"]), + ) + + +class Cheatcode: + func: Function + group: Group + status: Status + safety: Safety + + def __init__(self, func: Function, group: Group, status: Status, safety: Safety): + self.func = func + self.group = group + self.status = status + self.safety = safety + + @staticmethod + def from_dict(d: dict) -> "Cheatcode": + return Cheatcode( + Function.from_dict(d["func"]), + Group(d["group"]), + Status(d["status"]), + Safety(d["safety"]), + ) + + +class Error: + name: str + description: str + declaration: str + + def __init__(self, name: str, description: str, declaration: str): + self.name = name + self.description = description + self.declaration = declaration + + @staticmethod + def from_dict(d: dict) -> "Error": + return Error(**d) + + +class Event: + name: str + description: str + declaration: str + + def __init__(self, name: str, description: str, declaration: str): + self.name = name + self.description = description + self.declaration = declaration + + @staticmethod + def from_dict(d: dict) -> "Event": + return Event(**d) + + +class EnumVariant: + name: str + description: str + + def __init__(self, name: str, description: str): + self.name = name + self.description = description + + +class Enum: + name: str + description: str + variants: list[EnumVariant] + + def __init__(self, name: str, description: str, variants: list[EnumVariant]): + self.name = name + self.description = description + self.variants = variants + + @staticmethod + def from_dict(d: dict) -> "Enum": + return Enum( + d["name"], + d["description"], + list(map(lambda v: EnumVariant(**v), d["variants"])), + ) + + +class StructField: + name: str + ty: str + description: str + + def __init__(self, name: str, ty: str, description: str): + self.name = name + self.ty = ty + self.description = description + + +class Struct: + name: str + description: str + fields: list[StructField] + + def __init__(self, name: str, description: str, fields: list[StructField]): + self.name = name + self.description = description + self.fields = fields + + @staticmethod + def from_dict(d: dict) -> "Struct": + return Struct( + d["name"], + d["description"], + list(map(lambda f: StructField(**f), d["fields"])), + ) + + +class Cheatcodes: + errors: list[Error] + events: list[Event] + enums: list[Enum] + structs: list[Struct] + cheatcodes: list[Cheatcode] + + def __init__( + self, + errors: list[Error], + events: list[Event], + enums: list[Enum], + structs: list[Struct], + cheatcodes: list[Cheatcode], + ): + self.errors = errors + self.events = events + self.enums = enums + self.structs = structs + self.cheatcodes = cheatcodes + + @staticmethod + def from_dict(d: dict) -> "Cheatcodes": + return Cheatcodes( + errors=[Error.from_dict(e) for e in d["errors"]], + events=[Event.from_dict(e) for e in d["events"]], + enums=[Enum.from_dict(e) for e in d["enums"]], + structs=[Struct.from_dict(e) for e in d["structs"]], + cheatcodes=[Cheatcode.from_dict(e) for e in d["cheatcodes"]], + ) + + @staticmethod + def from_json(s) -> "Cheatcodes": + return Cheatcodes.from_dict(json.loads(s)) + + @staticmethod + def from_json_file(file_path: str) -> "Cheatcodes": + with open(file_path, "r") as f: + return Cheatcodes.from_dict(json.load(f)) + + +class Item(PyEnum): + ERROR: str = "error" + EVENT: str = "event" + ENUM: str = "enum" + STRUCT: str = "struct" + FUNCTION: str = "function" + + +class ItemOrder: + _list: list[Item] + + def __init__(self, list: list[Item]) -> None: + assert len(list) <= len(Item), "list must not contain more items than Item" + assert len(list) == len(set(list)), "list must not contain duplicates" + self._list = list + pass + + def get_list(self) -> list[Item]: + return self._list + + @staticmethod + def default() -> "ItemOrder": + return ItemOrder( + [ + Item.ERROR, + Item.EVENT, + Item.ENUM, + Item.STRUCT, + Item.FUNCTION, + ] + ) + + +class CheatcodesPrinter: + buffer: str + + prelude: bool + spdx_identifier: str + solidity_requirement: str + abicoder_v2: bool + + block_doc_style: bool + + indent_level: int + _indent_str: str + + nl_str: str + + items_order: ItemOrder + + def __init__( + self, + buffer: str = "", + prelude: bool = True, + spdx_identifier: str = "UNLICENSED", + solidity_requirement: str = "", + abicoder_pragma: bool = False, + block_doc_style: bool = False, + indent_level: int = 0, + indent_with: int | str = 4, + nl_str: str = "\n", + items_order: ItemOrder = ItemOrder.default(), + ): + self.prelude = prelude + self.spdx_identifier = spdx_identifier + self.solidity_requirement = solidity_requirement + self.abicoder_v2 = abicoder_pragma + self.block_doc_style = block_doc_style + self.buffer = buffer + self.indent_level = indent_level + self.nl_str = nl_str + + if isinstance(indent_with, int): + assert indent_with >= 0 + self._indent_str = " " * indent_with + elif isinstance(indent_with, str): + self._indent_str = indent_with + else: + assert False, "indent_with must be int or str" + + self.items_order = items_order + + def finish(self) -> str: + ret = self.buffer.rstrip() + self.buffer = "" + return ret + + def p_contract(self, contract: Cheatcodes, name: str, inherits: str = ""): + if self.prelude: + self.p_prelude(contract) + + self._p_str("interface ") + name = name.strip() + if name != "": + self._p_str(name) + self._p_str(" ") + if inherits != "": + self._p_str("is ") + self._p_str(inherits) + self._p_str(" ") + self._p_str("{") + self._p_nl() + self._with_indent(lambda: self._p_items(contract)) + self._p_str("}") + self._p_nl() + + def _p_items(self, contract: Cheatcodes): + for item in self.items_order.get_list(): + if item == Item.ERROR: + self.p_errors(contract.errors) + elif item == Item.EVENT: + self.p_events(contract.events) + elif item == Item.ENUM: + self.p_enums(contract.enums) + elif item == Item.STRUCT: + self.p_structs(contract.structs) + elif item == Item.FUNCTION: + self.p_functions(contract.cheatcodes) + else: + assert False, f"unknown item {item}" + + def p_prelude(self, contract: Cheatcodes | None = None): + self._p_str(f"// SPDX-License-Identifier: {self.spdx_identifier}") + self._p_nl() + + if self.solidity_requirement != "": + req = self.solidity_requirement + elif contract and len(contract.errors) > 0: + req = ">=0.8.4 <0.9.0" + else: + req = ">=0.6.0 <0.9.0" + self._p_str(f"pragma solidity {req};") + self._p_nl() + + if self.abicoder_v2: + self._p_str("pragma experimental ABIEncoderV2;") + self._p_nl() + + self._p_nl() + + def p_errors(self, errors: list[Error]): + for error in errors: + self._p_line(lambda: self.p_error(error)) + + def p_error(self, error: Error): + self._p_comment(error.description, doc=True) + self._p_line(lambda: self._p_str(error.declaration)) + + def p_events(self, events: list[Event]): + for event in events: + self._p_line(lambda: self.p_event(event)) + + def p_event(self, event: Event): + self._p_comment(event.description, doc=True) + self._p_line(lambda: self._p_str(event.declaration)) + + def p_enums(self, enums: list[Enum]): + for enum in enums: + self._p_line(lambda: self.p_enum(enum)) + + def p_enum(self, enum: Enum): + self._p_comment(enum.description, doc=True) + self._p_line(lambda: self._p_str(f"enum {enum.name} {{")) + self._with_indent(lambda: self.p_enum_variants(enum.variants)) + self._p_line(lambda: self._p_str("}")) + + def p_enum_variants(self, variants: list[EnumVariant]): + for i, variant in enumerate(variants): + self._p_indent() + self._p_comment(variant.description) + + self._p_indent() + self._p_str(variant.name) + if i < len(variants) - 1: + self._p_str(",") + self._p_nl() + + def p_structs(self, structs: list[Struct]): + for struct in structs: + self._p_line(lambda: self.p_struct(struct)) + + def p_struct(self, struct: Struct): + self._p_comment(struct.description, doc=True) + self._p_line(lambda: self._p_str(f"struct {struct.name} {{")) + self._with_indent(lambda: self.p_struct_fields(struct.fields)) + self._p_line(lambda: self._p_str("}")) + + def p_struct_fields(self, fields: list[StructField]): + for field in fields: + self._p_line(lambda: self.p_struct_field(field)) + + def p_struct_field(self, field: StructField): + self._p_comment(field.description) + self._p_indented(lambda: self._p_str(f"{field.ty} {field.name};")) + + def p_functions(self, cheatcodes: list[Cheatcode]): + for cheatcode in cheatcodes: + self._p_line(lambda: self.p_function(cheatcode.func)) + + def p_function(self, func: Function): + self._p_comment(func.description, doc=True) + self._p_line(lambda: self._p_str(func.declaration)) + + def _p_comment(self, s: str, doc: bool = False): + s = s.strip() + if s == "": + return + + s = map(lambda line: line.lstrip(), s.split("\n")) + if self.block_doc_style: + self._p_str("/*") + if doc: + self._p_str("*") + self._p_nl() + for line in s: + self._p_indent() + self._p_str(" ") + if doc: + self._p_str("* ") + self._p_str(line) + self._p_nl() + self._p_indent() + self._p_str(" */") + self._p_nl() + else: + first_line = True + for line in s: + if not first_line: + self._p_indent() + first_line = False + + if doc: + self._p_str("/// ") + else: + self._p_str("// ") + self._p_str(line) + self._p_nl() + + def _with_indent(self, f: VoidFn): + self._inc_indent() + f() + self._dec_indent() + + def _p_line(self, f: VoidFn): + self._p_indent() + f() + self._p_nl() + + def _p_indented(self, f: VoidFn): + self._p_indent() + f() + + def _p_indent(self): + for _ in range(self.indent_level): + self._p_str(self._indent_str) + + def _p_nl(self): + self._p_str(self.nl_str) + + def _p_str(self, txt: str): + self.buffer += txt + + def _inc_indent(self): + self.indent_level += 1 + + def _dec_indent(self): + self.indent_level -= 1 + + +if __name__ == "__main__": + main() diff --git a/docs/crypto/zkCTF/day1/Ethereal/mint-contracts/lib/forge-std/src/Base.sol b/docs/crypto/zkCTF/day1/Ethereal/mint-contracts/lib/forge-std/src/Base.sol new file mode 100644 index 0000000..851ac0c --- /dev/null +++ b/docs/crypto/zkCTF/day1/Ethereal/mint-contracts/lib/forge-std/src/Base.sol @@ -0,0 +1,35 @@ +// SPDX-License-Identifier: MIT +pragma solidity >=0.6.2 <0.9.0; + +import {StdStorage} from "./StdStorage.sol"; +import {Vm, VmSafe} from "./Vm.sol"; + +abstract contract CommonBase { + // Cheat code address, 0x7109709ECfa91a80626fF3989D68f67F5b1DD12D. + address internal constant VM_ADDRESS = address(uint160(uint256(keccak256("hevm cheat code")))); + // console.sol and console2.sol work by executing a staticcall to this address. + address internal constant CONSOLE = 0x000000000000000000636F6e736F6c652e6c6f67; + // Used when deploying with create2, https://github.com/Arachnid/deterministic-deployment-proxy. + address internal constant CREATE2_FACTORY = 0x4e59b44847b379578588920cA78FbF26c0B4956C; + // Default address for tx.origin and msg.sender, 0x1804c8AB1F12E6bbf3894d4083f33e07309d1f38. + address internal constant DEFAULT_SENDER = address(uint160(uint256(keccak256("foundry default caller")))); + // Address of the test contract, deployed by the DEFAULT_SENDER. + address internal constant DEFAULT_TEST_CONTRACT = 0x5615dEB798BB3E4dFa0139dFa1b3D433Cc23b72f; + // Deterministic deployment address of the Multicall3 contract. + address internal constant MULTICALL3_ADDRESS = 0xcA11bde05977b3631167028862bE2a173976CA11; + // The order of the secp256k1 curve. + uint256 internal constant SECP256K1_ORDER = + 115792089237316195423570985008687907852837564279074904382605163141518161494337; + + uint256 internal constant UINT256_MAX = + 115792089237316195423570985008687907853269984665640564039457584007913129639935; + + Vm internal constant vm = Vm(VM_ADDRESS); + StdStorage internal stdstore; +} + +abstract contract TestBase is CommonBase {} + +abstract contract ScriptBase is CommonBase { + VmSafe internal constant vmSafe = VmSafe(VM_ADDRESS); +} diff --git a/docs/crypto/zkCTF/day1/Ethereal/mint-contracts/lib/forge-std/src/Script.sol b/docs/crypto/zkCTF/day1/Ethereal/mint-contracts/lib/forge-std/src/Script.sol new file mode 100644 index 0000000..94e75f6 --- /dev/null +++ b/docs/crypto/zkCTF/day1/Ethereal/mint-contracts/lib/forge-std/src/Script.sol @@ -0,0 +1,27 @@ +// SPDX-License-Identifier: MIT +pragma solidity >=0.6.2 <0.9.0; + +// 💬 ABOUT +// Forge Std's default Script. + +// 🧩 MODULES +import {console} from "./console.sol"; +import {console2} from "./console2.sol"; +import {safeconsole} from "./safeconsole.sol"; +import {StdChains} from "./StdChains.sol"; +import {StdCheatsSafe} from "./StdCheats.sol"; +import {stdJson} from "./StdJson.sol"; +import {stdMath} from "./StdMath.sol"; +import {StdStorage, stdStorageSafe} from "./StdStorage.sol"; +import {StdStyle} from "./StdStyle.sol"; +import {StdUtils} from "./StdUtils.sol"; +import {VmSafe} from "./Vm.sol"; + +// 📦 BOILERPLATE +import {ScriptBase} from "./Base.sol"; + +// ⭐️ SCRIPT +abstract contract Script is ScriptBase, StdChains, StdCheatsSafe, StdUtils { + // Note: IS_SCRIPT() must return true. + bool public IS_SCRIPT = true; +} diff --git a/docs/crypto/zkCTF/day1/Ethereal/mint-contracts/lib/forge-std/src/StdAssertions.sol b/docs/crypto/zkCTF/day1/Ethereal/mint-contracts/lib/forge-std/src/StdAssertions.sol new file mode 100644 index 0000000..2778b3a --- /dev/null +++ b/docs/crypto/zkCTF/day1/Ethereal/mint-contracts/lib/forge-std/src/StdAssertions.sol @@ -0,0 +1,376 @@ +// SPDX-License-Identifier: MIT +pragma solidity >=0.6.2 <0.9.0; + +import {DSTest} from "ds-test/test.sol"; +import {stdMath} from "./StdMath.sol"; + +abstract contract StdAssertions is DSTest { + event log_array(uint256[] val); + event log_array(int256[] val); + event log_array(address[] val); + event log_named_array(string key, uint256[] val); + event log_named_array(string key, int256[] val); + event log_named_array(string key, address[] val); + + function fail(string memory err) internal virtual { + emit log_named_string("Error", err); + fail(); + } + + function assertFalse(bool data) internal virtual { + assertTrue(!data); + } + + function assertFalse(bool data, string memory err) internal virtual { + assertTrue(!data, err); + } + + function assertEq(bool a, bool b) internal virtual { + if (a != b) { + emit log("Error: a == b not satisfied [bool]"); + emit log_named_string(" Left", a ? "true" : "false"); + emit log_named_string(" Right", b ? "true" : "false"); + fail(); + } + } + + function assertEq(bool a, bool b, string memory err) internal virtual { + if (a != b) { + emit log_named_string("Error", err); + assertEq(a, b); + } + } + + function assertEq(bytes memory a, bytes memory b) internal virtual { + assertEq0(a, b); + } + + function assertEq(bytes memory a, bytes memory b, string memory err) internal virtual { + assertEq0(a, b, err); + } + + function assertEq(uint256[] memory a, uint256[] memory b) internal virtual { + if (keccak256(abi.encode(a)) != keccak256(abi.encode(b))) { + emit log("Error: a == b not satisfied [uint[]]"); + emit log_named_array(" Left", a); + emit log_named_array(" Right", b); + fail(); + } + } + + function assertEq(int256[] memory a, int256[] memory b) internal virtual { + if (keccak256(abi.encode(a)) != keccak256(abi.encode(b))) { + emit log("Error: a == b not satisfied [int[]]"); + emit log_named_array(" Left", a); + emit log_named_array(" Right", b); + fail(); + } + } + + function assertEq(address[] memory a, address[] memory b) internal virtual { + if (keccak256(abi.encode(a)) != keccak256(abi.encode(b))) { + emit log("Error: a == b not satisfied [address[]]"); + emit log_named_array(" Left", a); + emit log_named_array(" Right", b); + fail(); + } + } + + function assertEq(uint256[] memory a, uint256[] memory b, string memory err) internal virtual { + if (keccak256(abi.encode(a)) != keccak256(abi.encode(b))) { + emit log_named_string("Error", err); + assertEq(a, b); + } + } + + function assertEq(int256[] memory a, int256[] memory b, string memory err) internal virtual { + if (keccak256(abi.encode(a)) != keccak256(abi.encode(b))) { + emit log_named_string("Error", err); + assertEq(a, b); + } + } + + function assertEq(address[] memory a, address[] memory b, string memory err) internal virtual { + if (keccak256(abi.encode(a)) != keccak256(abi.encode(b))) { + emit log_named_string("Error", err); + assertEq(a, b); + } + } + + // Legacy helper + function assertEqUint(uint256 a, uint256 b) internal virtual { + assertEq(uint256(a), uint256(b)); + } + + function assertApproxEqAbs(uint256 a, uint256 b, uint256 maxDelta) internal virtual { + uint256 delta = stdMath.delta(a, b); + + if (delta > maxDelta) { + emit log("Error: a ~= b not satisfied [uint]"); + emit log_named_uint(" Left", a); + emit log_named_uint(" Right", b); + emit log_named_uint(" Max Delta", maxDelta); + emit log_named_uint(" Delta", delta); + fail(); + } + } + + function assertApproxEqAbs(uint256 a, uint256 b, uint256 maxDelta, string memory err) internal virtual { + uint256 delta = stdMath.delta(a, b); + + if (delta > maxDelta) { + emit log_named_string("Error", err); + assertApproxEqAbs(a, b, maxDelta); + } + } + + function assertApproxEqAbsDecimal(uint256 a, uint256 b, uint256 maxDelta, uint256 decimals) internal virtual { + uint256 delta = stdMath.delta(a, b); + + if (delta > maxDelta) { + emit log("Error: a ~= b not satisfied [uint]"); + emit log_named_decimal_uint(" Left", a, decimals); + emit log_named_decimal_uint(" Right", b, decimals); + emit log_named_decimal_uint(" Max Delta", maxDelta, decimals); + emit log_named_decimal_uint(" Delta", delta, decimals); + fail(); + } + } + + function assertApproxEqAbsDecimal(uint256 a, uint256 b, uint256 maxDelta, uint256 decimals, string memory err) + internal + virtual + { + uint256 delta = stdMath.delta(a, b); + + if (delta > maxDelta) { + emit log_named_string("Error", err); + assertApproxEqAbsDecimal(a, b, maxDelta, decimals); + } + } + + function assertApproxEqAbs(int256 a, int256 b, uint256 maxDelta) internal virtual { + uint256 delta = stdMath.delta(a, b); + + if (delta > maxDelta) { + emit log("Error: a ~= b not satisfied [int]"); + emit log_named_int(" Left", a); + emit log_named_int(" Right", b); + emit log_named_uint(" Max Delta", maxDelta); + emit log_named_uint(" Delta", delta); + fail(); + } + } + + function assertApproxEqAbs(int256 a, int256 b, uint256 maxDelta, string memory err) internal virtual { + uint256 delta = stdMath.delta(a, b); + + if (delta > maxDelta) { + emit log_named_string("Error", err); + assertApproxEqAbs(a, b, maxDelta); + } + } + + function assertApproxEqAbsDecimal(int256 a, int256 b, uint256 maxDelta, uint256 decimals) internal virtual { + uint256 delta = stdMath.delta(a, b); + + if (delta > maxDelta) { + emit log("Error: a ~= b not satisfied [int]"); + emit log_named_decimal_int(" Left", a, decimals); + emit log_named_decimal_int(" Right", b, decimals); + emit log_named_decimal_uint(" Max Delta", maxDelta, decimals); + emit log_named_decimal_uint(" Delta", delta, decimals); + fail(); + } + } + + function assertApproxEqAbsDecimal(int256 a, int256 b, uint256 maxDelta, uint256 decimals, string memory err) + internal + virtual + { + uint256 delta = stdMath.delta(a, b); + + if (delta > maxDelta) { + emit log_named_string("Error", err); + assertApproxEqAbsDecimal(a, b, maxDelta, decimals); + } + } + + function assertApproxEqRel( + uint256 a, + uint256 b, + uint256 maxPercentDelta // An 18 decimal fixed point number, where 1e18 == 100% + ) internal virtual { + if (b == 0) return assertEq(a, b); // If the left is 0, right must be too. + + uint256 percentDelta = stdMath.percentDelta(a, b); + + if (percentDelta > maxPercentDelta) { + emit log("Error: a ~= b not satisfied [uint]"); + emit log_named_uint(" Left", a); + emit log_named_uint(" Right", b); + emit log_named_decimal_uint(" Max % Delta", maxPercentDelta * 100, 18); + emit log_named_decimal_uint(" % Delta", percentDelta * 100, 18); + fail(); + } + } + + function assertApproxEqRel( + uint256 a, + uint256 b, + uint256 maxPercentDelta, // An 18 decimal fixed point number, where 1e18 == 100% + string memory err + ) internal virtual { + if (b == 0) return assertEq(a, b, err); // If the left is 0, right must be too. + + uint256 percentDelta = stdMath.percentDelta(a, b); + + if (percentDelta > maxPercentDelta) { + emit log_named_string("Error", err); + assertApproxEqRel(a, b, maxPercentDelta); + } + } + + function assertApproxEqRelDecimal( + uint256 a, + uint256 b, + uint256 maxPercentDelta, // An 18 decimal fixed point number, where 1e18 == 100% + uint256 decimals + ) internal virtual { + if (b == 0) return assertEq(a, b); // If the left is 0, right must be too. + + uint256 percentDelta = stdMath.percentDelta(a, b); + + if (percentDelta > maxPercentDelta) { + emit log("Error: a ~= b not satisfied [uint]"); + emit log_named_decimal_uint(" Left", a, decimals); + emit log_named_decimal_uint(" Right", b, decimals); + emit log_named_decimal_uint(" Max % Delta", maxPercentDelta * 100, 18); + emit log_named_decimal_uint(" % Delta", percentDelta * 100, 18); + fail(); + } + } + + function assertApproxEqRelDecimal( + uint256 a, + uint256 b, + uint256 maxPercentDelta, // An 18 decimal fixed point number, where 1e18 == 100% + uint256 decimals, + string memory err + ) internal virtual { + if (b == 0) return assertEq(a, b, err); // If the left is 0, right must be too. + + uint256 percentDelta = stdMath.percentDelta(a, b); + + if (percentDelta > maxPercentDelta) { + emit log_named_string("Error", err); + assertApproxEqRelDecimal(a, b, maxPercentDelta, decimals); + } + } + + function assertApproxEqRel(int256 a, int256 b, uint256 maxPercentDelta) internal virtual { + if (b == 0) return assertEq(a, b); // If the left is 0, right must be too. + + uint256 percentDelta = stdMath.percentDelta(a, b); + + if (percentDelta > maxPercentDelta) { + emit log("Error: a ~= b not satisfied [int]"); + emit log_named_int(" Left", a); + emit log_named_int(" Right", b); + emit log_named_decimal_uint(" Max % Delta", maxPercentDelta * 100, 18); + emit log_named_decimal_uint(" % Delta", percentDelta * 100, 18); + fail(); + } + } + + function assertApproxEqRel(int256 a, int256 b, uint256 maxPercentDelta, string memory err) internal virtual { + if (b == 0) return assertEq(a, b, err); // If the left is 0, right must be too. + + uint256 percentDelta = stdMath.percentDelta(a, b); + + if (percentDelta > maxPercentDelta) { + emit log_named_string("Error", err); + assertApproxEqRel(a, b, maxPercentDelta); + } + } + + function assertApproxEqRelDecimal(int256 a, int256 b, uint256 maxPercentDelta, uint256 decimals) internal virtual { + if (b == 0) return assertEq(a, b); // If the left is 0, right must be too. + + uint256 percentDelta = stdMath.percentDelta(a, b); + + if (percentDelta > maxPercentDelta) { + emit log("Error: a ~= b not satisfied [int]"); + emit log_named_decimal_int(" Left", a, decimals); + emit log_named_decimal_int(" Right", b, decimals); + emit log_named_decimal_uint(" Max % Delta", maxPercentDelta * 100, 18); + emit log_named_decimal_uint(" % Delta", percentDelta * 100, 18); + fail(); + } + } + + function assertApproxEqRelDecimal(int256 a, int256 b, uint256 maxPercentDelta, uint256 decimals, string memory err) + internal + virtual + { + if (b == 0) return assertEq(a, b, err); // If the left is 0, right must be too. + + uint256 percentDelta = stdMath.percentDelta(a, b); + + if (percentDelta > maxPercentDelta) { + emit log_named_string("Error", err); + assertApproxEqRelDecimal(a, b, maxPercentDelta, decimals); + } + } + + function assertEqCall(address target, bytes memory callDataA, bytes memory callDataB) internal virtual { + assertEqCall(target, callDataA, target, callDataB, true); + } + + function assertEqCall(address targetA, bytes memory callDataA, address targetB, bytes memory callDataB) + internal + virtual + { + assertEqCall(targetA, callDataA, targetB, callDataB, true); + } + + function assertEqCall(address target, bytes memory callDataA, bytes memory callDataB, bool strictRevertData) + internal + virtual + { + assertEqCall(target, callDataA, target, callDataB, strictRevertData); + } + + function assertEqCall( + address targetA, + bytes memory callDataA, + address targetB, + bytes memory callDataB, + bool strictRevertData + ) internal virtual { + (bool successA, bytes memory returnDataA) = address(targetA).call(callDataA); + (bool successB, bytes memory returnDataB) = address(targetB).call(callDataB); + + if (successA && successB) { + assertEq(returnDataA, returnDataB, "Call return data does not match"); + } + + if (!successA && !successB && strictRevertData) { + assertEq(returnDataA, returnDataB, "Call revert data does not match"); + } + + if (!successA && successB) { + emit log("Error: Calls were not equal"); + emit log_named_bytes(" Left call revert data", returnDataA); + emit log_named_bytes(" Right call return data", returnDataB); + fail(); + } + + if (successA && !successB) { + emit log("Error: Calls were not equal"); + emit log_named_bytes(" Left call return data", returnDataA); + emit log_named_bytes(" Right call revert data", returnDataB); + fail(); + } + } +} diff --git a/docs/crypto/zkCTF/day1/Ethereal/mint-contracts/lib/forge-std/src/StdChains.sol b/docs/crypto/zkCTF/day1/Ethereal/mint-contracts/lib/forge-std/src/StdChains.sol new file mode 100644 index 0000000..bdc1c56 --- /dev/null +++ b/docs/crypto/zkCTF/day1/Ethereal/mint-contracts/lib/forge-std/src/StdChains.sol @@ -0,0 +1,248 @@ +// SPDX-License-Identifier: MIT +pragma solidity >=0.6.2 <0.9.0; + +import {VmSafe} from "./Vm.sol"; + +/** + * StdChains provides information about EVM compatible chains that can be used in scripts/tests. + * For each chain, the chain's name, chain ID, and a default RPC URL are provided. Chains are + * identified by their alias, which is the same as the alias in the `[rpc_endpoints]` section of + * the `foundry.toml` file. For best UX, ensure the alias in the `foundry.toml` file match the + * alias used in this contract, which can be found as the first argument to the + * `setChainWithDefaultRpcUrl` call in the `initializeStdChains` function. + * + * There are two main ways to use this contract: + * 1. Set a chain with `setChain(string memory chainAlias, ChainData memory chain)` or + * `setChain(string memory chainAlias, Chain memory chain)` + * 2. Get a chain with `getChain(string memory chainAlias)` or `getChain(uint256 chainId)`. + * + * The first time either of those are used, chains are initialized with the default set of RPC URLs. + * This is done in `initializeStdChains`, which uses `setChainWithDefaultRpcUrl`. Defaults are recorded in + * `defaultRpcUrls`. + * + * The `setChain` function is straightforward, and it simply saves off the given chain data. + * + * The `getChain` methods use `getChainWithUpdatedRpcUrl` to return a chain. For example, let's say + * we want to retrieve the RPC URL for `mainnet`: + * - If you have specified data with `setChain`, it will return that. + * - If you have configured a mainnet RPC URL in `foundry.toml`, it will return the URL, provided it + * is valid (e.g. a URL is specified, or an environment variable is given and exists). + * - If neither of the above conditions is met, the default data is returned. + * + * Summarizing the above, the prioritization hierarchy is `setChain` -> `foundry.toml` -> environment variable -> defaults. + */ +abstract contract StdChains { + VmSafe private constant vm = VmSafe(address(uint160(uint256(keccak256("hevm cheat code"))))); + + bool private stdChainsInitialized; + + struct ChainData { + string name; + uint256 chainId; + string rpcUrl; + } + + struct Chain { + // The chain name. + string name; + // The chain's Chain ID. + uint256 chainId; + // The chain's alias. (i.e. what gets specified in `foundry.toml`). + string chainAlias; + // A default RPC endpoint for this chain. + // NOTE: This default RPC URL is included for convenience to facilitate quick tests and + // experimentation. Do not use this RPC URL for production test suites, CI, or other heavy + // usage as you will be throttled and this is a disservice to others who need this endpoint. + string rpcUrl; + } + + // Maps from the chain's alias (matching the alias in the `foundry.toml` file) to chain data. + mapping(string => Chain) private chains; + // Maps from the chain's alias to it's default RPC URL. + mapping(string => string) private defaultRpcUrls; + // Maps from a chain ID to it's alias. + mapping(uint256 => string) private idToAlias; + + bool private fallbackToDefaultRpcUrls = true; + + // The RPC URL will be fetched from config or defaultRpcUrls if possible. + function getChain(string memory chainAlias) internal virtual returns (Chain memory chain) { + require(bytes(chainAlias).length != 0, "StdChains getChain(string): Chain alias cannot be the empty string."); + + initializeStdChains(); + chain = chains[chainAlias]; + require( + chain.chainId != 0, + string(abi.encodePacked("StdChains getChain(string): Chain with alias \"", chainAlias, "\" not found.")) + ); + + chain = getChainWithUpdatedRpcUrl(chainAlias, chain); + } + + function getChain(uint256 chainId) internal virtual returns (Chain memory chain) { + require(chainId != 0, "StdChains getChain(uint256): Chain ID cannot be 0."); + initializeStdChains(); + string memory chainAlias = idToAlias[chainId]; + + chain = chains[chainAlias]; + + require( + chain.chainId != 0, + string(abi.encodePacked("StdChains getChain(uint256): Chain with ID ", vm.toString(chainId), " not found.")) + ); + + chain = getChainWithUpdatedRpcUrl(chainAlias, chain); + } + + // set chain info, with priority to argument's rpcUrl field. + function setChain(string memory chainAlias, ChainData memory chain) internal virtual { + require( + bytes(chainAlias).length != 0, + "StdChains setChain(string,ChainData): Chain alias cannot be the empty string." + ); + + require(chain.chainId != 0, "StdChains setChain(string,ChainData): Chain ID cannot be 0."); + + initializeStdChains(); + string memory foundAlias = idToAlias[chain.chainId]; + + require( + bytes(foundAlias).length == 0 || keccak256(bytes(foundAlias)) == keccak256(bytes(chainAlias)), + string( + abi.encodePacked( + "StdChains setChain(string,ChainData): Chain ID ", + vm.toString(chain.chainId), + " already used by \"", + foundAlias, + "\"." + ) + ) + ); + + uint256 oldChainId = chains[chainAlias].chainId; + delete idToAlias[oldChainId]; + + chains[chainAlias] = + Chain({name: chain.name, chainId: chain.chainId, chainAlias: chainAlias, rpcUrl: chain.rpcUrl}); + idToAlias[chain.chainId] = chainAlias; + } + + // set chain info, with priority to argument's rpcUrl field. + function setChain(string memory chainAlias, Chain memory chain) internal virtual { + setChain(chainAlias, ChainData({name: chain.name, chainId: chain.chainId, rpcUrl: chain.rpcUrl})); + } + + function _toUpper(string memory str) private pure returns (string memory) { + bytes memory strb = bytes(str); + bytes memory copy = new bytes(strb.length); + for (uint256 i = 0; i < strb.length; i++) { + bytes1 b = strb[i]; + if (b >= 0x61 && b <= 0x7A) { + copy[i] = bytes1(uint8(b) - 32); + } else { + copy[i] = b; + } + } + return string(copy); + } + + // lookup rpcUrl, in descending order of priority: + // current -> config (foundry.toml) -> environment variable -> default + function getChainWithUpdatedRpcUrl(string memory chainAlias, Chain memory chain) + private + view + returns (Chain memory) + { + if (bytes(chain.rpcUrl).length == 0) { + try vm.rpcUrl(chainAlias) returns (string memory configRpcUrl) { + chain.rpcUrl = configRpcUrl; + } catch (bytes memory err) { + string memory envName = string(abi.encodePacked(_toUpper(chainAlias), "_RPC_URL")); + if (fallbackToDefaultRpcUrls) { + chain.rpcUrl = vm.envOr(envName, defaultRpcUrls[chainAlias]); + } else { + chain.rpcUrl = vm.envString(envName); + } + // Distinguish 'not found' from 'cannot read' + // The upstream error thrown by forge for failing cheats changed so we check both the old and new versions + bytes memory oldNotFoundError = + abi.encodeWithSignature("CheatCodeError", string(abi.encodePacked("invalid rpc url ", chainAlias))); + bytes memory newNotFoundError = abi.encodeWithSignature( + "CheatcodeError(string)", string(abi.encodePacked("invalid rpc url: ", chainAlias)) + ); + bytes32 errHash = keccak256(err); + if ( + (errHash != keccak256(oldNotFoundError) && errHash != keccak256(newNotFoundError)) + || bytes(chain.rpcUrl).length == 0 + ) { + /// @solidity memory-safe-assembly + assembly { + revert(add(32, err), mload(err)) + } + } + } + } + return chain; + } + + function setFallbackToDefaultRpcUrls(bool useDefault) internal { + fallbackToDefaultRpcUrls = useDefault; + } + + function initializeStdChains() private { + if (stdChainsInitialized) return; + + stdChainsInitialized = true; + + // If adding an RPC here, make sure to test the default RPC URL in `testRpcs` + setChainWithDefaultRpcUrl("anvil", ChainData("Anvil", 31337, "http://127.0.0.1:8545")); + setChainWithDefaultRpcUrl( + "mainnet", ChainData("Mainnet", 1, "https://mainnet.infura.io/v3/b9794ad1ddf84dfb8c34d6bb5dca2001") + ); + setChainWithDefaultRpcUrl( + "goerli", ChainData("Goerli", 5, "https://goerli.infura.io/v3/b9794ad1ddf84dfb8c34d6bb5dca2001") + ); + setChainWithDefaultRpcUrl( + "sepolia", ChainData("Sepolia", 11155111, "https://sepolia.infura.io/v3/b9794ad1ddf84dfb8c34d6bb5dca2001") + ); + setChainWithDefaultRpcUrl("optimism", ChainData("Optimism", 10, "https://mainnet.optimism.io")); + setChainWithDefaultRpcUrl("optimism_goerli", ChainData("Optimism Goerli", 420, "https://goerli.optimism.io")); + setChainWithDefaultRpcUrl("arbitrum_one", ChainData("Arbitrum One", 42161, "https://arb1.arbitrum.io/rpc")); + setChainWithDefaultRpcUrl( + "arbitrum_one_goerli", ChainData("Arbitrum One Goerli", 421613, "https://goerli-rollup.arbitrum.io/rpc") + ); + setChainWithDefaultRpcUrl("arbitrum_nova", ChainData("Arbitrum Nova", 42170, "https://nova.arbitrum.io/rpc")); + setChainWithDefaultRpcUrl("polygon", ChainData("Polygon", 137, "https://polygon-rpc.com")); + setChainWithDefaultRpcUrl( + "polygon_mumbai", ChainData("Polygon Mumbai", 80001, "https://rpc-mumbai.maticvigil.com") + ); + setChainWithDefaultRpcUrl("avalanche", ChainData("Avalanche", 43114, "https://api.avax.network/ext/bc/C/rpc")); + setChainWithDefaultRpcUrl( + "avalanche_fuji", ChainData("Avalanche Fuji", 43113, "https://api.avax-test.network/ext/bc/C/rpc") + ); + setChainWithDefaultRpcUrl( + "bnb_smart_chain", ChainData("BNB Smart Chain", 56, "https://bsc-dataseed1.binance.org") + ); + setChainWithDefaultRpcUrl( + "bnb_smart_chain_testnet", + ChainData("BNB Smart Chain Testnet", 97, "https://rpc.ankr.com/bsc_testnet_chapel") + ); + setChainWithDefaultRpcUrl("gnosis_chain", ChainData("Gnosis Chain", 100, "https://rpc.gnosischain.com")); + setChainWithDefaultRpcUrl("moonbeam", ChainData("Moonbeam", 1284, "https://rpc.api.moonbeam.network")); + setChainWithDefaultRpcUrl( + "moonriver", ChainData("Moonriver", 1285, "https://rpc.api.moonriver.moonbeam.network") + ); + setChainWithDefaultRpcUrl("moonbase", ChainData("Moonbase", 1287, "https://rpc.testnet.moonbeam.network")); + setChainWithDefaultRpcUrl("base_goerli", ChainData("Base Goerli", 84531, "https://goerli.base.org")); + setChainWithDefaultRpcUrl("base", ChainData("Base", 8453, "https://mainnet.base.org")); + } + + // set chain info, with priority to chainAlias' rpc url in foundry.toml + function setChainWithDefaultRpcUrl(string memory chainAlias, ChainData memory chain) private { + string memory rpcUrl = chain.rpcUrl; + defaultRpcUrls[chainAlias] = rpcUrl; + chain.rpcUrl = ""; + setChain(chainAlias, chain); + chain.rpcUrl = rpcUrl; // restore argument + } +} diff --git a/docs/crypto/zkCTF/day1/Ethereal/mint-contracts/lib/forge-std/src/StdCheats.sol b/docs/crypto/zkCTF/day1/Ethereal/mint-contracts/lib/forge-std/src/StdCheats.sol new file mode 100644 index 0000000..f293313 --- /dev/null +++ b/docs/crypto/zkCTF/day1/Ethereal/mint-contracts/lib/forge-std/src/StdCheats.sol @@ -0,0 +1,817 @@ +// SPDX-License-Identifier: MIT +pragma solidity >=0.6.2 <0.9.0; + +pragma experimental ABIEncoderV2; + +import {StdStorage, stdStorage} from "./StdStorage.sol"; +import {console2} from "./console2.sol"; +import {Vm} from "./Vm.sol"; + +abstract contract StdCheatsSafe { + Vm private constant vm = Vm(address(uint160(uint256(keccak256("hevm cheat code"))))); + + uint256 private constant UINT256_MAX = + 115792089237316195423570985008687907853269984665640564039457584007913129639935; + + bool private gasMeteringOff; + + // Data structures to parse Transaction objects from the broadcast artifact + // that conform to EIP1559. The Raw structs is what is parsed from the JSON + // and then converted to the one that is used by the user for better UX. + + struct RawTx1559 { + string[] arguments; + address contractAddress; + string contractName; + // json value name = function + string functionSig; + bytes32 hash; + // json value name = tx + RawTx1559Detail txDetail; + // json value name = type + string opcode; + } + + struct RawTx1559Detail { + AccessList[] accessList; + bytes data; + address from; + bytes gas; + bytes nonce; + address to; + bytes txType; + bytes value; + } + + struct Tx1559 { + string[] arguments; + address contractAddress; + string contractName; + string functionSig; + bytes32 hash; + Tx1559Detail txDetail; + string opcode; + } + + struct Tx1559Detail { + AccessList[] accessList; + bytes data; + address from; + uint256 gas; + uint256 nonce; + address to; + uint256 txType; + uint256 value; + } + + // Data structures to parse Transaction objects from the broadcast artifact + // that DO NOT conform to EIP1559. The Raw structs is what is parsed from the JSON + // and then converted to the one that is used by the user for better UX. + + struct TxLegacy { + string[] arguments; + address contractAddress; + string contractName; + string functionSig; + string hash; + string opcode; + TxDetailLegacy transaction; + } + + struct TxDetailLegacy { + AccessList[] accessList; + uint256 chainId; + bytes data; + address from; + uint256 gas; + uint256 gasPrice; + bytes32 hash; + uint256 nonce; + bytes1 opcode; + bytes32 r; + bytes32 s; + uint256 txType; + address to; + uint8 v; + uint256 value; + } + + struct AccessList { + address accessAddress; + bytes32[] storageKeys; + } + + // Data structures to parse Receipt objects from the broadcast artifact. + // The Raw structs is what is parsed from the JSON + // and then converted to the one that is used by the user for better UX. + + struct RawReceipt { + bytes32 blockHash; + bytes blockNumber; + address contractAddress; + bytes cumulativeGasUsed; + bytes effectiveGasPrice; + address from; + bytes gasUsed; + RawReceiptLog[] logs; + bytes logsBloom; + bytes status; + address to; + bytes32 transactionHash; + bytes transactionIndex; + } + + struct Receipt { + bytes32 blockHash; + uint256 blockNumber; + address contractAddress; + uint256 cumulativeGasUsed; + uint256 effectiveGasPrice; + address from; + uint256 gasUsed; + ReceiptLog[] logs; + bytes logsBloom; + uint256 status; + address to; + bytes32 transactionHash; + uint256 transactionIndex; + } + + // Data structures to parse the entire broadcast artifact, assuming the + // transactions conform to EIP1559. + + struct EIP1559ScriptArtifact { + string[] libraries; + string path; + string[] pending; + Receipt[] receipts; + uint256 timestamp; + Tx1559[] transactions; + TxReturn[] txReturns; + } + + struct RawEIP1559ScriptArtifact { + string[] libraries; + string path; + string[] pending; + RawReceipt[] receipts; + TxReturn[] txReturns; + uint256 timestamp; + RawTx1559[] transactions; + } + + struct RawReceiptLog { + // json value = address + address logAddress; + bytes32 blockHash; + bytes blockNumber; + bytes data; + bytes logIndex; + bool removed; + bytes32[] topics; + bytes32 transactionHash; + bytes transactionIndex; + bytes transactionLogIndex; + } + + struct ReceiptLog { + // json value = address + address logAddress; + bytes32 blockHash; + uint256 blockNumber; + bytes data; + uint256 logIndex; + bytes32[] topics; + uint256 transactionIndex; + uint256 transactionLogIndex; + bool removed; + } + + struct TxReturn { + string internalType; + string value; + } + + struct Account { + address addr; + uint256 key; + } + + enum AddressType { + Payable, + NonPayable, + ZeroAddress, + Precompile, + ForgeAddress + } + + // Checks that `addr` is not blacklisted by token contracts that have a blacklist. + function assumeNotBlacklisted(address token, address addr) internal view virtual { + // Nothing to check if `token` is not a contract. + uint256 tokenCodeSize; + assembly { + tokenCodeSize := extcodesize(token) + } + require(tokenCodeSize > 0, "StdCheats assumeNotBlacklisted(address,address): Token address is not a contract."); + + bool success; + bytes memory returnData; + + // 4-byte selector for `isBlacklisted(address)`, used by USDC. + (success, returnData) = token.staticcall(abi.encodeWithSelector(0xfe575a87, addr)); + vm.assume(!success || abi.decode(returnData, (bool)) == false); + + // 4-byte selector for `isBlackListed(address)`, used by USDT. + (success, returnData) = token.staticcall(abi.encodeWithSelector(0xe47d6060, addr)); + vm.assume(!success || abi.decode(returnData, (bool)) == false); + } + + // Checks that `addr` is not blacklisted by token contracts that have a blacklist. + // This is identical to `assumeNotBlacklisted(address,address)` but with a different name, for + // backwards compatibility, since this name was used in the original PR which has already has + // a release. This function can be removed in a future release once we want a breaking change. + function assumeNoBlacklisted(address token, address addr) internal view virtual { + assumeNotBlacklisted(token, addr); + } + + function assumeAddressIsNot(address addr, AddressType addressType) internal virtual { + if (addressType == AddressType.Payable) { + assumeNotPayable(addr); + } else if (addressType == AddressType.NonPayable) { + assumePayable(addr); + } else if (addressType == AddressType.ZeroAddress) { + assumeNotZeroAddress(addr); + } else if (addressType == AddressType.Precompile) { + assumeNotPrecompile(addr); + } else if (addressType == AddressType.ForgeAddress) { + assumeNotForgeAddress(addr); + } + } + + function assumeAddressIsNot(address addr, AddressType addressType1, AddressType addressType2) internal virtual { + assumeAddressIsNot(addr, addressType1); + assumeAddressIsNot(addr, addressType2); + } + + function assumeAddressIsNot( + address addr, + AddressType addressType1, + AddressType addressType2, + AddressType addressType3 + ) internal virtual { + assumeAddressIsNot(addr, addressType1); + assumeAddressIsNot(addr, addressType2); + assumeAddressIsNot(addr, addressType3); + } + + function assumeAddressIsNot( + address addr, + AddressType addressType1, + AddressType addressType2, + AddressType addressType3, + AddressType addressType4 + ) internal virtual { + assumeAddressIsNot(addr, addressType1); + assumeAddressIsNot(addr, addressType2); + assumeAddressIsNot(addr, addressType3); + assumeAddressIsNot(addr, addressType4); + } + + // This function checks whether an address, `addr`, is payable. It works by sending 1 wei to + // `addr` and checking the `success` return value. + // NOTE: This function may result in state changes depending on the fallback/receive logic + // implemented by `addr`, which should be taken into account when this function is used. + function _isPayable(address addr) private returns (bool) { + require( + addr.balance < UINT256_MAX, + "StdCheats _isPayable(address): Balance equals max uint256, so it cannot receive any more funds" + ); + uint256 origBalanceTest = address(this).balance; + uint256 origBalanceAddr = address(addr).balance; + + vm.deal(address(this), 1); + (bool success,) = payable(addr).call{value: 1}(""); + + // reset balances + vm.deal(address(this), origBalanceTest); + vm.deal(addr, origBalanceAddr); + + return success; + } + + // NOTE: This function may result in state changes depending on the fallback/receive logic + // implemented by `addr`, which should be taken into account when this function is used. See the + // `_isPayable` method for more information. + function assumePayable(address addr) internal virtual { + vm.assume(_isPayable(addr)); + } + + function assumeNotPayable(address addr) internal virtual { + vm.assume(!_isPayable(addr)); + } + + function assumeNotZeroAddress(address addr) internal pure virtual { + vm.assume(addr != address(0)); + } + + function assumeNotPrecompile(address addr) internal pure virtual { + assumeNotPrecompile(addr, _pureChainId()); + } + + function assumeNotPrecompile(address addr, uint256 chainId) internal pure virtual { + // Note: For some chains like Optimism these are technically predeploys (i.e. bytecode placed at a specific + // address), but the same rationale for excluding them applies so we include those too. + + // These should be present on all EVM-compatible chains. + vm.assume(addr < address(0x1) || addr > address(0x9)); + + // forgefmt: disable-start + if (chainId == 10 || chainId == 420) { + // https://github.com/ethereum-optimism/optimism/blob/eaa371a0184b56b7ca6d9eb9cb0a2b78b2ccd864/op-bindings/predeploys/addresses.go#L6-L21 + vm.assume(addr < address(0x4200000000000000000000000000000000000000) || addr > address(0x4200000000000000000000000000000000000800)); + } else if (chainId == 42161 || chainId == 421613) { + // https://developer.arbitrum.io/useful-addresses#arbitrum-precompiles-l2-same-on-all-arb-chains + vm.assume(addr < address(0x0000000000000000000000000000000000000064) || addr > address(0x0000000000000000000000000000000000000068)); + } else if (chainId == 43114 || chainId == 43113) { + // https://github.com/ava-labs/subnet-evm/blob/47c03fd007ecaa6de2c52ea081596e0a88401f58/precompile/params.go#L18-L59 + vm.assume(addr < address(0x0100000000000000000000000000000000000000) || addr > address(0x01000000000000000000000000000000000000ff)); + vm.assume(addr < address(0x0200000000000000000000000000000000000000) || addr > address(0x02000000000000000000000000000000000000FF)); + vm.assume(addr < address(0x0300000000000000000000000000000000000000) || addr > address(0x03000000000000000000000000000000000000Ff)); + } + // forgefmt: disable-end + } + + function assumeNotForgeAddress(address addr) internal pure virtual { + // vm, console, and Create2Deployer addresses + vm.assume( + addr != address(vm) && addr != 0x000000000000000000636F6e736F6c652e6c6f67 + && addr != 0x4e59b44847b379578588920cA78FbF26c0B4956C + ); + } + + function readEIP1559ScriptArtifact(string memory path) + internal + view + virtual + returns (EIP1559ScriptArtifact memory) + { + string memory data = vm.readFile(path); + bytes memory parsedData = vm.parseJson(data); + RawEIP1559ScriptArtifact memory rawArtifact = abi.decode(parsedData, (RawEIP1559ScriptArtifact)); + EIP1559ScriptArtifact memory artifact; + artifact.libraries = rawArtifact.libraries; + artifact.path = rawArtifact.path; + artifact.timestamp = rawArtifact.timestamp; + artifact.pending = rawArtifact.pending; + artifact.txReturns = rawArtifact.txReturns; + artifact.receipts = rawToConvertedReceipts(rawArtifact.receipts); + artifact.transactions = rawToConvertedEIPTx1559s(rawArtifact.transactions); + return artifact; + } + + function rawToConvertedEIPTx1559s(RawTx1559[] memory rawTxs) internal pure virtual returns (Tx1559[] memory) { + Tx1559[] memory txs = new Tx1559[](rawTxs.length); + for (uint256 i; i < rawTxs.length; i++) { + txs[i] = rawToConvertedEIPTx1559(rawTxs[i]); + } + return txs; + } + + function rawToConvertedEIPTx1559(RawTx1559 memory rawTx) internal pure virtual returns (Tx1559 memory) { + Tx1559 memory transaction; + transaction.arguments = rawTx.arguments; + transaction.contractName = rawTx.contractName; + transaction.functionSig = rawTx.functionSig; + transaction.hash = rawTx.hash; + transaction.txDetail = rawToConvertedEIP1559Detail(rawTx.txDetail); + transaction.opcode = rawTx.opcode; + return transaction; + } + + function rawToConvertedEIP1559Detail(RawTx1559Detail memory rawDetail) + internal + pure + virtual + returns (Tx1559Detail memory) + { + Tx1559Detail memory txDetail; + txDetail.data = rawDetail.data; + txDetail.from = rawDetail.from; + txDetail.to = rawDetail.to; + txDetail.nonce = _bytesToUint(rawDetail.nonce); + txDetail.txType = _bytesToUint(rawDetail.txType); + txDetail.value = _bytesToUint(rawDetail.value); + txDetail.gas = _bytesToUint(rawDetail.gas); + txDetail.accessList = rawDetail.accessList; + return txDetail; + } + + function readTx1559s(string memory path) internal view virtual returns (Tx1559[] memory) { + string memory deployData = vm.readFile(path); + bytes memory parsedDeployData = vm.parseJson(deployData, ".transactions"); + RawTx1559[] memory rawTxs = abi.decode(parsedDeployData, (RawTx1559[])); + return rawToConvertedEIPTx1559s(rawTxs); + } + + function readTx1559(string memory path, uint256 index) internal view virtual returns (Tx1559 memory) { + string memory deployData = vm.readFile(path); + string memory key = string(abi.encodePacked(".transactions[", vm.toString(index), "]")); + bytes memory parsedDeployData = vm.parseJson(deployData, key); + RawTx1559 memory rawTx = abi.decode(parsedDeployData, (RawTx1559)); + return rawToConvertedEIPTx1559(rawTx); + } + + // Analogous to readTransactions, but for receipts. + function readReceipts(string memory path) internal view virtual returns (Receipt[] memory) { + string memory deployData = vm.readFile(path); + bytes memory parsedDeployData = vm.parseJson(deployData, ".receipts"); + RawReceipt[] memory rawReceipts = abi.decode(parsedDeployData, (RawReceipt[])); + return rawToConvertedReceipts(rawReceipts); + } + + function readReceipt(string memory path, uint256 index) internal view virtual returns (Receipt memory) { + string memory deployData = vm.readFile(path); + string memory key = string(abi.encodePacked(".receipts[", vm.toString(index), "]")); + bytes memory parsedDeployData = vm.parseJson(deployData, key); + RawReceipt memory rawReceipt = abi.decode(parsedDeployData, (RawReceipt)); + return rawToConvertedReceipt(rawReceipt); + } + + function rawToConvertedReceipts(RawReceipt[] memory rawReceipts) internal pure virtual returns (Receipt[] memory) { + Receipt[] memory receipts = new Receipt[](rawReceipts.length); + for (uint256 i; i < rawReceipts.length; i++) { + receipts[i] = rawToConvertedReceipt(rawReceipts[i]); + } + return receipts; + } + + function rawToConvertedReceipt(RawReceipt memory rawReceipt) internal pure virtual returns (Receipt memory) { + Receipt memory receipt; + receipt.blockHash = rawReceipt.blockHash; + receipt.to = rawReceipt.to; + receipt.from = rawReceipt.from; + receipt.contractAddress = rawReceipt.contractAddress; + receipt.effectiveGasPrice = _bytesToUint(rawReceipt.effectiveGasPrice); + receipt.cumulativeGasUsed = _bytesToUint(rawReceipt.cumulativeGasUsed); + receipt.gasUsed = _bytesToUint(rawReceipt.gasUsed); + receipt.status = _bytesToUint(rawReceipt.status); + receipt.transactionIndex = _bytesToUint(rawReceipt.transactionIndex); + receipt.blockNumber = _bytesToUint(rawReceipt.blockNumber); + receipt.logs = rawToConvertedReceiptLogs(rawReceipt.logs); + receipt.logsBloom = rawReceipt.logsBloom; + receipt.transactionHash = rawReceipt.transactionHash; + return receipt; + } + + function rawToConvertedReceiptLogs(RawReceiptLog[] memory rawLogs) + internal + pure + virtual + returns (ReceiptLog[] memory) + { + ReceiptLog[] memory logs = new ReceiptLog[](rawLogs.length); + for (uint256 i; i < rawLogs.length; i++) { + logs[i].logAddress = rawLogs[i].logAddress; + logs[i].blockHash = rawLogs[i].blockHash; + logs[i].blockNumber = _bytesToUint(rawLogs[i].blockNumber); + logs[i].data = rawLogs[i].data; + logs[i].logIndex = _bytesToUint(rawLogs[i].logIndex); + logs[i].topics = rawLogs[i].topics; + logs[i].transactionIndex = _bytesToUint(rawLogs[i].transactionIndex); + logs[i].transactionLogIndex = _bytesToUint(rawLogs[i].transactionLogIndex); + logs[i].removed = rawLogs[i].removed; + } + return logs; + } + + // Deploy a contract by fetching the contract bytecode from + // the artifacts directory + // e.g. `deployCode(code, abi.encode(arg1,arg2,arg3))` + function deployCode(string memory what, bytes memory args) internal virtual returns (address addr) { + bytes memory bytecode = abi.encodePacked(vm.getCode(what), args); + /// @solidity memory-safe-assembly + assembly { + addr := create(0, add(bytecode, 0x20), mload(bytecode)) + } + + require(addr != address(0), "StdCheats deployCode(string,bytes): Deployment failed."); + } + + function deployCode(string memory what) internal virtual returns (address addr) { + bytes memory bytecode = vm.getCode(what); + /// @solidity memory-safe-assembly + assembly { + addr := create(0, add(bytecode, 0x20), mload(bytecode)) + } + + require(addr != address(0), "StdCheats deployCode(string): Deployment failed."); + } + + /// @dev deploy contract with value on construction + function deployCode(string memory what, bytes memory args, uint256 val) internal virtual returns (address addr) { + bytes memory bytecode = abi.encodePacked(vm.getCode(what), args); + /// @solidity memory-safe-assembly + assembly { + addr := create(val, add(bytecode, 0x20), mload(bytecode)) + } + + require(addr != address(0), "StdCheats deployCode(string,bytes,uint256): Deployment failed."); + } + + function deployCode(string memory what, uint256 val) internal virtual returns (address addr) { + bytes memory bytecode = vm.getCode(what); + /// @solidity memory-safe-assembly + assembly { + addr := create(val, add(bytecode, 0x20), mload(bytecode)) + } + + require(addr != address(0), "StdCheats deployCode(string,uint256): Deployment failed."); + } + + // creates a labeled address and the corresponding private key + function makeAddrAndKey(string memory name) internal virtual returns (address addr, uint256 privateKey) { + privateKey = uint256(keccak256(abi.encodePacked(name))); + addr = vm.addr(privateKey); + vm.label(addr, name); + } + + // creates a labeled address + function makeAddr(string memory name) internal virtual returns (address addr) { + (addr,) = makeAddrAndKey(name); + } + + // Destroys an account immediately, sending the balance to beneficiary. + // Destroying means: balance will be zero, code will be empty, and nonce will be 0 + // This is similar to selfdestruct but not identical: selfdestruct destroys code and nonce + // only after tx ends, this will run immediately. + function destroyAccount(address who, address beneficiary) internal virtual { + uint256 currBalance = who.balance; + vm.etch(who, abi.encode()); + vm.deal(who, 0); + vm.resetNonce(who); + + uint256 beneficiaryBalance = beneficiary.balance; + vm.deal(beneficiary, currBalance + beneficiaryBalance); + } + + // creates a struct containing both a labeled address and the corresponding private key + function makeAccount(string memory name) internal virtual returns (Account memory account) { + (account.addr, account.key) = makeAddrAndKey(name); + } + + function deriveRememberKey(string memory mnemonic, uint32 index) + internal + virtual + returns (address who, uint256 privateKey) + { + privateKey = vm.deriveKey(mnemonic, index); + who = vm.rememberKey(privateKey); + } + + function _bytesToUint(bytes memory b) private pure returns (uint256) { + require(b.length <= 32, "StdCheats _bytesToUint(bytes): Bytes length exceeds 32."); + return abi.decode(abi.encodePacked(new bytes(32 - b.length), b), (uint256)); + } + + function isFork() internal view virtual returns (bool status) { + try vm.activeFork() { + status = true; + } catch (bytes memory) {} + } + + modifier skipWhenForking() { + if (!isFork()) { + _; + } + } + + modifier skipWhenNotForking() { + if (isFork()) { + _; + } + } + + modifier noGasMetering() { + vm.pauseGasMetering(); + // To prevent turning gas monitoring back on with nested functions that use this modifier, + // we check if gasMetering started in the off position. If it did, we don't want to turn + // it back on until we exit the top level function that used the modifier + // + // i.e. funcA() noGasMetering { funcB() }, where funcB has noGasMetering as well. + // funcA will have `gasStartedOff` as false, funcB will have it as true, + // so we only turn metering back on at the end of the funcA + bool gasStartedOff = gasMeteringOff; + gasMeteringOff = true; + + _; + + // if gas metering was on when this modifier was called, turn it back on at the end + if (!gasStartedOff) { + gasMeteringOff = false; + vm.resumeGasMetering(); + } + } + + // We use this complex approach of `_viewChainId` and `_pureChainId` to ensure there are no + // compiler warnings when accessing chain ID in any solidity version supported by forge-std. We + // can't simply access the chain ID in a normal view or pure function because the solc View Pure + // Checker changed `chainid` from pure to view in 0.8.0. + function _viewChainId() private view returns (uint256 chainId) { + // Assembly required since `block.chainid` was introduced in 0.8.0. + assembly { + chainId := chainid() + } + + address(this); // Silence warnings in older Solc versions. + } + + function _pureChainId() private pure returns (uint256 chainId) { + function() internal view returns (uint256) fnIn = _viewChainId; + function() internal pure returns (uint256) pureChainId; + assembly { + pureChainId := fnIn + } + chainId = pureChainId(); + } +} + +// Wrappers around cheatcodes to avoid footguns +abstract contract StdCheats is StdCheatsSafe { + using stdStorage for StdStorage; + + StdStorage private stdstore; + Vm private constant vm = Vm(address(uint160(uint256(keccak256("hevm cheat code"))))); + address private constant CONSOLE2_ADDRESS = 0x000000000000000000636F6e736F6c652e6c6f67; + + // Skip forward or rewind time by the specified number of seconds + function skip(uint256 time) internal virtual { + vm.warp(block.timestamp + time); + } + + function rewind(uint256 time) internal virtual { + vm.warp(block.timestamp - time); + } + + // Setup a prank from an address that has some ether + function hoax(address msgSender) internal virtual { + vm.deal(msgSender, 1 << 128); + vm.prank(msgSender); + } + + function hoax(address msgSender, uint256 give) internal virtual { + vm.deal(msgSender, give); + vm.prank(msgSender); + } + + function hoax(address msgSender, address origin) internal virtual { + vm.deal(msgSender, 1 << 128); + vm.prank(msgSender, origin); + } + + function hoax(address msgSender, address origin, uint256 give) internal virtual { + vm.deal(msgSender, give); + vm.prank(msgSender, origin); + } + + // Start perpetual prank from an address that has some ether + function startHoax(address msgSender) internal virtual { + vm.deal(msgSender, 1 << 128); + vm.startPrank(msgSender); + } + + function startHoax(address msgSender, uint256 give) internal virtual { + vm.deal(msgSender, give); + vm.startPrank(msgSender); + } + + // Start perpetual prank from an address that has some ether + // tx.origin is set to the origin parameter + function startHoax(address msgSender, address origin) internal virtual { + vm.deal(msgSender, 1 << 128); + vm.startPrank(msgSender, origin); + } + + function startHoax(address msgSender, address origin, uint256 give) internal virtual { + vm.deal(msgSender, give); + vm.startPrank(msgSender, origin); + } + + function changePrank(address msgSender) internal virtual { + console2_log_StdCheats("changePrank is deprecated. Please use vm.startPrank instead."); + vm.stopPrank(); + vm.startPrank(msgSender); + } + + function changePrank(address msgSender, address txOrigin) internal virtual { + vm.stopPrank(); + vm.startPrank(msgSender, txOrigin); + } + + // The same as Vm's `deal` + // Use the alternative signature for ERC20 tokens + function deal(address to, uint256 give) internal virtual { + vm.deal(to, give); + } + + // Set the balance of an account for any ERC20 token + // Use the alternative signature to update `totalSupply` + function deal(address token, address to, uint256 give) internal virtual { + deal(token, to, give, false); + } + + // Set the balance of an account for any ERC1155 token + // Use the alternative signature to update `totalSupply` + function dealERC1155(address token, address to, uint256 id, uint256 give) internal virtual { + dealERC1155(token, to, id, give, false); + } + + function deal(address token, address to, uint256 give, bool adjust) internal virtual { + // get current balance + (, bytes memory balData) = token.staticcall(abi.encodeWithSelector(0x70a08231, to)); + uint256 prevBal = abi.decode(balData, (uint256)); + + // update balance + stdstore.target(token).sig(0x70a08231).with_key(to).checked_write(give); + + // update total supply + if (adjust) { + (, bytes memory totSupData) = token.staticcall(abi.encodeWithSelector(0x18160ddd)); + uint256 totSup = abi.decode(totSupData, (uint256)); + if (give < prevBal) { + totSup -= (prevBal - give); + } else { + totSup += (give - prevBal); + } + stdstore.target(token).sig(0x18160ddd).checked_write(totSup); + } + } + + function dealERC1155(address token, address to, uint256 id, uint256 give, bool adjust) internal virtual { + // get current balance + (, bytes memory balData) = token.staticcall(abi.encodeWithSelector(0x00fdd58e, to, id)); + uint256 prevBal = abi.decode(balData, (uint256)); + + // update balance + stdstore.target(token).sig(0x00fdd58e).with_key(to).with_key(id).checked_write(give); + + // update total supply + if (adjust) { + (, bytes memory totSupData) = token.staticcall(abi.encodeWithSelector(0xbd85b039, id)); + require( + totSupData.length != 0, + "StdCheats deal(address,address,uint,uint,bool): target contract is not ERC1155Supply." + ); + uint256 totSup = abi.decode(totSupData, (uint256)); + if (give < prevBal) { + totSup -= (prevBal - give); + } else { + totSup += (give - prevBal); + } + stdstore.target(token).sig(0xbd85b039).with_key(id).checked_write(totSup); + } + } + + function dealERC721(address token, address to, uint256 id) internal virtual { + // check if token id is already minted and the actual owner. + (bool successMinted, bytes memory ownerData) = token.staticcall(abi.encodeWithSelector(0x6352211e, id)); + require(successMinted, "StdCheats deal(address,address,uint,bool): id not minted."); + + // get owner current balance + (, bytes memory fromBalData) = + token.staticcall(abi.encodeWithSelector(0x70a08231, abi.decode(ownerData, (address)))); + uint256 fromPrevBal = abi.decode(fromBalData, (uint256)); + + // get new user current balance + (, bytes memory toBalData) = token.staticcall(abi.encodeWithSelector(0x70a08231, to)); + uint256 toPrevBal = abi.decode(toBalData, (uint256)); + + // update balances + stdstore.target(token).sig(0x70a08231).with_key(abi.decode(ownerData, (address))).checked_write(--fromPrevBal); + stdstore.target(token).sig(0x70a08231).with_key(to).checked_write(++toPrevBal); + + // update owner + stdstore.target(token).sig(0x6352211e).with_key(id).checked_write(to); + } + + function deployCodeTo(string memory what, address where) internal virtual { + deployCodeTo(what, "", 0, where); + } + + function deployCodeTo(string memory what, bytes memory args, address where) internal virtual { + deployCodeTo(what, args, 0, where); + } + + function deployCodeTo(string memory what, bytes memory args, uint256 value, address where) internal virtual { + bytes memory creationCode = vm.getCode(what); + vm.etch(where, abi.encodePacked(creationCode, args)); + (bool success, bytes memory runtimeBytecode) = where.call{value: value}(""); + require(success, "StdCheats deployCodeTo(string,bytes,uint256,address): Failed to create runtime bytecode."); + vm.etch(where, runtimeBytecode); + } + + // Used to prevent the compilation of console, which shortens the compilation time when console is not used elsewhere. + function console2_log_StdCheats(string memory p0) private view { + (bool status,) = address(CONSOLE2_ADDRESS).staticcall(abi.encodeWithSignature("log(string)", p0)); + status; + } +} diff --git a/docs/crypto/zkCTF/day1/Ethereal/mint-contracts/lib/forge-std/src/StdError.sol b/docs/crypto/zkCTF/day1/Ethereal/mint-contracts/lib/forge-std/src/StdError.sol new file mode 100644 index 0000000..a302191 --- /dev/null +++ b/docs/crypto/zkCTF/day1/Ethereal/mint-contracts/lib/forge-std/src/StdError.sol @@ -0,0 +1,15 @@ +// SPDX-License-Identifier: MIT +// Panics work for versions >=0.8.0, but we lowered the pragma to make this compatible with Test +pragma solidity >=0.6.2 <0.9.0; + +library stdError { + bytes public constant assertionError = abi.encodeWithSignature("Panic(uint256)", 0x01); + bytes public constant arithmeticError = abi.encodeWithSignature("Panic(uint256)", 0x11); + bytes public constant divisionError = abi.encodeWithSignature("Panic(uint256)", 0x12); + bytes public constant enumConversionError = abi.encodeWithSignature("Panic(uint256)", 0x21); + bytes public constant encodeStorageError = abi.encodeWithSignature("Panic(uint256)", 0x22); + bytes public constant popError = abi.encodeWithSignature("Panic(uint256)", 0x31); + bytes public constant indexOOBError = abi.encodeWithSignature("Panic(uint256)", 0x32); + bytes public constant memOverflowError = abi.encodeWithSignature("Panic(uint256)", 0x41); + bytes public constant zeroVarError = abi.encodeWithSignature("Panic(uint256)", 0x51); +} diff --git a/docs/crypto/zkCTF/day1/Ethereal/mint-contracts/lib/forge-std/src/StdInvariant.sol b/docs/crypto/zkCTF/day1/Ethereal/mint-contracts/lib/forge-std/src/StdInvariant.sol new file mode 100644 index 0000000..bcd9ac0 --- /dev/null +++ b/docs/crypto/zkCTF/day1/Ethereal/mint-contracts/lib/forge-std/src/StdInvariant.sol @@ -0,0 +1,107 @@ +// SPDX-License-Identifier: MIT +pragma solidity >=0.6.2 <0.9.0; + +pragma experimental ABIEncoderV2; + +abstract contract StdInvariant { + struct FuzzSelector { + address addr; + bytes4[] selectors; + } + + struct FuzzInterface { + address addr; + string[] artifacts; + } + + address[] private _excludedContracts; + address[] private _excludedSenders; + address[] private _targetedContracts; + address[] private _targetedSenders; + + string[] private _excludedArtifacts; + string[] private _targetedArtifacts; + + FuzzSelector[] private _targetedArtifactSelectors; + FuzzSelector[] private _targetedSelectors; + + FuzzInterface[] private _targetedInterfaces; + + // Functions for users: + // These are intended to be called in tests. + + function excludeContract(address newExcludedContract_) internal { + _excludedContracts.push(newExcludedContract_); + } + + function excludeSender(address newExcludedSender_) internal { + _excludedSenders.push(newExcludedSender_); + } + + function excludeArtifact(string memory newExcludedArtifact_) internal { + _excludedArtifacts.push(newExcludedArtifact_); + } + + function targetArtifact(string memory newTargetedArtifact_) internal { + _targetedArtifacts.push(newTargetedArtifact_); + } + + function targetArtifactSelector(FuzzSelector memory newTargetedArtifactSelector_) internal { + _targetedArtifactSelectors.push(newTargetedArtifactSelector_); + } + + function targetContract(address newTargetedContract_) internal { + _targetedContracts.push(newTargetedContract_); + } + + function targetSelector(FuzzSelector memory newTargetedSelector_) internal { + _targetedSelectors.push(newTargetedSelector_); + } + + function targetSender(address newTargetedSender_) internal { + _targetedSenders.push(newTargetedSender_); + } + + function targetInterface(FuzzInterface memory newTargetedInterface_) internal { + _targetedInterfaces.push(newTargetedInterface_); + } + + // Functions for forge: + // These are called by forge to run invariant tests and don't need to be called in tests. + + function excludeArtifacts() public view returns (string[] memory excludedArtifacts_) { + excludedArtifacts_ = _excludedArtifacts; + } + + function excludeContracts() public view returns (address[] memory excludedContracts_) { + excludedContracts_ = _excludedContracts; + } + + function excludeSenders() public view returns (address[] memory excludedSenders_) { + excludedSenders_ = _excludedSenders; + } + + function targetArtifacts() public view returns (string[] memory targetedArtifacts_) { + targetedArtifacts_ = _targetedArtifacts; + } + + function targetArtifactSelectors() public view returns (FuzzSelector[] memory targetedArtifactSelectors_) { + targetedArtifactSelectors_ = _targetedArtifactSelectors; + } + + function targetContracts() public view returns (address[] memory targetedContracts_) { + targetedContracts_ = _targetedContracts; + } + + function targetSelectors() public view returns (FuzzSelector[] memory targetedSelectors_) { + targetedSelectors_ = _targetedSelectors; + } + + function targetSenders() public view returns (address[] memory targetedSenders_) { + targetedSenders_ = _targetedSenders; + } + + function targetInterfaces() public view returns (FuzzInterface[] memory targetedInterfaces_) { + targetedInterfaces_ = _targetedInterfaces; + } +} diff --git a/docs/crypto/zkCTF/day1/Ethereal/mint-contracts/lib/forge-std/src/StdJson.sol b/docs/crypto/zkCTF/day1/Ethereal/mint-contracts/lib/forge-std/src/StdJson.sol new file mode 100644 index 0000000..42d9bb7 --- /dev/null +++ b/docs/crypto/zkCTF/day1/Ethereal/mint-contracts/lib/forge-std/src/StdJson.sol @@ -0,0 +1,183 @@ +// SPDX-License-Identifier: MIT +pragma solidity >=0.6.0 <0.9.0; + +pragma experimental ABIEncoderV2; + +import {VmSafe} from "./Vm.sol"; + +// Helpers for parsing and writing JSON files +// To parse: +// ``` +// using stdJson for string; +// string memory json = vm.readFile("some_peth"); +// json.parseUint(""); +// ``` +// To write: +// ``` +// using stdJson for string; +// string memory json = "deploymentArtifact"; +// Contract contract = new Contract(); +// json.serialize("contractAddress", address(contract)); +// json = json.serialize("deploymentTimes", uint(1)); +// // store the stringified JSON to the 'json' variable we have been using as a key +// // as we won't need it any longer +// string memory json2 = "finalArtifact"; +// string memory final = json2.serialize("depArtifact", json); +// final.write(""); +// ``` + +library stdJson { + VmSafe private constant vm = VmSafe(address(uint160(uint256(keccak256("hevm cheat code"))))); + + function parseRaw(string memory json, string memory key) internal pure returns (bytes memory) { + return vm.parseJson(json, key); + } + + function readUint(string memory json, string memory key) internal pure returns (uint256) { + return vm.parseJsonUint(json, key); + } + + function readUintArray(string memory json, string memory key) internal pure returns (uint256[] memory) { + return vm.parseJsonUintArray(json, key); + } + + function readInt(string memory json, string memory key) internal pure returns (int256) { + return vm.parseJsonInt(json, key); + } + + function readIntArray(string memory json, string memory key) internal pure returns (int256[] memory) { + return vm.parseJsonIntArray(json, key); + } + + function readBytes32(string memory json, string memory key) internal pure returns (bytes32) { + return vm.parseJsonBytes32(json, key); + } + + function readBytes32Array(string memory json, string memory key) internal pure returns (bytes32[] memory) { + return vm.parseJsonBytes32Array(json, key); + } + + function readString(string memory json, string memory key) internal pure returns (string memory) { + return vm.parseJsonString(json, key); + } + + function readStringArray(string memory json, string memory key) internal pure returns (string[] memory) { + return vm.parseJsonStringArray(json, key); + } + + function readAddress(string memory json, string memory key) internal pure returns (address) { + return vm.parseJsonAddress(json, key); + } + + function readAddressArray(string memory json, string memory key) internal pure returns (address[] memory) { + return vm.parseJsonAddressArray(json, key); + } + + function readBool(string memory json, string memory key) internal pure returns (bool) { + return vm.parseJsonBool(json, key); + } + + function readBoolArray(string memory json, string memory key) internal pure returns (bool[] memory) { + return vm.parseJsonBoolArray(json, key); + } + + function readBytes(string memory json, string memory key) internal pure returns (bytes memory) { + return vm.parseJsonBytes(json, key); + } + + function readBytesArray(string memory json, string memory key) internal pure returns (bytes[] memory) { + return vm.parseJsonBytesArray(json, key); + } + + function serialize(string memory jsonKey, string memory rootObject) internal returns (string memory) { + return vm.serializeJson(jsonKey, rootObject); + } + + function serialize(string memory jsonKey, string memory key, bool value) internal returns (string memory) { + return vm.serializeBool(jsonKey, key, value); + } + + function serialize(string memory jsonKey, string memory key, bool[] memory value) + internal + returns (string memory) + { + return vm.serializeBool(jsonKey, key, value); + } + + function serialize(string memory jsonKey, string memory key, uint256 value) internal returns (string memory) { + return vm.serializeUint(jsonKey, key, value); + } + + function serialize(string memory jsonKey, string memory key, uint256[] memory value) + internal + returns (string memory) + { + return vm.serializeUint(jsonKey, key, value); + } + + function serialize(string memory jsonKey, string memory key, int256 value) internal returns (string memory) { + return vm.serializeInt(jsonKey, key, value); + } + + function serialize(string memory jsonKey, string memory key, int256[] memory value) + internal + returns (string memory) + { + return vm.serializeInt(jsonKey, key, value); + } + + function serialize(string memory jsonKey, string memory key, address value) internal returns (string memory) { + return vm.serializeAddress(jsonKey, key, value); + } + + function serialize(string memory jsonKey, string memory key, address[] memory value) + internal + returns (string memory) + { + return vm.serializeAddress(jsonKey, key, value); + } + + function serialize(string memory jsonKey, string memory key, bytes32 value) internal returns (string memory) { + return vm.serializeBytes32(jsonKey, key, value); + } + + function serialize(string memory jsonKey, string memory key, bytes32[] memory value) + internal + returns (string memory) + { + return vm.serializeBytes32(jsonKey, key, value); + } + + function serialize(string memory jsonKey, string memory key, bytes memory value) internal returns (string memory) { + return vm.serializeBytes(jsonKey, key, value); + } + + function serialize(string memory jsonKey, string memory key, bytes[] memory value) + internal + returns (string memory) + { + return vm.serializeBytes(jsonKey, key, value); + } + + function serialize(string memory jsonKey, string memory key, string memory value) + internal + returns (string memory) + { + return vm.serializeString(jsonKey, key, value); + } + + function serialize(string memory jsonKey, string memory key, string[] memory value) + internal + returns (string memory) + { + return vm.serializeString(jsonKey, key, value); + } + + function write(string memory jsonKey, string memory path) internal { + vm.writeJson(jsonKey, path); + } + + function write(string memory jsonKey, string memory path, string memory valueKey) internal { + vm.writeJson(jsonKey, path, valueKey); + } +} diff --git a/docs/crypto/zkCTF/day1/Ethereal/mint-contracts/lib/forge-std/src/StdMath.sol b/docs/crypto/zkCTF/day1/Ethereal/mint-contracts/lib/forge-std/src/StdMath.sol new file mode 100644 index 0000000..459523b --- /dev/null +++ b/docs/crypto/zkCTF/day1/Ethereal/mint-contracts/lib/forge-std/src/StdMath.sol @@ -0,0 +1,43 @@ +// SPDX-License-Identifier: MIT +pragma solidity >=0.6.2 <0.9.0; + +library stdMath { + int256 private constant INT256_MIN = -57896044618658097711785492504343953926634992332820282019728792003956564819968; + + function abs(int256 a) internal pure returns (uint256) { + // Required or it will fail when `a = type(int256).min` + if (a == INT256_MIN) { + return 57896044618658097711785492504343953926634992332820282019728792003956564819968; + } + + return uint256(a > 0 ? a : -a); + } + + function delta(uint256 a, uint256 b) internal pure returns (uint256) { + return a > b ? a - b : b - a; + } + + function delta(int256 a, int256 b) internal pure returns (uint256) { + // a and b are of the same sign + // this works thanks to two's complement, the left-most bit is the sign bit + if ((a ^ b) > -1) { + return delta(abs(a), abs(b)); + } + + // a and b are of opposite signs + return abs(a) + abs(b); + } + + function percentDelta(uint256 a, uint256 b) internal pure returns (uint256) { + uint256 absDelta = delta(a, b); + + return absDelta * 1e18 / b; + } + + function percentDelta(int256 a, int256 b) internal pure returns (uint256) { + uint256 absDelta = delta(a, b); + uint256 absB = abs(b); + + return absDelta * 1e18 / absB; + } +} diff --git a/docs/crypto/zkCTF/day1/Ethereal/mint-contracts/lib/forge-std/src/StdStorage.sol b/docs/crypto/zkCTF/day1/Ethereal/mint-contracts/lib/forge-std/src/StdStorage.sol new file mode 100644 index 0000000..e5ded70 --- /dev/null +++ b/docs/crypto/zkCTF/day1/Ethereal/mint-contracts/lib/forge-std/src/StdStorage.sol @@ -0,0 +1,378 @@ +// SPDX-License-Identifier: MIT +pragma solidity >=0.6.2 <0.9.0; + +import {Vm} from "./Vm.sol"; + +struct StdStorage { + mapping(address => mapping(bytes4 => mapping(bytes32 => uint256))) slots; + mapping(address => mapping(bytes4 => mapping(bytes32 => bool))) finds; + bytes32[] _keys; + bytes4 _sig; + uint256 _depth; + address _target; + bytes32 _set; +} + +library stdStorageSafe { + event SlotFound(address who, bytes4 fsig, bytes32 keysHash, uint256 slot); + event WARNING_UninitedSlot(address who, uint256 slot); + + Vm private constant vm = Vm(address(uint160(uint256(keccak256("hevm cheat code"))))); + + function sigs(string memory sigStr) internal pure returns (bytes4) { + return bytes4(keccak256(bytes(sigStr))); + } + + /// @notice find an arbitrary storage slot given a function sig, input data, address of the contract and a value to check against + // slot complexity: + // if flat, will be bytes32(uint256(uint)); + // if map, will be keccak256(abi.encode(key, uint(slot))); + // if deep map, will be keccak256(abi.encode(key1, keccak256(abi.encode(key0, uint(slot))))); + // if map struct, will be bytes32(uint256(keccak256(abi.encode(key1, keccak256(abi.encode(key0, uint(slot)))))) + structFieldDepth); + function find(StdStorage storage self) internal returns (uint256) { + address who = self._target; + bytes4 fsig = self._sig; + uint256 field_depth = self._depth; + bytes32[] memory ins = self._keys; + + // calldata to test against + if (self.finds[who][fsig][keccak256(abi.encodePacked(ins, field_depth))]) { + return self.slots[who][fsig][keccak256(abi.encodePacked(ins, field_depth))]; + } + bytes memory cald = abi.encodePacked(fsig, flatten(ins)); + vm.record(); + bytes32 fdat; + { + (, bytes memory rdat) = who.staticcall(cald); + fdat = bytesToBytes32(rdat, 32 * field_depth); + } + + (bytes32[] memory reads,) = vm.accesses(address(who)); + if (reads.length == 1) { + bytes32 curr = vm.load(who, reads[0]); + if (curr == bytes32(0)) { + emit WARNING_UninitedSlot(who, uint256(reads[0])); + } + if (fdat != curr) { + require( + false, + "stdStorage find(StdStorage): Packed slot. This would cause dangerous overwriting and currently isn't supported." + ); + } + emit SlotFound(who, fsig, keccak256(abi.encodePacked(ins, field_depth)), uint256(reads[0])); + self.slots[who][fsig][keccak256(abi.encodePacked(ins, field_depth))] = uint256(reads[0]); + self.finds[who][fsig][keccak256(abi.encodePacked(ins, field_depth))] = true; + } else if (reads.length > 1) { + for (uint256 i = 0; i < reads.length; i++) { + bytes32 prev = vm.load(who, reads[i]); + if (prev == bytes32(0)) { + emit WARNING_UninitedSlot(who, uint256(reads[i])); + } + if (prev != fdat) { + continue; + } + bytes32 new_val = ~prev; + // store + vm.store(who, reads[i], new_val); + bool success; + { + bytes memory rdat; + (success, rdat) = who.staticcall(cald); + fdat = bytesToBytes32(rdat, 32 * field_depth); + } + + if (success && fdat == new_val) { + // we found which of the slots is the actual one + emit SlotFound(who, fsig, keccak256(abi.encodePacked(ins, field_depth)), uint256(reads[i])); + self.slots[who][fsig][keccak256(abi.encodePacked(ins, field_depth))] = uint256(reads[i]); + self.finds[who][fsig][keccak256(abi.encodePacked(ins, field_depth))] = true; + vm.store(who, reads[i], prev); + break; + } + vm.store(who, reads[i], prev); + } + } else { + revert("stdStorage find(StdStorage): No storage use detected for target."); + } + + require( + self.finds[who][fsig][keccak256(abi.encodePacked(ins, field_depth))], + "stdStorage find(StdStorage): Slot(s) not found." + ); + + delete self._target; + delete self._sig; + delete self._keys; + delete self._depth; + + return self.slots[who][fsig][keccak256(abi.encodePacked(ins, field_depth))]; + } + + function target(StdStorage storage self, address _target) internal returns (StdStorage storage) { + self._target = _target; + return self; + } + + function sig(StdStorage storage self, bytes4 _sig) internal returns (StdStorage storage) { + self._sig = _sig; + return self; + } + + function sig(StdStorage storage self, string memory _sig) internal returns (StdStorage storage) { + self._sig = sigs(_sig); + return self; + } + + function with_key(StdStorage storage self, address who) internal returns (StdStorage storage) { + self._keys.push(bytes32(uint256(uint160(who)))); + return self; + } + + function with_key(StdStorage storage self, uint256 amt) internal returns (StdStorage storage) { + self._keys.push(bytes32(amt)); + return self; + } + + function with_key(StdStorage storage self, bytes32 key) internal returns (StdStorage storage) { + self._keys.push(key); + return self; + } + + function depth(StdStorage storage self, uint256 _depth) internal returns (StdStorage storage) { + self._depth = _depth; + return self; + } + + function read(StdStorage storage self) private returns (bytes memory) { + address t = self._target; + uint256 s = find(self); + return abi.encode(vm.load(t, bytes32(s))); + } + + function read_bytes32(StdStorage storage self) internal returns (bytes32) { + return abi.decode(read(self), (bytes32)); + } + + function read_bool(StdStorage storage self) internal returns (bool) { + int256 v = read_int(self); + if (v == 0) return false; + if (v == 1) return true; + revert("stdStorage read_bool(StdStorage): Cannot decode. Make sure you are reading a bool."); + } + + function read_address(StdStorage storage self) internal returns (address) { + return abi.decode(read(self), (address)); + } + + function read_uint(StdStorage storage self) internal returns (uint256) { + return abi.decode(read(self), (uint256)); + } + + function read_int(StdStorage storage self) internal returns (int256) { + return abi.decode(read(self), (int256)); + } + + function parent(StdStorage storage self) internal returns (uint256, bytes32) { + address who = self._target; + uint256 field_depth = self._depth; + vm.startMappingRecording(); + uint256 child = find(self) - field_depth; + (bool found, bytes32 key, bytes32 parent_slot) = vm.getMappingKeyAndParentOf(who, bytes32(child)); + if (!found) { + revert( + "stdStorage read_bool(StdStorage): Cannot find parent. Make sure you give a slot and startMappingRecording() has been called." + ); + } + return (uint256(parent_slot), key); + } + + function root(StdStorage storage self) internal returns (uint256) { + address who = self._target; + uint256 field_depth = self._depth; + vm.startMappingRecording(); + uint256 child = find(self) - field_depth; + bool found; + bytes32 root_slot; + bytes32 parent_slot; + (found,, parent_slot) = vm.getMappingKeyAndParentOf(who, bytes32(child)); + if (!found) { + revert( + "stdStorage read_bool(StdStorage): Cannot find parent. Make sure you give a slot and startMappingRecording() has been called." + ); + } + while (found) { + root_slot = parent_slot; + (found,, parent_slot) = vm.getMappingKeyAndParentOf(who, bytes32(root_slot)); + } + return uint256(root_slot); + } + + function bytesToBytes32(bytes memory b, uint256 offset) private pure returns (bytes32) { + bytes32 out; + + uint256 max = b.length > 32 ? 32 : b.length; + for (uint256 i = 0; i < max; i++) { + out |= bytes32(b[offset + i] & 0xFF) >> (i * 8); + } + return out; + } + + function flatten(bytes32[] memory b) private pure returns (bytes memory) { + bytes memory result = new bytes(b.length * 32); + for (uint256 i = 0; i < b.length; i++) { + bytes32 k = b[i]; + /// @solidity memory-safe-assembly + assembly { + mstore(add(result, add(32, mul(32, i))), k) + } + } + + return result; + } +} + +library stdStorage { + Vm private constant vm = Vm(address(uint160(uint256(keccak256("hevm cheat code"))))); + + function sigs(string memory sigStr) internal pure returns (bytes4) { + return stdStorageSafe.sigs(sigStr); + } + + function find(StdStorage storage self) internal returns (uint256) { + return stdStorageSafe.find(self); + } + + function target(StdStorage storage self, address _target) internal returns (StdStorage storage) { + return stdStorageSafe.target(self, _target); + } + + function sig(StdStorage storage self, bytes4 _sig) internal returns (StdStorage storage) { + return stdStorageSafe.sig(self, _sig); + } + + function sig(StdStorage storage self, string memory _sig) internal returns (StdStorage storage) { + return stdStorageSafe.sig(self, _sig); + } + + function with_key(StdStorage storage self, address who) internal returns (StdStorage storage) { + return stdStorageSafe.with_key(self, who); + } + + function with_key(StdStorage storage self, uint256 amt) internal returns (StdStorage storage) { + return stdStorageSafe.with_key(self, amt); + } + + function with_key(StdStorage storage self, bytes32 key) internal returns (StdStorage storage) { + return stdStorageSafe.with_key(self, key); + } + + function depth(StdStorage storage self, uint256 _depth) internal returns (StdStorage storage) { + return stdStorageSafe.depth(self, _depth); + } + + function checked_write(StdStorage storage self, address who) internal { + checked_write(self, bytes32(uint256(uint160(who)))); + } + + function checked_write(StdStorage storage self, uint256 amt) internal { + checked_write(self, bytes32(amt)); + } + + function checked_write_int(StdStorage storage self, int256 val) internal { + checked_write(self, bytes32(uint256(val))); + } + + function checked_write(StdStorage storage self, bool write) internal { + bytes32 t; + /// @solidity memory-safe-assembly + assembly { + t := write + } + checked_write(self, t); + } + + function checked_write(StdStorage storage self, bytes32 set) internal { + address who = self._target; + bytes4 fsig = self._sig; + uint256 field_depth = self._depth; + bytes32[] memory ins = self._keys; + + bytes memory cald = abi.encodePacked(fsig, flatten(ins)); + if (!self.finds[who][fsig][keccak256(abi.encodePacked(ins, field_depth))]) { + find(self); + } + bytes32 slot = bytes32(self.slots[who][fsig][keccak256(abi.encodePacked(ins, field_depth))]); + + bytes32 fdat; + { + (, bytes memory rdat) = who.staticcall(cald); + fdat = bytesToBytes32(rdat, 32 * field_depth); + } + bytes32 curr = vm.load(who, slot); + + if (fdat != curr) { + require( + false, + "stdStorage find(StdStorage): Packed slot. This would cause dangerous overwriting and currently isn't supported." + ); + } + vm.store(who, slot, set); + delete self._target; + delete self._sig; + delete self._keys; + delete self._depth; + } + + function read_bytes32(StdStorage storage self) internal returns (bytes32) { + return stdStorageSafe.read_bytes32(self); + } + + function read_bool(StdStorage storage self) internal returns (bool) { + return stdStorageSafe.read_bool(self); + } + + function read_address(StdStorage storage self) internal returns (address) { + return stdStorageSafe.read_address(self); + } + + function read_uint(StdStorage storage self) internal returns (uint256) { + return stdStorageSafe.read_uint(self); + } + + function read_int(StdStorage storage self) internal returns (int256) { + return stdStorageSafe.read_int(self); + } + + function parent(StdStorage storage self) internal returns (uint256, bytes32) { + return stdStorageSafe.parent(self); + } + + function root(StdStorage storage self) internal returns (uint256) { + return stdStorageSafe.root(self); + } + + // Private function so needs to be copied over + function bytesToBytes32(bytes memory b, uint256 offset) private pure returns (bytes32) { + bytes32 out; + + uint256 max = b.length > 32 ? 32 : b.length; + for (uint256 i = 0; i < max; i++) { + out |= bytes32(b[offset + i] & 0xFF) >> (i * 8); + } + return out; + } + + // Private function so needs to be copied over + function flatten(bytes32[] memory b) private pure returns (bytes memory) { + bytes memory result = new bytes(b.length * 32); + for (uint256 i = 0; i < b.length; i++) { + bytes32 k = b[i]; + /// @solidity memory-safe-assembly + assembly { + mstore(add(result, add(32, mul(32, i))), k) + } + } + + return result; + } +} diff --git a/docs/crypto/zkCTF/day1/Ethereal/mint-contracts/lib/forge-std/src/StdStyle.sol b/docs/crypto/zkCTF/day1/Ethereal/mint-contracts/lib/forge-std/src/StdStyle.sol new file mode 100644 index 0000000..d371e0c --- /dev/null +++ b/docs/crypto/zkCTF/day1/Ethereal/mint-contracts/lib/forge-std/src/StdStyle.sol @@ -0,0 +1,333 @@ +// SPDX-License-Identifier: MIT +pragma solidity >=0.4.22 <0.9.0; + +import {VmSafe} from "./Vm.sol"; + +library StdStyle { + VmSafe private constant vm = VmSafe(address(uint160(uint256(keccak256("hevm cheat code"))))); + + string constant RED = "\u001b[91m"; + string constant GREEN = "\u001b[92m"; + string constant YELLOW = "\u001b[93m"; + string constant BLUE = "\u001b[94m"; + string constant MAGENTA = "\u001b[95m"; + string constant CYAN = "\u001b[96m"; + string constant BOLD = "\u001b[1m"; + string constant DIM = "\u001b[2m"; + string constant ITALIC = "\u001b[3m"; + string constant UNDERLINE = "\u001b[4m"; + string constant INVERSE = "\u001b[7m"; + string constant RESET = "\u001b[0m"; + + function styleConcat(string memory style, string memory self) private pure returns (string memory) { + return string(abi.encodePacked(style, self, RESET)); + } + + function red(string memory self) internal pure returns (string memory) { + return styleConcat(RED, self); + } + + function red(uint256 self) internal pure returns (string memory) { + return red(vm.toString(self)); + } + + function red(int256 self) internal pure returns (string memory) { + return red(vm.toString(self)); + } + + function red(address self) internal pure returns (string memory) { + return red(vm.toString(self)); + } + + function red(bool self) internal pure returns (string memory) { + return red(vm.toString(self)); + } + + function redBytes(bytes memory self) internal pure returns (string memory) { + return red(vm.toString(self)); + } + + function redBytes32(bytes32 self) internal pure returns (string memory) { + return red(vm.toString(self)); + } + + function green(string memory self) internal pure returns (string memory) { + return styleConcat(GREEN, self); + } + + function green(uint256 self) internal pure returns (string memory) { + return green(vm.toString(self)); + } + + function green(int256 self) internal pure returns (string memory) { + return green(vm.toString(self)); + } + + function green(address self) internal pure returns (string memory) { + return green(vm.toString(self)); + } + + function green(bool self) internal pure returns (string memory) { + return green(vm.toString(self)); + } + + function greenBytes(bytes memory self) internal pure returns (string memory) { + return green(vm.toString(self)); + } + + function greenBytes32(bytes32 self) internal pure returns (string memory) { + return green(vm.toString(self)); + } + + function yellow(string memory self) internal pure returns (string memory) { + return styleConcat(YELLOW, self); + } + + function yellow(uint256 self) internal pure returns (string memory) { + return yellow(vm.toString(self)); + } + + function yellow(int256 self) internal pure returns (string memory) { + return yellow(vm.toString(self)); + } + + function yellow(address self) internal pure returns (string memory) { + return yellow(vm.toString(self)); + } + + function yellow(bool self) internal pure returns (string memory) { + return yellow(vm.toString(self)); + } + + function yellowBytes(bytes memory self) internal pure returns (string memory) { + return yellow(vm.toString(self)); + } + + function yellowBytes32(bytes32 self) internal pure returns (string memory) { + return yellow(vm.toString(self)); + } + + function blue(string memory self) internal pure returns (string memory) { + return styleConcat(BLUE, self); + } + + function blue(uint256 self) internal pure returns (string memory) { + return blue(vm.toString(self)); + } + + function blue(int256 self) internal pure returns (string memory) { + return blue(vm.toString(self)); + } + + function blue(address self) internal pure returns (string memory) { + return blue(vm.toString(self)); + } + + function blue(bool self) internal pure returns (string memory) { + return blue(vm.toString(self)); + } + + function blueBytes(bytes memory self) internal pure returns (string memory) { + return blue(vm.toString(self)); + } + + function blueBytes32(bytes32 self) internal pure returns (string memory) { + return blue(vm.toString(self)); + } + + function magenta(string memory self) internal pure returns (string memory) { + return styleConcat(MAGENTA, self); + } + + function magenta(uint256 self) internal pure returns (string memory) { + return magenta(vm.toString(self)); + } + + function magenta(int256 self) internal pure returns (string memory) { + return magenta(vm.toString(self)); + } + + function magenta(address self) internal pure returns (string memory) { + return magenta(vm.toString(self)); + } + + function magenta(bool self) internal pure returns (string memory) { + return magenta(vm.toString(self)); + } + + function magentaBytes(bytes memory self) internal pure returns (string memory) { + return magenta(vm.toString(self)); + } + + function magentaBytes32(bytes32 self) internal pure returns (string memory) { + return magenta(vm.toString(self)); + } + + function cyan(string memory self) internal pure returns (string memory) { + return styleConcat(CYAN, self); + } + + function cyan(uint256 self) internal pure returns (string memory) { + return cyan(vm.toString(self)); + } + + function cyan(int256 self) internal pure returns (string memory) { + return cyan(vm.toString(self)); + } + + function cyan(address self) internal pure returns (string memory) { + return cyan(vm.toString(self)); + } + + function cyan(bool self) internal pure returns (string memory) { + return cyan(vm.toString(self)); + } + + function cyanBytes(bytes memory self) internal pure returns (string memory) { + return cyan(vm.toString(self)); + } + + function cyanBytes32(bytes32 self) internal pure returns (string memory) { + return cyan(vm.toString(self)); + } + + function bold(string memory self) internal pure returns (string memory) { + return styleConcat(BOLD, self); + } + + function bold(uint256 self) internal pure returns (string memory) { + return bold(vm.toString(self)); + } + + function bold(int256 self) internal pure returns (string memory) { + return bold(vm.toString(self)); + } + + function bold(address self) internal pure returns (string memory) { + return bold(vm.toString(self)); + } + + function bold(bool self) internal pure returns (string memory) { + return bold(vm.toString(self)); + } + + function boldBytes(bytes memory self) internal pure returns (string memory) { + return bold(vm.toString(self)); + } + + function boldBytes32(bytes32 self) internal pure returns (string memory) { + return bold(vm.toString(self)); + } + + function dim(string memory self) internal pure returns (string memory) { + return styleConcat(DIM, self); + } + + function dim(uint256 self) internal pure returns (string memory) { + return dim(vm.toString(self)); + } + + function dim(int256 self) internal pure returns (string memory) { + return dim(vm.toString(self)); + } + + function dim(address self) internal pure returns (string memory) { + return dim(vm.toString(self)); + } + + function dim(bool self) internal pure returns (string memory) { + return dim(vm.toString(self)); + } + + function dimBytes(bytes memory self) internal pure returns (string memory) { + return dim(vm.toString(self)); + } + + function dimBytes32(bytes32 self) internal pure returns (string memory) { + return dim(vm.toString(self)); + } + + function italic(string memory self) internal pure returns (string memory) { + return styleConcat(ITALIC, self); + } + + function italic(uint256 self) internal pure returns (string memory) { + return italic(vm.toString(self)); + } + + function italic(int256 self) internal pure returns (string memory) { + return italic(vm.toString(self)); + } + + function italic(address self) internal pure returns (string memory) { + return italic(vm.toString(self)); + } + + function italic(bool self) internal pure returns (string memory) { + return italic(vm.toString(self)); + } + + function italicBytes(bytes memory self) internal pure returns (string memory) { + return italic(vm.toString(self)); + } + + function italicBytes32(bytes32 self) internal pure returns (string memory) { + return italic(vm.toString(self)); + } + + function underline(string memory self) internal pure returns (string memory) { + return styleConcat(UNDERLINE, self); + } + + function underline(uint256 self) internal pure returns (string memory) { + return underline(vm.toString(self)); + } + + function underline(int256 self) internal pure returns (string memory) { + return underline(vm.toString(self)); + } + + function underline(address self) internal pure returns (string memory) { + return underline(vm.toString(self)); + } + + function underline(bool self) internal pure returns (string memory) { + return underline(vm.toString(self)); + } + + function underlineBytes(bytes memory self) internal pure returns (string memory) { + return underline(vm.toString(self)); + } + + function underlineBytes32(bytes32 self) internal pure returns (string memory) { + return underline(vm.toString(self)); + } + + function inverse(string memory self) internal pure returns (string memory) { + return styleConcat(INVERSE, self); + } + + function inverse(uint256 self) internal pure returns (string memory) { + return inverse(vm.toString(self)); + } + + function inverse(int256 self) internal pure returns (string memory) { + return inverse(vm.toString(self)); + } + + function inverse(address self) internal pure returns (string memory) { + return inverse(vm.toString(self)); + } + + function inverse(bool self) internal pure returns (string memory) { + return inverse(vm.toString(self)); + } + + function inverseBytes(bytes memory self) internal pure returns (string memory) { + return inverse(vm.toString(self)); + } + + function inverseBytes32(bytes32 self) internal pure returns (string memory) { + return inverse(vm.toString(self)); + } +} diff --git a/docs/crypto/zkCTF/day1/Ethereal/mint-contracts/lib/forge-std/src/StdUtils.sol b/docs/crypto/zkCTF/day1/Ethereal/mint-contracts/lib/forge-std/src/StdUtils.sol new file mode 100644 index 0000000..0f61305 --- /dev/null +++ b/docs/crypto/zkCTF/day1/Ethereal/mint-contracts/lib/forge-std/src/StdUtils.sol @@ -0,0 +1,226 @@ +// SPDX-License-Identifier: MIT +pragma solidity >=0.6.2 <0.9.0; + +pragma experimental ABIEncoderV2; + +import {IMulticall3} from "./interfaces/IMulticall3.sol"; +import {MockERC20} from "./mocks/MockERC20.sol"; +import {MockERC721} from "./mocks/MockERC721.sol"; +import {VmSafe} from "./Vm.sol"; + +abstract contract StdUtils { + /*////////////////////////////////////////////////////////////////////////// + CONSTANTS + //////////////////////////////////////////////////////////////////////////*/ + + IMulticall3 private constant multicall = IMulticall3(0xcA11bde05977b3631167028862bE2a173976CA11); + VmSafe private constant vm = VmSafe(address(uint160(uint256(keccak256("hevm cheat code"))))); + address private constant CONSOLE2_ADDRESS = 0x000000000000000000636F6e736F6c652e6c6f67; + uint256 private constant INT256_MIN_ABS = + 57896044618658097711785492504343953926634992332820282019728792003956564819968; + uint256 private constant SECP256K1_ORDER = + 115792089237316195423570985008687907852837564279074904382605163141518161494337; + uint256 private constant UINT256_MAX = + 115792089237316195423570985008687907853269984665640564039457584007913129639935; + + // Used by default when deploying with create2, https://github.com/Arachnid/deterministic-deployment-proxy. + address private constant CREATE2_FACTORY = 0x4e59b44847b379578588920cA78FbF26c0B4956C; + + /*////////////////////////////////////////////////////////////////////////// + INTERNAL FUNCTIONS + //////////////////////////////////////////////////////////////////////////*/ + + function _bound(uint256 x, uint256 min, uint256 max) internal pure virtual returns (uint256 result) { + require(min <= max, "StdUtils bound(uint256,uint256,uint256): Max is less than min."); + // If x is between min and max, return x directly. This is to ensure that dictionary values + // do not get shifted if the min is nonzero. More info: https://github.com/foundry-rs/forge-std/issues/188 + if (x >= min && x <= max) return x; + + uint256 size = max - min + 1; + + // If the value is 0, 1, 2, 3, wrap that to min, min+1, min+2, min+3. Similarly for the UINT256_MAX side. + // This helps ensure coverage of the min/max values. + if (x <= 3 && size > x) return min + x; + if (x >= UINT256_MAX - 3 && size > UINT256_MAX - x) return max - (UINT256_MAX - x); + + // Otherwise, wrap x into the range [min, max], i.e. the range is inclusive. + if (x > max) { + uint256 diff = x - max; + uint256 rem = diff % size; + if (rem == 0) return max; + result = min + rem - 1; + } else if (x < min) { + uint256 diff = min - x; + uint256 rem = diff % size; + if (rem == 0) return min; + result = max - rem + 1; + } + } + + function bound(uint256 x, uint256 min, uint256 max) internal pure virtual returns (uint256 result) { + result = _bound(x, min, max); + console2_log_StdUtils("Bound Result", result); + } + + function _bound(int256 x, int256 min, int256 max) internal pure virtual returns (int256 result) { + require(min <= max, "StdUtils bound(int256,int256,int256): Max is less than min."); + + // Shifting all int256 values to uint256 to use _bound function. The range of two types are: + // int256 : -(2**255) ~ (2**255 - 1) + // uint256: 0 ~ (2**256 - 1) + // So, add 2**255, INT256_MIN_ABS to the integer values. + // + // If the given integer value is -2**255, we cannot use `-uint256(-x)` because of the overflow. + // So, use `~uint256(x) + 1` instead. + uint256 _x = x < 0 ? (INT256_MIN_ABS - ~uint256(x) - 1) : (uint256(x) + INT256_MIN_ABS); + uint256 _min = min < 0 ? (INT256_MIN_ABS - ~uint256(min) - 1) : (uint256(min) + INT256_MIN_ABS); + uint256 _max = max < 0 ? (INT256_MIN_ABS - ~uint256(max) - 1) : (uint256(max) + INT256_MIN_ABS); + + uint256 y = _bound(_x, _min, _max); + + // To move it back to int256 value, subtract INT256_MIN_ABS at here. + result = y < INT256_MIN_ABS ? int256(~(INT256_MIN_ABS - y) + 1) : int256(y - INT256_MIN_ABS); + } + + function bound(int256 x, int256 min, int256 max) internal pure virtual returns (int256 result) { + result = _bound(x, min, max); + console2_log_StdUtils("Bound result", vm.toString(result)); + } + + function boundPrivateKey(uint256 privateKey) internal pure virtual returns (uint256 result) { + result = _bound(privateKey, 1, SECP256K1_ORDER - 1); + } + + function bytesToUint(bytes memory b) internal pure virtual returns (uint256) { + require(b.length <= 32, "StdUtils bytesToUint(bytes): Bytes length exceeds 32."); + return abi.decode(abi.encodePacked(new bytes(32 - b.length), b), (uint256)); + } + + /// @dev Compute the address a contract will be deployed at for a given deployer address and nonce + /// @notice adapted from Solmate implementation (https://github.com/Rari-Capital/solmate/blob/main/src/utils/LibRLP.sol) + function computeCreateAddress(address deployer, uint256 nonce) internal pure virtual returns (address) { + console2_log_StdUtils("computeCreateAddress is deprecated. Please use vm.computeCreateAddress instead."); + return vm.computeCreateAddress(deployer, nonce); + } + + function computeCreate2Address(bytes32 salt, bytes32 initcodeHash, address deployer) + internal + pure + virtual + returns (address) + { + console2_log_StdUtils("computeCreate2Address is deprecated. Please use vm.computeCreate2Address instead."); + return vm.computeCreate2Address(salt, initcodeHash, deployer); + } + + /// @dev returns the address of a contract created with CREATE2 using the default CREATE2 deployer + function computeCreate2Address(bytes32 salt, bytes32 initCodeHash) internal pure returns (address) { + console2_log_StdUtils("computeCreate2Address is deprecated. Please use vm.computeCreate2Address instead."); + return vm.computeCreate2Address(salt, initCodeHash); + } + + /// @dev returns an initialized mock ERC20 contract + function deployMockERC20(string memory name, string memory symbol, uint8 decimals) + internal + returns (MockERC20 mock) + { + mock = new MockERC20(); + mock.initialize(name, symbol, decimals); + } + + /// @dev returns an initialized mock ERC721 contract + function deployMockERC721(string memory name, string memory symbol) internal returns (MockERC721 mock) { + mock = new MockERC721(); + mock.initialize(name, symbol); + } + + /// @dev returns the hash of the init code (creation code + no args) used in CREATE2 with no constructor arguments + /// @param creationCode the creation code of a contract C, as returned by type(C).creationCode + function hashInitCode(bytes memory creationCode) internal pure returns (bytes32) { + return hashInitCode(creationCode, ""); + } + + /// @dev returns the hash of the init code (creation code + ABI-encoded args) used in CREATE2 + /// @param creationCode the creation code of a contract C, as returned by type(C).creationCode + /// @param args the ABI-encoded arguments to the constructor of C + function hashInitCode(bytes memory creationCode, bytes memory args) internal pure returns (bytes32) { + return keccak256(abi.encodePacked(creationCode, args)); + } + + // Performs a single call with Multicall3 to query the ERC-20 token balances of the given addresses. + function getTokenBalances(address token, address[] memory addresses) + internal + virtual + returns (uint256[] memory balances) + { + uint256 tokenCodeSize; + assembly { + tokenCodeSize := extcodesize(token) + } + require(tokenCodeSize > 0, "StdUtils getTokenBalances(address,address[]): Token address is not a contract."); + + // ABI encode the aggregate call to Multicall3. + uint256 length = addresses.length; + IMulticall3.Call[] memory calls = new IMulticall3.Call[](length); + for (uint256 i = 0; i < length; ++i) { + // 0x70a08231 = bytes4("balanceOf(address)")) + calls[i] = IMulticall3.Call({target: token, callData: abi.encodeWithSelector(0x70a08231, (addresses[i]))}); + } + + // Make the aggregate call. + (, bytes[] memory returnData) = multicall.aggregate(calls); + + // ABI decode the return data and return the balances. + balances = new uint256[](length); + for (uint256 i = 0; i < length; ++i) { + balances[i] = abi.decode(returnData[i], (uint256)); + } + } + + /*////////////////////////////////////////////////////////////////////////// + PRIVATE FUNCTIONS + //////////////////////////////////////////////////////////////////////////*/ + + function addressFromLast20Bytes(bytes32 bytesValue) private pure returns (address) { + return address(uint160(uint256(bytesValue))); + } + + // This section is used to prevent the compilation of console, which shortens the compilation time when console is + // not used elsewhere. We also trick the compiler into letting us make the console log methods as `pure` to avoid + // any breaking changes to function signatures. + function _castLogPayloadViewToPure(function(bytes memory) internal view fnIn) + internal + pure + returns (function(bytes memory) internal pure fnOut) + { + assembly { + fnOut := fnIn + } + } + + function _sendLogPayload(bytes memory payload) internal pure { + _castLogPayloadViewToPure(_sendLogPayloadView)(payload); + } + + function _sendLogPayloadView(bytes memory payload) private view { + uint256 payloadLength = payload.length; + address consoleAddress = CONSOLE2_ADDRESS; + /// @solidity memory-safe-assembly + assembly { + let payloadStart := add(payload, 32) + let r := staticcall(gas(), consoleAddress, payloadStart, payloadLength, 0, 0) + } + } + + function console2_log_StdUtils(string memory p0) private pure { + _sendLogPayload(abi.encodeWithSignature("log(string)", p0)); + } + + function console2_log_StdUtils(string memory p0, uint256 p1) private pure { + _sendLogPayload(abi.encodeWithSignature("log(string,uint256)", p0, p1)); + } + + function console2_log_StdUtils(string memory p0, string memory p1) private pure { + _sendLogPayload(abi.encodeWithSignature("log(string,string)", p0, p1)); + } +} diff --git a/docs/crypto/zkCTF/day1/Ethereal/mint-contracts/lib/forge-std/src/Test.sol b/docs/crypto/zkCTF/day1/Ethereal/mint-contracts/lib/forge-std/src/Test.sol new file mode 100644 index 0000000..743c183 --- /dev/null +++ b/docs/crypto/zkCTF/day1/Ethereal/mint-contracts/lib/forge-std/src/Test.sol @@ -0,0 +1,33 @@ +// SPDX-License-Identifier: MIT +pragma solidity >=0.6.2 <0.9.0; + +pragma experimental ABIEncoderV2; + +// 💬 ABOUT +// Forge Std's default Test. + +// 🧩 MODULES +import {console} from "./console.sol"; +import {console2} from "./console2.sol"; +import {safeconsole} from "./safeconsole.sol"; +import {StdAssertions} from "./StdAssertions.sol"; +import {StdChains} from "./StdChains.sol"; +import {StdCheats} from "./StdCheats.sol"; +import {stdError} from "./StdError.sol"; +import {StdInvariant} from "./StdInvariant.sol"; +import {stdJson} from "./StdJson.sol"; +import {stdMath} from "./StdMath.sol"; +import {StdStorage, stdStorage} from "./StdStorage.sol"; +import {StdStyle} from "./StdStyle.sol"; +import {StdUtils} from "./StdUtils.sol"; +import {Vm} from "./Vm.sol"; + +// 📦 BOILERPLATE +import {TestBase} from "./Base.sol"; +import {DSTest} from "ds-test/test.sol"; + +// ⭐️ TEST +abstract contract Test is TestBase, DSTest, StdAssertions, StdChains, StdCheats, StdInvariant, StdUtils { +// Note: IS_TEST() must return true. +// Note: Must have failure system, https://github.com/dapphub/ds-test/blob/cd98eff28324bfac652e63a239a60632a761790b/src/test.sol#L39-L76. +} diff --git a/docs/crypto/zkCTF/day1/Ethereal/mint-contracts/lib/forge-std/src/Vm.sol b/docs/crypto/zkCTF/day1/Ethereal/mint-contracts/lib/forge-std/src/Vm.sol new file mode 100644 index 0000000..fffe0c6 --- /dev/null +++ b/docs/crypto/zkCTF/day1/Ethereal/mint-contracts/lib/forge-std/src/Vm.sol @@ -0,0 +1,1096 @@ +// Automatically @generated by scripts/vm.py. Do not modify manually. + +// SPDX-License-Identifier: MIT OR Apache-2.0 +pragma solidity >=0.6.2 <0.9.0; +pragma experimental ABIEncoderV2; + +/// The `VmSafe` interface does not allow manipulation of the EVM state or other actions that may +/// result in Script simulations differing from on-chain execution. It is recommended to only use +/// these cheats in scripts. +interface VmSafe { + /// A modification applied to either `msg.sender` or `tx.origin`. Returned by `readCallers`. + enum CallerMode { + // No caller modification is currently active. + None, + // A one time broadcast triggered by a `vm.broadcast()` call is currently active. + Broadcast, + // A recurrent broadcast triggered by a `vm.startBroadcast()` call is currently active. + RecurrentBroadcast, + // A one time prank triggered by a `vm.prank()` call is currently active. + Prank, + // A recurrent prank triggered by a `vm.startPrank()` call is currently active. + RecurrentPrank + } + + /// The kind of account access that occurred. + enum AccountAccessKind { + // The account was called. + Call, + // The account was called via delegatecall. + DelegateCall, + // The account was called via callcode. + CallCode, + // The account was called via staticcall. + StaticCall, + // The account was created. + Create, + // The account was selfdestructed. + SelfDestruct, + // Synthetic access indicating the current context has resumed after a previous sub-context (AccountAccess). + Resume, + // The account's balance was read. + Balance, + // The account's codesize was read. + Extcodesize, + // The account's codehash was read. + Extcodehash, + // The account's code was copied. + Extcodecopy + } + + /// An Ethereum log. Returned by `getRecordedLogs`. + struct Log { + // The topics of the log, including the signature, if any. + bytes32[] topics; + // The raw data of the log. + bytes data; + // The address of the log's emitter. + address emitter; + } + + /// An RPC URL and its alias. Returned by `rpcUrlStructs`. + struct Rpc { + // The alias of the RPC URL. + string key; + // The RPC URL. + string url; + } + + /// An RPC log object. Returned by `eth_getLogs`. + struct EthGetLogs { + // The address of the log's emitter. + address emitter; + // The topics of the log, including the signature, if any. + bytes32[] topics; + // The raw data of the log. + bytes data; + // The block hash. + bytes32 blockHash; + // The block number. + uint64 blockNumber; + // The transaction hash. + bytes32 transactionHash; + // The transaction index in the block. + uint64 transactionIndex; + // The log index. + uint256 logIndex; + // Whether the log was removed. + bool removed; + } + + /// A single entry in a directory listing. Returned by `readDir`. + struct DirEntry { + // The error message, if any. + string errorMessage; + // The path of the entry. + string path; + // The depth of the entry. + uint64 depth; + // Whether the entry is a directory. + bool isDir; + // Whether the entry is a symlink. + bool isSymlink; + } + + /// Metadata information about a file. + /// This structure is returned from the `fsMetadata` function and represents known + /// metadata about a file such as its permissions, size, modification + /// times, etc. + struct FsMetadata { + // True if this metadata is for a directory. + bool isDir; + // True if this metadata is for a symlink. + bool isSymlink; + // The size of the file, in bytes, this metadata is for. + uint256 length; + // True if this metadata is for a readonly (unwritable) file. + bool readOnly; + // The last modification time listed in this metadata. + uint256 modified; + // The last access time of this metadata. + uint256 accessed; + // The creation time listed in this metadata. + uint256 created; + } + + /// A wallet with a public and private key. + struct Wallet { + // The wallet's address. + address addr; + // The wallet's public key `X`. + uint256 publicKeyX; + // The wallet's public key `Y`. + uint256 publicKeyY; + // The wallet's private key. + uint256 privateKey; + } + + /// The result of a `tryFfi` call. + struct FfiResult { + // The exit code of the call. + int32 exitCode; + // The optionally hex-decoded `stdout` data. + bytes stdout; + // The `stderr` data. + bytes stderr; + } + + /// Information on the chain and fork. + struct ChainInfo { + // The fork identifier. Set to zero if no fork is active. + uint256 forkId; + // The chain ID of the current fork. + uint256 chainId; + } + + /// The result of a `stopAndReturnStateDiff` call. + struct AccountAccess { + // The chain and fork the access occurred. + ChainInfo chainInfo; + // The kind of account access that determines what the account is. + // If kind is Call, DelegateCall, StaticCall or CallCode, then the account is the callee. + // If kind is Create, then the account is the newly created account. + // If kind is SelfDestruct, then the account is the selfdestruct recipient. + // If kind is a Resume, then account represents a account context that has resumed. + AccountAccessKind kind; + // The account that was accessed. + // It's either the account created, callee or a selfdestruct recipient for CREATE, CALL or SELFDESTRUCT. + address account; + // What accessed the account. + address accessor; + // If the account was initialized or empty prior to the access. + // An account is considered initialized if it has code, a + // non-zero nonce, or a non-zero balance. + bool initialized; + // The previous balance of the accessed account. + uint256 oldBalance; + // The potential new balance of the accessed account. + // That is, all balance changes are recorded here, even if reverts occurred. + uint256 newBalance; + // Code of the account deployed by CREATE. + bytes deployedCode; + // Value passed along with the account access + uint256 value; + // Input data provided to the CREATE or CALL + bytes data; + // If this access reverted in either the current or parent context. + bool reverted; + // An ordered list of storage accesses made during an account access operation. + StorageAccess[] storageAccesses; + } + + /// The storage accessed during an `AccountAccess`. + struct StorageAccess { + // The account whose storage was accessed. + address account; + // The slot that was accessed. + bytes32 slot; + // If the access was a write. + bool isWrite; + // The previous value of the slot. + bytes32 previousValue; + // The new value of the slot. + bytes32 newValue; + // If the access was reverted. + bool reverted; + } + + // ======== Environment ======== + + /// Gets the environment variable `name` and parses it as `address`. + /// Reverts if the variable was not found or could not be parsed. + function envAddress(string calldata name) external view returns (address value); + + /// Gets the environment variable `name` and parses it as an array of `address`, delimited by `delim`. + /// Reverts if the variable was not found or could not be parsed. + function envAddress(string calldata name, string calldata delim) external view returns (address[] memory value); + + /// Gets the environment variable `name` and parses it as `bool`. + /// Reverts if the variable was not found or could not be parsed. + function envBool(string calldata name) external view returns (bool value); + + /// Gets the environment variable `name` and parses it as an array of `bool`, delimited by `delim`. + /// Reverts if the variable was not found or could not be parsed. + function envBool(string calldata name, string calldata delim) external view returns (bool[] memory value); + + /// Gets the environment variable `name` and parses it as `bytes32`. + /// Reverts if the variable was not found or could not be parsed. + function envBytes32(string calldata name) external view returns (bytes32 value); + + /// Gets the environment variable `name` and parses it as an array of `bytes32`, delimited by `delim`. + /// Reverts if the variable was not found or could not be parsed. + function envBytes32(string calldata name, string calldata delim) external view returns (bytes32[] memory value); + + /// Gets the environment variable `name` and parses it as `bytes`. + /// Reverts if the variable was not found or could not be parsed. + function envBytes(string calldata name) external view returns (bytes memory value); + + /// Gets the environment variable `name` and parses it as an array of `bytes`, delimited by `delim`. + /// Reverts if the variable was not found or could not be parsed. + function envBytes(string calldata name, string calldata delim) external view returns (bytes[] memory value); + + /// Gets the environment variable `name` and parses it as `int256`. + /// Reverts if the variable was not found or could not be parsed. + function envInt(string calldata name) external view returns (int256 value); + + /// Gets the environment variable `name` and parses it as an array of `int256`, delimited by `delim`. + /// Reverts if the variable was not found or could not be parsed. + function envInt(string calldata name, string calldata delim) external view returns (int256[] memory value); + + /// Gets the environment variable `name` and parses it as `bool`. + /// Reverts if the variable could not be parsed. + /// Returns `defaultValue` if the variable was not found. + function envOr(string calldata name, bool defaultValue) external view returns (bool value); + + /// Gets the environment variable `name` and parses it as `uint256`. + /// Reverts if the variable could not be parsed. + /// Returns `defaultValue` if the variable was not found. + function envOr(string calldata name, uint256 defaultValue) external view returns (uint256 value); + + /// Gets the environment variable `name` and parses it as an array of `address`, delimited by `delim`. + /// Reverts if the variable could not be parsed. + /// Returns `defaultValue` if the variable was not found. + function envOr(string calldata name, string calldata delim, address[] calldata defaultValue) + external + view + returns (address[] memory value); + + /// Gets the environment variable `name` and parses it as an array of `bytes32`, delimited by `delim`. + /// Reverts if the variable could not be parsed. + /// Returns `defaultValue` if the variable was not found. + function envOr(string calldata name, string calldata delim, bytes32[] calldata defaultValue) + external + view + returns (bytes32[] memory value); + + /// Gets the environment variable `name` and parses it as an array of `string`, delimited by `delim`. + /// Reverts if the variable could not be parsed. + /// Returns `defaultValue` if the variable was not found. + function envOr(string calldata name, string calldata delim, string[] calldata defaultValue) + external + view + returns (string[] memory value); + + /// Gets the environment variable `name` and parses it as an array of `bytes`, delimited by `delim`. + /// Reverts if the variable could not be parsed. + /// Returns `defaultValue` if the variable was not found. + function envOr(string calldata name, string calldata delim, bytes[] calldata defaultValue) + external + view + returns (bytes[] memory value); + + /// Gets the environment variable `name` and parses it as `int256`. + /// Reverts if the variable could not be parsed. + /// Returns `defaultValue` if the variable was not found. + function envOr(string calldata name, int256 defaultValue) external view returns (int256 value); + + /// Gets the environment variable `name` and parses it as `address`. + /// Reverts if the variable could not be parsed. + /// Returns `defaultValue` if the variable was not found. + function envOr(string calldata name, address defaultValue) external view returns (address value); + + /// Gets the environment variable `name` and parses it as `bytes32`. + /// Reverts if the variable could not be parsed. + /// Returns `defaultValue` if the variable was not found. + function envOr(string calldata name, bytes32 defaultValue) external view returns (bytes32 value); + + /// Gets the environment variable `name` and parses it as `string`. + /// Reverts if the variable could not be parsed. + /// Returns `defaultValue` if the variable was not found. + function envOr(string calldata name, string calldata defaultValue) external view returns (string memory value); + + /// Gets the environment variable `name` and parses it as `bytes`. + /// Reverts if the variable could not be parsed. + /// Returns `defaultValue` if the variable was not found. + function envOr(string calldata name, bytes calldata defaultValue) external view returns (bytes memory value); + + /// Gets the environment variable `name` and parses it as an array of `bool`, delimited by `delim`. + /// Reverts if the variable could not be parsed. + /// Returns `defaultValue` if the variable was not found. + function envOr(string calldata name, string calldata delim, bool[] calldata defaultValue) + external + view + returns (bool[] memory value); + + /// Gets the environment variable `name` and parses it as an array of `uint256`, delimited by `delim`. + /// Reverts if the variable could not be parsed. + /// Returns `defaultValue` if the variable was not found. + function envOr(string calldata name, string calldata delim, uint256[] calldata defaultValue) + external + view + returns (uint256[] memory value); + + /// Gets the environment variable `name` and parses it as an array of `int256`, delimited by `delim`. + /// Reverts if the variable could not be parsed. + /// Returns `defaultValue` if the variable was not found. + function envOr(string calldata name, string calldata delim, int256[] calldata defaultValue) + external + view + returns (int256[] memory value); + + /// Gets the environment variable `name` and parses it as `string`. + /// Reverts if the variable was not found or could not be parsed. + function envString(string calldata name) external view returns (string memory value); + + /// Gets the environment variable `name` and parses it as an array of `string`, delimited by `delim`. + /// Reverts if the variable was not found or could not be parsed. + function envString(string calldata name, string calldata delim) external view returns (string[] memory value); + + /// Gets the environment variable `name` and parses it as `uint256`. + /// Reverts if the variable was not found or could not be parsed. + function envUint(string calldata name) external view returns (uint256 value); + + /// Gets the environment variable `name` and parses it as an array of `uint256`, delimited by `delim`. + /// Reverts if the variable was not found or could not be parsed. + function envUint(string calldata name, string calldata delim) external view returns (uint256[] memory value); + + /// Sets environment variables. + function setEnv(string calldata name, string calldata value) external; + + // ======== EVM ======== + + /// Gets all accessed reads and write slot from a `vm.record` session, for a given address. + function accesses(address target) external returns (bytes32[] memory readSlots, bytes32[] memory writeSlots); + + /// Gets the address for a given private key. + function addr(uint256 privateKey) external pure returns (address keyAddr); + + /// Gets all the logs according to specified filter. + function eth_getLogs(uint256 fromBlock, uint256 toBlock, address target, bytes32[] calldata topics) + external + returns (EthGetLogs[] memory logs); + + /// Gets the current `block.number`. + /// You should use this instead of `block.number` if you use `vm.roll`, as `block.number` is assumed to be constant across a transaction, + /// and as a result will get optimized out by the compiler. + /// See https://github.com/foundry-rs/foundry/issues/6180 + function getBlockNumber() external view returns (uint256 height); + + /// Gets the current `block.timestamp`. + /// You should use this instead of `block.timestamp` if you use `vm.warp`, as `block.timestamp` is assumed to be constant across a transaction, + /// and as a result will get optimized out by the compiler. + /// See https://github.com/foundry-rs/foundry/issues/6180 + function getBlockTimestamp() external view returns (uint256 timestamp); + + /// Gets the map key and parent of a mapping at a given slot, for a given address. + function getMappingKeyAndParentOf(address target, bytes32 elementSlot) + external + returns (bool found, bytes32 key, bytes32 parent); + + /// Gets the number of elements in the mapping at the given slot, for a given address. + function getMappingLength(address target, bytes32 mappingSlot) external returns (uint256 length); + + /// Gets the elements at index idx of the mapping at the given slot, for a given address. The + /// index must be less than the length of the mapping (i.e. the number of keys in the mapping). + function getMappingSlotAt(address target, bytes32 mappingSlot, uint256 idx) external returns (bytes32 value); + + /// Gets the nonce of an account. + function getNonce(address account) external view returns (uint64 nonce); + + /// Gets all the recorded logs. + function getRecordedLogs() external returns (Log[] memory logs); + + /// Loads a storage slot from an address. + function load(address target, bytes32 slot) external view returns (bytes32 data); + + /// Pauses gas metering (i.e. gas usage is not counted). Noop if already paused. + function pauseGasMetering() external; + + /// Records all storage reads and writes. + function record() external; + + /// Record all the transaction logs. + function recordLogs() external; + + /// Resumes gas metering (i.e. gas usage is counted again). Noop if already on. + function resumeGasMetering() external; + + /// Performs an Ethereum JSON-RPC request to the current fork URL. + function rpc(string calldata method, string calldata params) external returns (bytes memory data); + + /// Signs data. + function sign(uint256 privateKey, bytes32 digest) external pure returns (uint8 v, bytes32 r, bytes32 s); + + /// Starts recording all map SSTOREs for later retrieval. + function startMappingRecording() external; + + /// Record all account accesses as part of CREATE, CALL or SELFDESTRUCT opcodes in order, + /// along with the context of the calls + function startStateDiffRecording() external; + + /// Returns an ordered array of all account accesses from a `vm.startStateDiffRecording` session. + function stopAndReturnStateDiff() external returns (AccountAccess[] memory accountAccesses); + + /// Stops recording all map SSTOREs for later retrieval and clears the recorded data. + function stopMappingRecording() external; + + // ======== Filesystem ======== + + /// Closes file for reading, resetting the offset and allowing to read it from beginning with readLine. + /// `path` is relative to the project root. + function closeFile(string calldata path) external; + + /// Copies the contents of one file to another. This function will **overwrite** the contents of `to`. + /// On success, the total number of bytes copied is returned and it is equal to the length of the `to` file as reported by `metadata`. + /// Both `from` and `to` are relative to the project root. + function copyFile(string calldata from, string calldata to) external returns (uint64 copied); + + /// Creates a new, empty directory at the provided path. + /// This cheatcode will revert in the following situations, but is not limited to just these cases: + /// - User lacks permissions to modify `path`. + /// - A parent of the given path doesn't exist and `recursive` is false. + /// - `path` already exists and `recursive` is false. + /// `path` is relative to the project root. + function createDir(string calldata path, bool recursive) external; + + /// Returns true if the given path points to an existing entity, else returns false. + function exists(string calldata path) external returns (bool result); + + /// Performs a foreign function call via the terminal. + function ffi(string[] calldata commandInput) external returns (bytes memory result); + + /// Given a path, query the file system to get information about a file, directory, etc. + function fsMetadata(string calldata path) external view returns (FsMetadata memory metadata); + + /// Gets the creation bytecode from an artifact file. Takes in the relative path to the json file. + function getCode(string calldata artifactPath) external view returns (bytes memory creationBytecode); + + /// Gets the deployed bytecode from an artifact file. Takes in the relative path to the json file. + function getDeployedCode(string calldata artifactPath) external view returns (bytes memory runtimeBytecode); + + /// Returns true if the path exists on disk and is pointing at a directory, else returns false. + function isDir(string calldata path) external returns (bool result); + + /// Returns true if the path exists on disk and is pointing at a regular file, else returns false. + function isFile(string calldata path) external returns (bool result); + + /// Get the path of the current project root. + function projectRoot() external view returns (string memory path); + + /// Reads the directory at the given path recursively, up to `maxDepth`. + /// `maxDepth` defaults to 1, meaning only the direct children of the given directory will be returned. + /// Follows symbolic links if `followLinks` is true. + function readDir(string calldata path) external view returns (DirEntry[] memory entries); + + /// See `readDir(string)`. + function readDir(string calldata path, uint64 maxDepth) external view returns (DirEntry[] memory entries); + + /// See `readDir(string)`. + function readDir(string calldata path, uint64 maxDepth, bool followLinks) + external + view + returns (DirEntry[] memory entries); + + /// Reads the entire content of file to string. `path` is relative to the project root. + function readFile(string calldata path) external view returns (string memory data); + + /// Reads the entire content of file as binary. `path` is relative to the project root. + function readFileBinary(string calldata path) external view returns (bytes memory data); + + /// Reads next line of file to string. + function readLine(string calldata path) external view returns (string memory line); + + /// Reads a symbolic link, returning the path that the link points to. + /// This cheatcode will revert in the following situations, but is not limited to just these cases: + /// - `path` is not a symbolic link. + /// - `path` does not exist. + function readLink(string calldata linkPath) external view returns (string memory targetPath); + + /// Removes a directory at the provided path. + /// This cheatcode will revert in the following situations, but is not limited to just these cases: + /// - `path` doesn't exist. + /// - `path` isn't a directory. + /// - User lacks permissions to modify `path`. + /// - The directory is not empty and `recursive` is false. + /// `path` is relative to the project root. + function removeDir(string calldata path, bool recursive) external; + + /// Removes a file from the filesystem. + /// This cheatcode will revert in the following situations, but is not limited to just these cases: + /// - `path` points to a directory. + /// - The file doesn't exist. + /// - The user lacks permissions to remove the file. + /// `path` is relative to the project root. + function removeFile(string calldata path) external; + + /// Performs a foreign function call via terminal and returns the exit code, stdout, and stderr. + function tryFfi(string[] calldata commandInput) external returns (FfiResult memory result); + + /// Returns the time since unix epoch in milliseconds. + function unixTime() external returns (uint256 milliseconds); + + /// Writes data to file, creating a file if it does not exist, and entirely replacing its contents if it does. + /// `path` is relative to the project root. + function writeFile(string calldata path, string calldata data) external; + + /// Writes binary data to a file, creating a file if it does not exist, and entirely replacing its contents if it does. + /// `path` is relative to the project root. + function writeFileBinary(string calldata path, bytes calldata data) external; + + /// Writes line to file, creating a file if it does not exist. + /// `path` is relative to the project root. + function writeLine(string calldata path, string calldata data) external; + + // ======== JSON ======== + + /// Checks if `key` exists in a JSON object. + function keyExists(string calldata json, string calldata key) external view returns (bool); + + /// Parses a string of JSON data at `key` and coerces it to `address`. + function parseJsonAddress(string calldata json, string calldata key) external pure returns (address); + + /// Parses a string of JSON data at `key` and coerces it to `address[]`. + function parseJsonAddressArray(string calldata json, string calldata key) + external + pure + returns (address[] memory); + + /// Parses a string of JSON data at `key` and coerces it to `bool`. + function parseJsonBool(string calldata json, string calldata key) external pure returns (bool); + + /// Parses a string of JSON data at `key` and coerces it to `bool[]`. + function parseJsonBoolArray(string calldata json, string calldata key) external pure returns (bool[] memory); + + /// Parses a string of JSON data at `key` and coerces it to `bytes`. + function parseJsonBytes(string calldata json, string calldata key) external pure returns (bytes memory); + + /// Parses a string of JSON data at `key` and coerces it to `bytes32`. + function parseJsonBytes32(string calldata json, string calldata key) external pure returns (bytes32); + + /// Parses a string of JSON data at `key` and coerces it to `bytes32[]`. + function parseJsonBytes32Array(string calldata json, string calldata key) + external + pure + returns (bytes32[] memory); + + /// Parses a string of JSON data at `key` and coerces it to `bytes[]`. + function parseJsonBytesArray(string calldata json, string calldata key) external pure returns (bytes[] memory); + + /// Parses a string of JSON data at `key` and coerces it to `int256`. + function parseJsonInt(string calldata json, string calldata key) external pure returns (int256); + + /// Parses a string of JSON data at `key` and coerces it to `int256[]`. + function parseJsonIntArray(string calldata json, string calldata key) external pure returns (int256[] memory); + + /// Returns an array of all the keys in a JSON object. + function parseJsonKeys(string calldata json, string calldata key) external pure returns (string[] memory keys); + + /// Parses a string of JSON data at `key` and coerces it to `string`. + function parseJsonString(string calldata json, string calldata key) external pure returns (string memory); + + /// Parses a string of JSON data at `key` and coerces it to `string[]`. + function parseJsonStringArray(string calldata json, string calldata key) external pure returns (string[] memory); + + /// Parses a string of JSON data at `key` and coerces it to `uint256`. + function parseJsonUint(string calldata json, string calldata key) external pure returns (uint256); + + /// Parses a string of JSON data at `key` and coerces it to `uint256[]`. + function parseJsonUintArray(string calldata json, string calldata key) external pure returns (uint256[] memory); + + /// ABI-encodes a JSON object. + function parseJson(string calldata json) external pure returns (bytes memory abiEncodedData); + + /// ABI-encodes a JSON object at `key`. + function parseJson(string calldata json, string calldata key) external pure returns (bytes memory abiEncodedData); + + /// See `serializeJson`. + function serializeAddress(string calldata objectKey, string calldata valueKey, address value) + external + returns (string memory json); + + /// See `serializeJson`. + function serializeAddress(string calldata objectKey, string calldata valueKey, address[] calldata values) + external + returns (string memory json); + + /// See `serializeJson`. + function serializeBool(string calldata objectKey, string calldata valueKey, bool value) + external + returns (string memory json); + + /// See `serializeJson`. + function serializeBool(string calldata objectKey, string calldata valueKey, bool[] calldata values) + external + returns (string memory json); + + /// See `serializeJson`. + function serializeBytes32(string calldata objectKey, string calldata valueKey, bytes32 value) + external + returns (string memory json); + + /// See `serializeJson`. + function serializeBytes32(string calldata objectKey, string calldata valueKey, bytes32[] calldata values) + external + returns (string memory json); + + /// See `serializeJson`. + function serializeBytes(string calldata objectKey, string calldata valueKey, bytes calldata value) + external + returns (string memory json); + + /// See `serializeJson`. + function serializeBytes(string calldata objectKey, string calldata valueKey, bytes[] calldata values) + external + returns (string memory json); + + /// See `serializeJson`. + function serializeInt(string calldata objectKey, string calldata valueKey, int256 value) + external + returns (string memory json); + + /// See `serializeJson`. + function serializeInt(string calldata objectKey, string calldata valueKey, int256[] calldata values) + external + returns (string memory json); + + /// Serializes a key and value to a JSON object stored in-memory that can be later written to a file. + /// Returns the stringified version of the specific JSON file up to that moment. + function serializeJson(string calldata objectKey, string calldata value) external returns (string memory json); + + /// See `serializeJson`. + function serializeString(string calldata objectKey, string calldata valueKey, string calldata value) + external + returns (string memory json); + + /// See `serializeJson`. + function serializeString(string calldata objectKey, string calldata valueKey, string[] calldata values) + external + returns (string memory json); + + /// See `serializeJson`. + function serializeUint(string calldata objectKey, string calldata valueKey, uint256 value) + external + returns (string memory json); + + /// See `serializeJson`. + function serializeUint(string calldata objectKey, string calldata valueKey, uint256[] calldata values) + external + returns (string memory json); + + /// Write a serialized JSON object to a file. If the file exists, it will be overwritten. + function writeJson(string calldata json, string calldata path) external; + + /// Write a serialized JSON object to an **existing** JSON file, replacing a value with key = + /// This is useful to replace a specific value of a JSON file, without having to parse the entire thing. + function writeJson(string calldata json, string calldata path, string calldata valueKey) external; + + // ======== Scripting ======== + + /// Using the address that calls the test contract, has the next call (at this call depth only) + /// create a transaction that can later be signed and sent onchain. + function broadcast() external; + + /// Has the next call (at this call depth only) create a transaction with the address provided + /// as the sender that can later be signed and sent onchain. + function broadcast(address signer) external; + + /// Has the next call (at this call depth only) create a transaction with the private key + /// provided as the sender that can later be signed and sent onchain. + function broadcast(uint256 privateKey) external; + + /// Using the address that calls the test contract, has all subsequent calls + /// (at this call depth only) create transactions that can later be signed and sent onchain. + function startBroadcast() external; + + /// Has all subsequent calls (at this call depth only) create transactions with the address + /// provided that can later be signed and sent onchain. + function startBroadcast(address signer) external; + + /// Has all subsequent calls (at this call depth only) create transactions with the private key + /// provided that can later be signed and sent onchain. + function startBroadcast(uint256 privateKey) external; + + /// Stops collecting onchain transactions. + function stopBroadcast() external; + + // ======== String ======== + + /// Parses the given `string` into an `address`. + function parseAddress(string calldata stringifiedValue) external pure returns (address parsedValue); + + /// Parses the given `string` into a `bool`. + function parseBool(string calldata stringifiedValue) external pure returns (bool parsedValue); + + /// Parses the given `string` into `bytes`. + function parseBytes(string calldata stringifiedValue) external pure returns (bytes memory parsedValue); + + /// Parses the given `string` into a `bytes32`. + function parseBytes32(string calldata stringifiedValue) external pure returns (bytes32 parsedValue); + + /// Parses the given `string` into a `int256`. + function parseInt(string calldata stringifiedValue) external pure returns (int256 parsedValue); + + /// Parses the given `string` into a `uint256`. + function parseUint(string calldata stringifiedValue) external pure returns (uint256 parsedValue); + + /// Converts the given value to a `string`. + function toString(address value) external pure returns (string memory stringifiedValue); + + /// Converts the given value to a `string`. + function toString(bytes calldata value) external pure returns (string memory stringifiedValue); + + /// Converts the given value to a `string`. + function toString(bytes32 value) external pure returns (string memory stringifiedValue); + + /// Converts the given value to a `string`. + function toString(bool value) external pure returns (string memory stringifiedValue); + + /// Converts the given value to a `string`. + function toString(uint256 value) external pure returns (string memory stringifiedValue); + + /// Converts the given value to a `string`. + function toString(int256 value) external pure returns (string memory stringifiedValue); + + // ======== Testing ======== + + /// If the condition is false, discard this run's fuzz inputs and generate new ones. + function assume(bool condition) external pure; + + /// Writes a breakpoint to jump to in the debugger. + function breakpoint(string calldata char) external; + + /// Writes a conditional breakpoint to jump to in the debugger. + function breakpoint(string calldata char, bool value) external; + + /// Returns the RPC url for the given alias. + function rpcUrl(string calldata rpcAlias) external view returns (string memory json); + + /// Returns all rpc urls and their aliases as structs. + function rpcUrlStructs() external view returns (Rpc[] memory urls); + + /// Returns all rpc urls and their aliases `[alias, url][]`. + function rpcUrls() external view returns (string[2][] memory urls); + + /// Suspends execution of the main thread for `duration` milliseconds. + function sleep(uint256 duration) external; + + // ======== Utilities ======== + + /// Compute the address of a contract created with CREATE2 using the given CREATE2 deployer. + function computeCreate2Address(bytes32 salt, bytes32 initCodeHash, address deployer) + external + pure + returns (address); + + /// Compute the address of a contract created with CREATE2 using the default CREATE2 deployer. + function computeCreate2Address(bytes32 salt, bytes32 initCodeHash) external pure returns (address); + + /// Compute the address a contract will be deployed at for a given deployer address and nonce. + function computeCreateAddress(address deployer, uint256 nonce) external pure returns (address); + + /// Derives a private key from the name, labels the account with that name, and returns the wallet. + function createWallet(string calldata walletLabel) external returns (Wallet memory wallet); + + /// Generates a wallet from the private key and returns the wallet. + function createWallet(uint256 privateKey) external returns (Wallet memory wallet); + + /// Generates a wallet from the private key, labels the account with that name, and returns the wallet. + function createWallet(uint256 privateKey, string calldata walletLabel) external returns (Wallet memory wallet); + + /// Derive a private key from a provided mnenomic string (or mnenomic file path) + /// at the derivation path `m/44'/60'/0'/0/{index}`. + function deriveKey(string calldata mnemonic, uint32 index) external pure returns (uint256 privateKey); + + /// Derive a private key from a provided mnenomic string (or mnenomic file path) + /// at `{derivationPath}{index}`. + function deriveKey(string calldata mnemonic, string calldata derivationPath, uint32 index) + external + pure + returns (uint256 privateKey); + + /// Derive a private key from a provided mnenomic string (or mnenomic file path) in the specified language + /// at the derivation path `m/44'/60'/0'/0/{index}`. + function deriveKey(string calldata mnemonic, uint32 index, string calldata language) + external + pure + returns (uint256 privateKey); + + /// Derive a private key from a provided mnenomic string (or mnenomic file path) in the specified language + /// at `{derivationPath}{index}`. + function deriveKey(string calldata mnemonic, string calldata derivationPath, uint32 index, string calldata language) + external + pure + returns (uint256 privateKey); + + /// Gets the label for the specified address. + function getLabel(address account) external view returns (string memory currentLabel); + + /// Get a `Wallet`'s nonce. + function getNonce(Wallet calldata wallet) external returns (uint64 nonce); + + /// Labels an address in call traces. + function label(address account, string calldata newLabel) external; + + /// Adds a private key to the local forge wallet and returns the address. + function rememberKey(uint256 privateKey) external returns (address keyAddr); + + /// Signs data with a `Wallet`. + function sign(Wallet calldata wallet, bytes32 digest) external returns (uint8 v, bytes32 r, bytes32 s); +} + +/// The `Vm` interface does allow manipulation of the EVM state. These are all intended to be used +/// in tests, but it is not recommended to use these cheats in scripts. +interface Vm is VmSafe { + // ======== EVM ======== + + /// Returns the identifier of the currently active fork. Reverts if no fork is currently active. + function activeFork() external view returns (uint256 forkId); + + /// In forking mode, explicitly grant the given address cheatcode access. + function allowCheatcodes(address account) external; + + /// Sets `block.chainid`. + function chainId(uint256 newChainId) external; + + /// Clears all mocked calls. + function clearMockedCalls() external; + + /// Sets `block.coinbase`. + function coinbase(address newCoinbase) external; + + /// Creates a new fork with the given endpoint and the _latest_ block and returns the identifier of the fork. + function createFork(string calldata urlOrAlias) external returns (uint256 forkId); + + /// Creates a new fork with the given endpoint and block and returns the identifier of the fork. + function createFork(string calldata urlOrAlias, uint256 blockNumber) external returns (uint256 forkId); + + /// Creates a new fork with the given endpoint and at the block the given transaction was mined in, + /// replays all transaction mined in the block before the transaction, and returns the identifier of the fork. + function createFork(string calldata urlOrAlias, bytes32 txHash) external returns (uint256 forkId); + + /// Creates and also selects a new fork with the given endpoint and the latest block and returns the identifier of the fork. + function createSelectFork(string calldata urlOrAlias) external returns (uint256 forkId); + + /// Creates and also selects a new fork with the given endpoint and block and returns the identifier of the fork. + function createSelectFork(string calldata urlOrAlias, uint256 blockNumber) external returns (uint256 forkId); + + /// Creates and also selects new fork with the given endpoint and at the block the given transaction was mined in, + /// replays all transaction mined in the block before the transaction, returns the identifier of the fork. + function createSelectFork(string calldata urlOrAlias, bytes32 txHash) external returns (uint256 forkId); + + /// Sets an address' balance. + function deal(address account, uint256 newBalance) external; + + /// Removes the snapshot with the given ID created by `snapshot`. + /// Takes the snapshot ID to delete. + /// Returns `true` if the snapshot was successfully deleted. + /// Returns `false` if the snapshot does not exist. + function deleteSnapshot(uint256 snapshotId) external returns (bool success); + + /// Removes _all_ snapshots previously created by `snapshot`. + function deleteSnapshots() external; + + /// Sets `block.difficulty`. + /// Not available on EVM versions from Paris onwards. Use `prevrandao` instead. + /// Reverts if used on unsupported EVM versions. + function difficulty(uint256 newDifficulty) external; + + /// Sets an address' code. + function etch(address target, bytes calldata newRuntimeBytecode) external; + + /// Sets `block.basefee`. + function fee(uint256 newBasefee) external; + + /// Returns true if the account is marked as persistent. + function isPersistent(address account) external view returns (bool persistent); + + /// Load a genesis JSON file's `allocs` into the in-memory revm state. + function loadAllocs(string calldata pathToAllocsJson) external; + + /// Marks that the account(s) should use persistent storage across fork swaps in a multifork setup + /// Meaning, changes made to the state of this account will be kept when switching forks. + function makePersistent(address account) external; + + /// See `makePersistent(address)`. + function makePersistent(address account0, address account1) external; + + /// See `makePersistent(address)`. + function makePersistent(address account0, address account1, address account2) external; + + /// See `makePersistent(address)`. + function makePersistent(address[] calldata accounts) external; + + /// Reverts a call to an address with specified revert data. + function mockCallRevert(address callee, bytes calldata data, bytes calldata revertData) external; + + /// Reverts a call to an address with a specific `msg.value`, with specified revert data. + function mockCallRevert(address callee, uint256 msgValue, bytes calldata data, bytes calldata revertData) + external; + + /// Mocks a call to an address, returning specified data. + /// Calldata can either be strict or a partial match, e.g. if you only + /// pass a Solidity selector to the expected calldata, then the entire Solidity + /// function will be mocked. + function mockCall(address callee, bytes calldata data, bytes calldata returnData) external; + + /// Mocks a call to an address with a specific `msg.value`, returning specified data. + /// Calldata match takes precedence over `msg.value` in case of ambiguity. + function mockCall(address callee, uint256 msgValue, bytes calldata data, bytes calldata returnData) external; + + /// Sets the *next* call's `msg.sender` to be the input address. + function prank(address msgSender) external; + + /// Sets the *next* call's `msg.sender` to be the input address, and the `tx.origin` to be the second input. + function prank(address msgSender, address txOrigin) external; + + /// Sets `block.prevrandao`. + /// Not available on EVM versions before Paris. Use `difficulty` instead. + /// If used on unsupported EVM versions it will revert. + function prevrandao(bytes32 newPrevrandao) external; + + /// Reads the current `msg.sender` and `tx.origin` from state and reports if there is any active caller modification. + function readCallers() external returns (CallerMode callerMode, address msgSender, address txOrigin); + + /// Resets the nonce of an account to 0 for EOAs and 1 for contract accounts. + function resetNonce(address account) external; + + /// Revert the state of the EVM to a previous snapshot + /// Takes the snapshot ID to revert to. + /// Returns `true` if the snapshot was successfully reverted. + /// Returns `false` if the snapshot does not exist. + /// **Note:** This does not automatically delete the snapshot. To delete the snapshot use `deleteSnapshot`. + function revertTo(uint256 snapshotId) external returns (bool success); + + /// Revert the state of the EVM to a previous snapshot and automatically deletes the snapshots + /// Takes the snapshot ID to revert to. + /// Returns `true` if the snapshot was successfully reverted and deleted. + /// Returns `false` if the snapshot does not exist. + function revertToAndDelete(uint256 snapshotId) external returns (bool success); + + /// Revokes persistent status from the address, previously added via `makePersistent`. + function revokePersistent(address account) external; + + /// See `revokePersistent(address)`. + function revokePersistent(address[] calldata accounts) external; + + /// Sets `block.height`. + function roll(uint256 newHeight) external; + + /// Updates the currently active fork to given block number + /// This is similar to `roll` but for the currently active fork. + function rollFork(uint256 blockNumber) external; + + /// Updates the currently active fork to given transaction. This will `rollFork` with the number + /// of the block the transaction was mined in and replays all transaction mined before it in the block. + function rollFork(bytes32 txHash) external; + + /// Updates the given fork to given block number. + function rollFork(uint256 forkId, uint256 blockNumber) external; + + /// Updates the given fork to block number of the given transaction and replays all transaction mined before it in the block. + function rollFork(uint256 forkId, bytes32 txHash) external; + + /// Takes a fork identifier created by `createFork` and sets the corresponding forked state as active. + function selectFork(uint256 forkId) external; + + /// Sets the nonce of an account. Must be higher than the current nonce of the account. + function setNonce(address account, uint64 newNonce) external; + + /// Sets the nonce of an account to an arbitrary value. + function setNonceUnsafe(address account, uint64 newNonce) external; + + /// Snapshot the current state of the evm. + /// Returns the ID of the snapshot that was created. + /// To revert a snapshot use `revertTo`. + function snapshot() external returns (uint256 snapshotId); + + /// Sets all subsequent calls' `msg.sender` to be the input address until `stopPrank` is called. + function startPrank(address msgSender) external; + + /// Sets all subsequent calls' `msg.sender` to be the input address until `stopPrank` is called, and the `tx.origin` to be the second input. + function startPrank(address msgSender, address txOrigin) external; + + /// Resets subsequent calls' `msg.sender` to be `address(this)`. + function stopPrank() external; + + /// Stores a value to an address' storage slot. + function store(address target, bytes32 slot, bytes32 value) external; + + /// Fetches the given transaction from the active fork and executes it on the current state. + function transact(bytes32 txHash) external; + + /// Fetches the given transaction from the given fork and executes it on the current state. + function transact(uint256 forkId, bytes32 txHash) external; + + /// Sets `tx.gasprice`. + function txGasPrice(uint256 newGasPrice) external; + + /// Sets `block.timestamp`. + function warp(uint256 newTimestamp) external; + + // ======== Testing ======== + + /// Expect a call to an address with the specified `msg.value` and calldata, and a *minimum* amount of gas. + function expectCallMinGas(address callee, uint256 msgValue, uint64 minGas, bytes calldata data) external; + + /// Expect given number of calls to an address with the specified `msg.value` and calldata, and a *minimum* amount of gas. + function expectCallMinGas(address callee, uint256 msgValue, uint64 minGas, bytes calldata data, uint64 count) + external; + + /// Expects a call to an address with the specified calldata. + /// Calldata can either be a strict or a partial match. + function expectCall(address callee, bytes calldata data) external; + + /// Expects given number of calls to an address with the specified calldata. + function expectCall(address callee, bytes calldata data, uint64 count) external; + + /// Expects a call to an address with the specified `msg.value` and calldata. + function expectCall(address callee, uint256 msgValue, bytes calldata data) external; + + /// Expects given number of calls to an address with the specified `msg.value` and calldata. + function expectCall(address callee, uint256 msgValue, bytes calldata data, uint64 count) external; + + /// Expect a call to an address with the specified `msg.value`, gas, and calldata. + function expectCall(address callee, uint256 msgValue, uint64 gas, bytes calldata data) external; + + /// Expects given number of calls to an address with the specified `msg.value`, gas, and calldata. + function expectCall(address callee, uint256 msgValue, uint64 gas, bytes calldata data, uint64 count) external; + + /// Prepare an expected log with (bool checkTopic1, bool checkTopic2, bool checkTopic3, bool checkData.). + /// Call this function, then emit an event, then call a function. Internally after the call, we check if + /// logs were emitted in the expected order with the expected topics and data (as specified by the booleans). + function expectEmit(bool checkTopic1, bool checkTopic2, bool checkTopic3, bool checkData) external; + + /// Same as the previous method, but also checks supplied address against emitting contract. + function expectEmit(bool checkTopic1, bool checkTopic2, bool checkTopic3, bool checkData, address emitter) + external; + + /// Prepare an expected log with all topic and data checks enabled. + /// Call this function, then emit an event, then call a function. Internally after the call, we check if + /// logs were emitted in the expected order with the expected topics and data. + function expectEmit() external; + + /// Same as the previous method, but also checks supplied address against emitting contract. + function expectEmit(address emitter) external; + + /// Expects an error on next call with any revert data. + function expectRevert() external; + + /// Expects an error on next call that starts with the revert data. + function expectRevert(bytes4 revertData) external; + + /// Expects an error on next call that exactly matches the revert data. + function expectRevert(bytes calldata revertData) external; + + /// Only allows memory writes to offsets [0x00, 0x60) ∪ [min, max) in the current subcontext. If any other + /// memory is written to, the test will fail. Can be called multiple times to add more ranges to the set. + function expectSafeMemory(uint64 min, uint64 max) external; + + /// Only allows memory writes to offsets [0x00, 0x60) ∪ [min, max) in the next created subcontext. + /// If any other memory is written to, the test will fail. Can be called multiple times to add more ranges + /// to the set. + function expectSafeMemoryCall(uint64 min, uint64 max) external; + + /// Marks a test as skipped. Must be called at the top of the test. + function skip(bool skipTest) external; +} diff --git a/docs/crypto/zkCTF/day1/Ethereal/mint-contracts/lib/forge-std/src/console.sol b/docs/crypto/zkCTF/day1/Ethereal/mint-contracts/lib/forge-std/src/console.sol new file mode 100644 index 0000000..ad57e53 --- /dev/null +++ b/docs/crypto/zkCTF/day1/Ethereal/mint-contracts/lib/forge-std/src/console.sol @@ -0,0 +1,1533 @@ +// SPDX-License-Identifier: MIT +pragma solidity >=0.4.22 <0.9.0; + +library console { + address constant CONSOLE_ADDRESS = address(0x000000000000000000636F6e736F6c652e6c6f67); + + function _sendLogPayload(bytes memory payload) private view { + uint256 payloadLength = payload.length; + address consoleAddress = CONSOLE_ADDRESS; + /// @solidity memory-safe-assembly + assembly { + let payloadStart := add(payload, 32) + let r := staticcall(gas(), consoleAddress, payloadStart, payloadLength, 0, 0) + } + } + + function log() internal view { + _sendLogPayload(abi.encodeWithSignature("log()")); + } + + function logInt(int p0) internal view { + _sendLogPayload(abi.encodeWithSignature("log(int)", p0)); + } + + function logUint(uint p0) internal view { + _sendLogPayload(abi.encodeWithSignature("log(uint)", p0)); + } + + function logString(string memory p0) internal view { + _sendLogPayload(abi.encodeWithSignature("log(string)", p0)); + } + + function logBool(bool p0) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bool)", p0)); + } + + function logAddress(address p0) internal view { + _sendLogPayload(abi.encodeWithSignature("log(address)", p0)); + } + + function logBytes(bytes memory p0) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bytes)", p0)); + } + + function logBytes1(bytes1 p0) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bytes1)", p0)); + } + + function logBytes2(bytes2 p0) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bytes2)", p0)); + } + + function logBytes3(bytes3 p0) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bytes3)", p0)); + } + + function logBytes4(bytes4 p0) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bytes4)", p0)); + } + + function logBytes5(bytes5 p0) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bytes5)", p0)); + } + + function logBytes6(bytes6 p0) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bytes6)", p0)); + } + + function logBytes7(bytes7 p0) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bytes7)", p0)); + } + + function logBytes8(bytes8 p0) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bytes8)", p0)); + } + + function logBytes9(bytes9 p0) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bytes9)", p0)); + } + + function logBytes10(bytes10 p0) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bytes10)", p0)); + } + + function logBytes11(bytes11 p0) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bytes11)", p0)); + } + + function logBytes12(bytes12 p0) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bytes12)", p0)); + } + + function logBytes13(bytes13 p0) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bytes13)", p0)); + } + + function logBytes14(bytes14 p0) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bytes14)", p0)); + } + + function logBytes15(bytes15 p0) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bytes15)", p0)); + } + + function logBytes16(bytes16 p0) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bytes16)", p0)); + } + + function logBytes17(bytes17 p0) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bytes17)", p0)); + } + + function logBytes18(bytes18 p0) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bytes18)", p0)); + } + + function logBytes19(bytes19 p0) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bytes19)", p0)); + } + + function logBytes20(bytes20 p0) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bytes20)", p0)); + } + + function logBytes21(bytes21 p0) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bytes21)", p0)); + } + + function logBytes22(bytes22 p0) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bytes22)", p0)); + } + + function logBytes23(bytes23 p0) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bytes23)", p0)); + } + + function logBytes24(bytes24 p0) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bytes24)", p0)); + } + + function logBytes25(bytes25 p0) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bytes25)", p0)); + } + + function logBytes26(bytes26 p0) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bytes26)", p0)); + } + + function logBytes27(bytes27 p0) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bytes27)", p0)); + } + + function logBytes28(bytes28 p0) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bytes28)", p0)); + } + + function logBytes29(bytes29 p0) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bytes29)", p0)); + } + + function logBytes30(bytes30 p0) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bytes30)", p0)); + } + + function logBytes31(bytes31 p0) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bytes31)", p0)); + } + + function logBytes32(bytes32 p0) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bytes32)", p0)); + } + + function log(uint p0) internal view { + _sendLogPayload(abi.encodeWithSignature("log(uint)", p0)); + } + + function log(string memory p0) internal view { + _sendLogPayload(abi.encodeWithSignature("log(string)", p0)); + } + + function log(bool p0) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bool)", p0)); + } + + function log(address p0) internal view { + _sendLogPayload(abi.encodeWithSignature("log(address)", p0)); + } + + function log(uint p0, uint p1) internal view { + _sendLogPayload(abi.encodeWithSignature("log(uint,uint)", p0, p1)); + } + + function log(uint p0, string memory p1) internal view { + _sendLogPayload(abi.encodeWithSignature("log(uint,string)", p0, p1)); + } + + function log(uint p0, bool p1) internal view { + _sendLogPayload(abi.encodeWithSignature("log(uint,bool)", p0, p1)); + } + + function log(uint p0, address p1) internal view { + _sendLogPayload(abi.encodeWithSignature("log(uint,address)", p0, p1)); + } + + function log(string memory p0, uint p1) internal view { + _sendLogPayload(abi.encodeWithSignature("log(string,uint)", p0, p1)); + } + + function log(string memory p0, string memory p1) internal view { + _sendLogPayload(abi.encodeWithSignature("log(string,string)", p0, p1)); + } + + function log(string memory p0, bool p1) internal view { + _sendLogPayload(abi.encodeWithSignature("log(string,bool)", p0, p1)); + } + + function log(string memory p0, address p1) internal view { + _sendLogPayload(abi.encodeWithSignature("log(string,address)", p0, p1)); + } + + function log(bool p0, uint p1) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bool,uint)", p0, p1)); + } + + function log(bool p0, string memory p1) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bool,string)", p0, p1)); + } + + function log(bool p0, bool p1) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bool,bool)", p0, p1)); + } + + function log(bool p0, address p1) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bool,address)", p0, p1)); + } + + function log(address p0, uint p1) internal view { + _sendLogPayload(abi.encodeWithSignature("log(address,uint)", p0, p1)); + } + + function log(address p0, string memory p1) internal view { + _sendLogPayload(abi.encodeWithSignature("log(address,string)", p0, p1)); + } + + function log(address p0, bool p1) internal view { + _sendLogPayload(abi.encodeWithSignature("log(address,bool)", p0, p1)); + } + + function log(address p0, address p1) internal view { + _sendLogPayload(abi.encodeWithSignature("log(address,address)", p0, p1)); + } + + function log(uint p0, uint p1, uint p2) internal view { + _sendLogPayload(abi.encodeWithSignature("log(uint,uint,uint)", p0, p1, p2)); + } + + function log(uint p0, uint p1, string memory p2) internal view { + _sendLogPayload(abi.encodeWithSignature("log(uint,uint,string)", p0, p1, p2)); + } + + function log(uint p0, uint p1, bool p2) internal view { + _sendLogPayload(abi.encodeWithSignature("log(uint,uint,bool)", p0, p1, p2)); + } + + function log(uint p0, uint p1, address p2) internal view { + _sendLogPayload(abi.encodeWithSignature("log(uint,uint,address)", p0, p1, p2)); + } + + function log(uint p0, string memory p1, uint p2) internal view { + _sendLogPayload(abi.encodeWithSignature("log(uint,string,uint)", p0, p1, p2)); + } + + function log(uint p0, string memory p1, string memory p2) internal view { + _sendLogPayload(abi.encodeWithSignature("log(uint,string,string)", p0, p1, p2)); + } + + function log(uint p0, string memory p1, bool p2) internal view { + _sendLogPayload(abi.encodeWithSignature("log(uint,string,bool)", p0, p1, p2)); + } + + function log(uint p0, string memory p1, address p2) internal view { + _sendLogPayload(abi.encodeWithSignature("log(uint,string,address)", p0, p1, p2)); + } + + function log(uint p0, bool p1, uint p2) internal view { + _sendLogPayload(abi.encodeWithSignature("log(uint,bool,uint)", p0, p1, p2)); + } + + function log(uint p0, bool p1, string memory p2) internal view { + _sendLogPayload(abi.encodeWithSignature("log(uint,bool,string)", p0, p1, p2)); + } + + function log(uint p0, bool p1, bool p2) internal view { + _sendLogPayload(abi.encodeWithSignature("log(uint,bool,bool)", p0, p1, p2)); + } + + function log(uint p0, bool p1, address p2) internal view { + _sendLogPayload(abi.encodeWithSignature("log(uint,bool,address)", p0, p1, p2)); + } + + function log(uint p0, address p1, uint p2) internal view { + _sendLogPayload(abi.encodeWithSignature("log(uint,address,uint)", p0, p1, p2)); + } + + function log(uint p0, address p1, string memory p2) internal view { + _sendLogPayload(abi.encodeWithSignature("log(uint,address,string)", p0, p1, p2)); + } + + function log(uint p0, address p1, bool p2) internal view { + _sendLogPayload(abi.encodeWithSignature("log(uint,address,bool)", p0, p1, p2)); + } + + function log(uint p0, address p1, address p2) internal view { + _sendLogPayload(abi.encodeWithSignature("log(uint,address,address)", p0, p1, p2)); + } + + function log(string memory p0, uint p1, uint p2) internal view { + _sendLogPayload(abi.encodeWithSignature("log(string,uint,uint)", p0, p1, p2)); + } + + function log(string memory p0, uint p1, string memory p2) internal view { + _sendLogPayload(abi.encodeWithSignature("log(string,uint,string)", p0, p1, p2)); + } + + function log(string memory p0, uint p1, bool p2) internal view { + _sendLogPayload(abi.encodeWithSignature("log(string,uint,bool)", p0, p1, p2)); + } + + function log(string memory p0, uint p1, address p2) internal view { + _sendLogPayload(abi.encodeWithSignature("log(string,uint,address)", p0, p1, p2)); + } + + function log(string memory p0, string memory p1, uint p2) internal view { + _sendLogPayload(abi.encodeWithSignature("log(string,string,uint)", p0, p1, p2)); + } + + function log(string memory p0, string memory p1, string memory p2) internal view { + _sendLogPayload(abi.encodeWithSignature("log(string,string,string)", p0, p1, p2)); + } + + function log(string memory p0, string memory p1, bool p2) internal view { + _sendLogPayload(abi.encodeWithSignature("log(string,string,bool)", p0, p1, p2)); + } + + function log(string memory p0, string memory p1, address p2) internal view { + _sendLogPayload(abi.encodeWithSignature("log(string,string,address)", p0, p1, p2)); + } + + function log(string memory p0, bool p1, uint p2) internal view { + _sendLogPayload(abi.encodeWithSignature("log(string,bool,uint)", p0, p1, p2)); + } + + function log(string memory p0, bool p1, string memory p2) internal view { + _sendLogPayload(abi.encodeWithSignature("log(string,bool,string)", p0, p1, p2)); + } + + function log(string memory p0, bool p1, bool p2) internal view { + _sendLogPayload(abi.encodeWithSignature("log(string,bool,bool)", p0, p1, p2)); + } + + function log(string memory p0, bool p1, address p2) internal view { + _sendLogPayload(abi.encodeWithSignature("log(string,bool,address)", p0, p1, p2)); + } + + function log(string memory p0, address p1, uint p2) internal view { + _sendLogPayload(abi.encodeWithSignature("log(string,address,uint)", p0, p1, p2)); + } + + function log(string memory p0, address p1, string memory p2) internal view { + _sendLogPayload(abi.encodeWithSignature("log(string,address,string)", p0, p1, p2)); + } + + function log(string memory p0, address p1, bool p2) internal view { + _sendLogPayload(abi.encodeWithSignature("log(string,address,bool)", p0, p1, p2)); + } + + function log(string memory p0, address p1, address p2) internal view { + _sendLogPayload(abi.encodeWithSignature("log(string,address,address)", p0, p1, p2)); + } + + function log(bool p0, uint p1, uint p2) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bool,uint,uint)", p0, p1, p2)); + } + + function log(bool p0, uint p1, string memory p2) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bool,uint,string)", p0, p1, p2)); + } + + function log(bool p0, uint p1, bool p2) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bool,uint,bool)", p0, p1, p2)); + } + + function log(bool p0, uint p1, address p2) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bool,uint,address)", p0, p1, p2)); + } + + function log(bool p0, string memory p1, uint p2) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bool,string,uint)", p0, p1, p2)); + } + + function log(bool p0, string memory p1, string memory p2) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bool,string,string)", p0, p1, p2)); + } + + function log(bool p0, string memory p1, bool p2) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bool,string,bool)", p0, p1, p2)); + } + + function log(bool p0, string memory p1, address p2) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bool,string,address)", p0, p1, p2)); + } + + function log(bool p0, bool p1, uint p2) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bool,bool,uint)", p0, p1, p2)); + } + + function log(bool p0, bool p1, string memory p2) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bool,bool,string)", p0, p1, p2)); + } + + function log(bool p0, bool p1, bool p2) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bool,bool,bool)", p0, p1, p2)); + } + + function log(bool p0, bool p1, address p2) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bool,bool,address)", p0, p1, p2)); + } + + function log(bool p0, address p1, uint p2) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bool,address,uint)", p0, p1, p2)); + } + + function log(bool p0, address p1, string memory p2) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bool,address,string)", p0, p1, p2)); + } + + function log(bool p0, address p1, bool p2) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bool,address,bool)", p0, p1, p2)); + } + + function log(bool p0, address p1, address p2) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bool,address,address)", p0, p1, p2)); + } + + function log(address p0, uint p1, uint p2) internal view { + _sendLogPayload(abi.encodeWithSignature("log(address,uint,uint)", p0, p1, p2)); + } + + function log(address p0, uint p1, string memory p2) internal view { + _sendLogPayload(abi.encodeWithSignature("log(address,uint,string)", p0, p1, p2)); + } + + function log(address p0, uint p1, bool p2) internal view { + _sendLogPayload(abi.encodeWithSignature("log(address,uint,bool)", p0, p1, p2)); + } + + function log(address p0, uint p1, address p2) internal view { + _sendLogPayload(abi.encodeWithSignature("log(address,uint,address)", p0, p1, p2)); + } + + function log(address p0, string memory p1, uint p2) internal view { + _sendLogPayload(abi.encodeWithSignature("log(address,string,uint)", p0, p1, p2)); + } + + function log(address p0, string memory p1, string memory p2) internal view { + _sendLogPayload(abi.encodeWithSignature("log(address,string,string)", p0, p1, p2)); + } + + function log(address p0, string memory p1, bool p2) internal view { + _sendLogPayload(abi.encodeWithSignature("log(address,string,bool)", p0, p1, p2)); + } + + function log(address p0, string memory p1, address p2) internal view { + _sendLogPayload(abi.encodeWithSignature("log(address,string,address)", p0, p1, p2)); + } + + function log(address p0, bool p1, uint p2) internal view { + _sendLogPayload(abi.encodeWithSignature("log(address,bool,uint)", p0, p1, p2)); + } + + function log(address p0, bool p1, string memory p2) internal view { + _sendLogPayload(abi.encodeWithSignature("log(address,bool,string)", p0, p1, p2)); + } + + function log(address p0, bool p1, bool p2) internal view { + _sendLogPayload(abi.encodeWithSignature("log(address,bool,bool)", p0, p1, p2)); + } + + function log(address p0, bool p1, address p2) internal view { + _sendLogPayload(abi.encodeWithSignature("log(address,bool,address)", p0, p1, p2)); + } + + function log(address p0, address p1, uint p2) internal view { + _sendLogPayload(abi.encodeWithSignature("log(address,address,uint)", p0, p1, p2)); + } + + function log(address p0, address p1, string memory p2) internal view { + _sendLogPayload(abi.encodeWithSignature("log(address,address,string)", p0, p1, p2)); + } + + function log(address p0, address p1, bool p2) internal view { + _sendLogPayload(abi.encodeWithSignature("log(address,address,bool)", p0, p1, p2)); + } + + function log(address p0, address p1, address p2) internal view { + _sendLogPayload(abi.encodeWithSignature("log(address,address,address)", p0, p1, p2)); + } + + function log(uint p0, uint p1, uint p2, uint p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(uint,uint,uint,uint)", p0, p1, p2, p3)); + } + + function log(uint p0, uint p1, uint p2, string memory p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(uint,uint,uint,string)", p0, p1, p2, p3)); + } + + function log(uint p0, uint p1, uint p2, bool p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(uint,uint,uint,bool)", p0, p1, p2, p3)); + } + + function log(uint p0, uint p1, uint p2, address p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(uint,uint,uint,address)", p0, p1, p2, p3)); + } + + function log(uint p0, uint p1, string memory p2, uint p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(uint,uint,string,uint)", p0, p1, p2, p3)); + } + + function log(uint p0, uint p1, string memory p2, string memory p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(uint,uint,string,string)", p0, p1, p2, p3)); + } + + function log(uint p0, uint p1, string memory p2, bool p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(uint,uint,string,bool)", p0, p1, p2, p3)); + } + + function log(uint p0, uint p1, string memory p2, address p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(uint,uint,string,address)", p0, p1, p2, p3)); + } + + function log(uint p0, uint p1, bool p2, uint p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(uint,uint,bool,uint)", p0, p1, p2, p3)); + } + + function log(uint p0, uint p1, bool p2, string memory p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(uint,uint,bool,string)", p0, p1, p2, p3)); + } + + function log(uint p0, uint p1, bool p2, bool p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(uint,uint,bool,bool)", p0, p1, p2, p3)); + } + + function log(uint p0, uint p1, bool p2, address p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(uint,uint,bool,address)", p0, p1, p2, p3)); + } + + function log(uint p0, uint p1, address p2, uint p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(uint,uint,address,uint)", p0, p1, p2, p3)); + } + + function log(uint p0, uint p1, address p2, string memory p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(uint,uint,address,string)", p0, p1, p2, p3)); + } + + function log(uint p0, uint p1, address p2, bool p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(uint,uint,address,bool)", p0, p1, p2, p3)); + } + + function log(uint p0, uint p1, address p2, address p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(uint,uint,address,address)", p0, p1, p2, p3)); + } + + function log(uint p0, string memory p1, uint p2, uint p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(uint,string,uint,uint)", p0, p1, p2, p3)); + } + + function log(uint p0, string memory p1, uint p2, string memory p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(uint,string,uint,string)", p0, p1, p2, p3)); + } + + function log(uint p0, string memory p1, uint p2, bool p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(uint,string,uint,bool)", p0, p1, p2, p3)); + } + + function log(uint p0, string memory p1, uint p2, address p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(uint,string,uint,address)", p0, p1, p2, p3)); + } + + function log(uint p0, string memory p1, string memory p2, uint p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(uint,string,string,uint)", p0, p1, p2, p3)); + } + + function log(uint p0, string memory p1, string memory p2, string memory p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(uint,string,string,string)", p0, p1, p2, p3)); + } + + function log(uint p0, string memory p1, string memory p2, bool p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(uint,string,string,bool)", p0, p1, p2, p3)); + } + + function log(uint p0, string memory p1, string memory p2, address p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(uint,string,string,address)", p0, p1, p2, p3)); + } + + function log(uint p0, string memory p1, bool p2, uint p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(uint,string,bool,uint)", p0, p1, p2, p3)); + } + + function log(uint p0, string memory p1, bool p2, string memory p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(uint,string,bool,string)", p0, p1, p2, p3)); + } + + function log(uint p0, string memory p1, bool p2, bool p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(uint,string,bool,bool)", p0, p1, p2, p3)); + } + + function log(uint p0, string memory p1, bool p2, address p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(uint,string,bool,address)", p0, p1, p2, p3)); + } + + function log(uint p0, string memory p1, address p2, uint p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(uint,string,address,uint)", p0, p1, p2, p3)); + } + + function log(uint p0, string memory p1, address p2, string memory p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(uint,string,address,string)", p0, p1, p2, p3)); + } + + function log(uint p0, string memory p1, address p2, bool p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(uint,string,address,bool)", p0, p1, p2, p3)); + } + + function log(uint p0, string memory p1, address p2, address p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(uint,string,address,address)", p0, p1, p2, p3)); + } + + function log(uint p0, bool p1, uint p2, uint p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(uint,bool,uint,uint)", p0, p1, p2, p3)); + } + + function log(uint p0, bool p1, uint p2, string memory p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(uint,bool,uint,string)", p0, p1, p2, p3)); + } + + function log(uint p0, bool p1, uint p2, bool p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(uint,bool,uint,bool)", p0, p1, p2, p3)); + } + + function log(uint p0, bool p1, uint p2, address p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(uint,bool,uint,address)", p0, p1, p2, p3)); + } + + function log(uint p0, bool p1, string memory p2, uint p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(uint,bool,string,uint)", p0, p1, p2, p3)); + } + + function log(uint p0, bool p1, string memory p2, string memory p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(uint,bool,string,string)", p0, p1, p2, p3)); + } + + function log(uint p0, bool p1, string memory p2, bool p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(uint,bool,string,bool)", p0, p1, p2, p3)); + } + + function log(uint p0, bool p1, string memory p2, address p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(uint,bool,string,address)", p0, p1, p2, p3)); + } + + function log(uint p0, bool p1, bool p2, uint p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(uint,bool,bool,uint)", p0, p1, p2, p3)); + } + + function log(uint p0, bool p1, bool p2, string memory p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(uint,bool,bool,string)", p0, p1, p2, p3)); + } + + function log(uint p0, bool p1, bool p2, bool p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(uint,bool,bool,bool)", p0, p1, p2, p3)); + } + + function log(uint p0, bool p1, bool p2, address p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(uint,bool,bool,address)", p0, p1, p2, p3)); + } + + function log(uint p0, bool p1, address p2, uint p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(uint,bool,address,uint)", p0, p1, p2, p3)); + } + + function log(uint p0, bool p1, address p2, string memory p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(uint,bool,address,string)", p0, p1, p2, p3)); + } + + function log(uint p0, bool p1, address p2, bool p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(uint,bool,address,bool)", p0, p1, p2, p3)); + } + + function log(uint p0, bool p1, address p2, address p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(uint,bool,address,address)", p0, p1, p2, p3)); + } + + function log(uint p0, address p1, uint p2, uint p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(uint,address,uint,uint)", p0, p1, p2, p3)); + } + + function log(uint p0, address p1, uint p2, string memory p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(uint,address,uint,string)", p0, p1, p2, p3)); + } + + function log(uint p0, address p1, uint p2, bool p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(uint,address,uint,bool)", p0, p1, p2, p3)); + } + + function log(uint p0, address p1, uint p2, address p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(uint,address,uint,address)", p0, p1, p2, p3)); + } + + function log(uint p0, address p1, string memory p2, uint p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(uint,address,string,uint)", p0, p1, p2, p3)); + } + + function log(uint p0, address p1, string memory p2, string memory p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(uint,address,string,string)", p0, p1, p2, p3)); + } + + function log(uint p0, address p1, string memory p2, bool p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(uint,address,string,bool)", p0, p1, p2, p3)); + } + + function log(uint p0, address p1, string memory p2, address p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(uint,address,string,address)", p0, p1, p2, p3)); + } + + function log(uint p0, address p1, bool p2, uint p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(uint,address,bool,uint)", p0, p1, p2, p3)); + } + + function log(uint p0, address p1, bool p2, string memory p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(uint,address,bool,string)", p0, p1, p2, p3)); + } + + function log(uint p0, address p1, bool p2, bool p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(uint,address,bool,bool)", p0, p1, p2, p3)); + } + + function log(uint p0, address p1, bool p2, address p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(uint,address,bool,address)", p0, p1, p2, p3)); + } + + function log(uint p0, address p1, address p2, uint p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(uint,address,address,uint)", p0, p1, p2, p3)); + } + + function log(uint p0, address p1, address p2, string memory p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(uint,address,address,string)", p0, p1, p2, p3)); + } + + function log(uint p0, address p1, address p2, bool p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(uint,address,address,bool)", p0, p1, p2, p3)); + } + + function log(uint p0, address p1, address p2, address p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(uint,address,address,address)", p0, p1, p2, p3)); + } + + function log(string memory p0, uint p1, uint p2, uint p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(string,uint,uint,uint)", p0, p1, p2, p3)); + } + + function log(string memory p0, uint p1, uint p2, string memory p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(string,uint,uint,string)", p0, p1, p2, p3)); + } + + function log(string memory p0, uint p1, uint p2, bool p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(string,uint,uint,bool)", p0, p1, p2, p3)); + } + + function log(string memory p0, uint p1, uint p2, address p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(string,uint,uint,address)", p0, p1, p2, p3)); + } + + function log(string memory p0, uint p1, string memory p2, uint p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(string,uint,string,uint)", p0, p1, p2, p3)); + } + + function log(string memory p0, uint p1, string memory p2, string memory p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(string,uint,string,string)", p0, p1, p2, p3)); + } + + function log(string memory p0, uint p1, string memory p2, bool p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(string,uint,string,bool)", p0, p1, p2, p3)); + } + + function log(string memory p0, uint p1, string memory p2, address p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(string,uint,string,address)", p0, p1, p2, p3)); + } + + function log(string memory p0, uint p1, bool p2, uint p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(string,uint,bool,uint)", p0, p1, p2, p3)); + } + + function log(string memory p0, uint p1, bool p2, string memory p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(string,uint,bool,string)", p0, p1, p2, p3)); + } + + function log(string memory p0, uint p1, bool p2, bool p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(string,uint,bool,bool)", p0, p1, p2, p3)); + } + + function log(string memory p0, uint p1, bool p2, address p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(string,uint,bool,address)", p0, p1, p2, p3)); + } + + function log(string memory p0, uint p1, address p2, uint p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(string,uint,address,uint)", p0, p1, p2, p3)); + } + + function log(string memory p0, uint p1, address p2, string memory p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(string,uint,address,string)", p0, p1, p2, p3)); + } + + function log(string memory p0, uint p1, address p2, bool p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(string,uint,address,bool)", p0, p1, p2, p3)); + } + + function log(string memory p0, uint p1, address p2, address p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(string,uint,address,address)", p0, p1, p2, p3)); + } + + function log(string memory p0, string memory p1, uint p2, uint p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(string,string,uint,uint)", p0, p1, p2, p3)); + } + + function log(string memory p0, string memory p1, uint p2, string memory p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(string,string,uint,string)", p0, p1, p2, p3)); + } + + function log(string memory p0, string memory p1, uint p2, bool p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(string,string,uint,bool)", p0, p1, p2, p3)); + } + + function log(string memory p0, string memory p1, uint p2, address p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(string,string,uint,address)", p0, p1, p2, p3)); + } + + function log(string memory p0, string memory p1, string memory p2, uint p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(string,string,string,uint)", p0, p1, p2, p3)); + } + + function log(string memory p0, string memory p1, string memory p2, string memory p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(string,string,string,string)", p0, p1, p2, p3)); + } + + function log(string memory p0, string memory p1, string memory p2, bool p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(string,string,string,bool)", p0, p1, p2, p3)); + } + + function log(string memory p0, string memory p1, string memory p2, address p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(string,string,string,address)", p0, p1, p2, p3)); + } + + function log(string memory p0, string memory p1, bool p2, uint p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(string,string,bool,uint)", p0, p1, p2, p3)); + } + + function log(string memory p0, string memory p1, bool p2, string memory p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(string,string,bool,string)", p0, p1, p2, p3)); + } + + function log(string memory p0, string memory p1, bool p2, bool p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(string,string,bool,bool)", p0, p1, p2, p3)); + } + + function log(string memory p0, string memory p1, bool p2, address p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(string,string,bool,address)", p0, p1, p2, p3)); + } + + function log(string memory p0, string memory p1, address p2, uint p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(string,string,address,uint)", p0, p1, p2, p3)); + } + + function log(string memory p0, string memory p1, address p2, string memory p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(string,string,address,string)", p0, p1, p2, p3)); + } + + function log(string memory p0, string memory p1, address p2, bool p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(string,string,address,bool)", p0, p1, p2, p3)); + } + + function log(string memory p0, string memory p1, address p2, address p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(string,string,address,address)", p0, p1, p2, p3)); + } + + function log(string memory p0, bool p1, uint p2, uint p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(string,bool,uint,uint)", p0, p1, p2, p3)); + } + + function log(string memory p0, bool p1, uint p2, string memory p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(string,bool,uint,string)", p0, p1, p2, p3)); + } + + function log(string memory p0, bool p1, uint p2, bool p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(string,bool,uint,bool)", p0, p1, p2, p3)); + } + + function log(string memory p0, bool p1, uint p2, address p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(string,bool,uint,address)", p0, p1, p2, p3)); + } + + function log(string memory p0, bool p1, string memory p2, uint p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(string,bool,string,uint)", p0, p1, p2, p3)); + } + + function log(string memory p0, bool p1, string memory p2, string memory p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(string,bool,string,string)", p0, p1, p2, p3)); + } + + function log(string memory p0, bool p1, string memory p2, bool p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(string,bool,string,bool)", p0, p1, p2, p3)); + } + + function log(string memory p0, bool p1, string memory p2, address p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(string,bool,string,address)", p0, p1, p2, p3)); + } + + function log(string memory p0, bool p1, bool p2, uint p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(string,bool,bool,uint)", p0, p1, p2, p3)); + } + + function log(string memory p0, bool p1, bool p2, string memory p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(string,bool,bool,string)", p0, p1, p2, p3)); + } + + function log(string memory p0, bool p1, bool p2, bool p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(string,bool,bool,bool)", p0, p1, p2, p3)); + } + + function log(string memory p0, bool p1, bool p2, address p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(string,bool,bool,address)", p0, p1, p2, p3)); + } + + function log(string memory p0, bool p1, address p2, uint p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(string,bool,address,uint)", p0, p1, p2, p3)); + } + + function log(string memory p0, bool p1, address p2, string memory p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(string,bool,address,string)", p0, p1, p2, p3)); + } + + function log(string memory p0, bool p1, address p2, bool p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(string,bool,address,bool)", p0, p1, p2, p3)); + } + + function log(string memory p0, bool p1, address p2, address p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(string,bool,address,address)", p0, p1, p2, p3)); + } + + function log(string memory p0, address p1, uint p2, uint p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(string,address,uint,uint)", p0, p1, p2, p3)); + } + + function log(string memory p0, address p1, uint p2, string memory p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(string,address,uint,string)", p0, p1, p2, p3)); + } + + function log(string memory p0, address p1, uint p2, bool p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(string,address,uint,bool)", p0, p1, p2, p3)); + } + + function log(string memory p0, address p1, uint p2, address p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(string,address,uint,address)", p0, p1, p2, p3)); + } + + function log(string memory p0, address p1, string memory p2, uint p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(string,address,string,uint)", p0, p1, p2, p3)); + } + + function log(string memory p0, address p1, string memory p2, string memory p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(string,address,string,string)", p0, p1, p2, p3)); + } + + function log(string memory p0, address p1, string memory p2, bool p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(string,address,string,bool)", p0, p1, p2, p3)); + } + + function log(string memory p0, address p1, string memory p2, address p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(string,address,string,address)", p0, p1, p2, p3)); + } + + function log(string memory p0, address p1, bool p2, uint p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(string,address,bool,uint)", p0, p1, p2, p3)); + } + + function log(string memory p0, address p1, bool p2, string memory p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(string,address,bool,string)", p0, p1, p2, p3)); + } + + function log(string memory p0, address p1, bool p2, bool p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(string,address,bool,bool)", p0, p1, p2, p3)); + } + + function log(string memory p0, address p1, bool p2, address p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(string,address,bool,address)", p0, p1, p2, p3)); + } + + function log(string memory p0, address p1, address p2, uint p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(string,address,address,uint)", p0, p1, p2, p3)); + } + + function log(string memory p0, address p1, address p2, string memory p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(string,address,address,string)", p0, p1, p2, p3)); + } + + function log(string memory p0, address p1, address p2, bool p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(string,address,address,bool)", p0, p1, p2, p3)); + } + + function log(string memory p0, address p1, address p2, address p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(string,address,address,address)", p0, p1, p2, p3)); + } + + function log(bool p0, uint p1, uint p2, uint p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bool,uint,uint,uint)", p0, p1, p2, p3)); + } + + function log(bool p0, uint p1, uint p2, string memory p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bool,uint,uint,string)", p0, p1, p2, p3)); + } + + function log(bool p0, uint p1, uint p2, bool p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bool,uint,uint,bool)", p0, p1, p2, p3)); + } + + function log(bool p0, uint p1, uint p2, address p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bool,uint,uint,address)", p0, p1, p2, p3)); + } + + function log(bool p0, uint p1, string memory p2, uint p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bool,uint,string,uint)", p0, p1, p2, p3)); + } + + function log(bool p0, uint p1, string memory p2, string memory p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bool,uint,string,string)", p0, p1, p2, p3)); + } + + function log(bool p0, uint p1, string memory p2, bool p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bool,uint,string,bool)", p0, p1, p2, p3)); + } + + function log(bool p0, uint p1, string memory p2, address p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bool,uint,string,address)", p0, p1, p2, p3)); + } + + function log(bool p0, uint p1, bool p2, uint p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bool,uint,bool,uint)", p0, p1, p2, p3)); + } + + function log(bool p0, uint p1, bool p2, string memory p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bool,uint,bool,string)", p0, p1, p2, p3)); + } + + function log(bool p0, uint p1, bool p2, bool p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bool,uint,bool,bool)", p0, p1, p2, p3)); + } + + function log(bool p0, uint p1, bool p2, address p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bool,uint,bool,address)", p0, p1, p2, p3)); + } + + function log(bool p0, uint p1, address p2, uint p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bool,uint,address,uint)", p0, p1, p2, p3)); + } + + function log(bool p0, uint p1, address p2, string memory p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bool,uint,address,string)", p0, p1, p2, p3)); + } + + function log(bool p0, uint p1, address p2, bool p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bool,uint,address,bool)", p0, p1, p2, p3)); + } + + function log(bool p0, uint p1, address p2, address p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bool,uint,address,address)", p0, p1, p2, p3)); + } + + function log(bool p0, string memory p1, uint p2, uint p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bool,string,uint,uint)", p0, p1, p2, p3)); + } + + function log(bool p0, string memory p1, uint p2, string memory p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bool,string,uint,string)", p0, p1, p2, p3)); + } + + function log(bool p0, string memory p1, uint p2, bool p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bool,string,uint,bool)", p0, p1, p2, p3)); + } + + function log(bool p0, string memory p1, uint p2, address p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bool,string,uint,address)", p0, p1, p2, p3)); + } + + function log(bool p0, string memory p1, string memory p2, uint p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bool,string,string,uint)", p0, p1, p2, p3)); + } + + function log(bool p0, string memory p1, string memory p2, string memory p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bool,string,string,string)", p0, p1, p2, p3)); + } + + function log(bool p0, string memory p1, string memory p2, bool p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bool,string,string,bool)", p0, p1, p2, p3)); + } + + function log(bool p0, string memory p1, string memory p2, address p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bool,string,string,address)", p0, p1, p2, p3)); + } + + function log(bool p0, string memory p1, bool p2, uint p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bool,string,bool,uint)", p0, p1, p2, p3)); + } + + function log(bool p0, string memory p1, bool p2, string memory p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bool,string,bool,string)", p0, p1, p2, p3)); + } + + function log(bool p0, string memory p1, bool p2, bool p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bool,string,bool,bool)", p0, p1, p2, p3)); + } + + function log(bool p0, string memory p1, bool p2, address p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bool,string,bool,address)", p0, p1, p2, p3)); + } + + function log(bool p0, string memory p1, address p2, uint p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bool,string,address,uint)", p0, p1, p2, p3)); + } + + function log(bool p0, string memory p1, address p2, string memory p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bool,string,address,string)", p0, p1, p2, p3)); + } + + function log(bool p0, string memory p1, address p2, bool p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bool,string,address,bool)", p0, p1, p2, p3)); + } + + function log(bool p0, string memory p1, address p2, address p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bool,string,address,address)", p0, p1, p2, p3)); + } + + function log(bool p0, bool p1, uint p2, uint p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bool,bool,uint,uint)", p0, p1, p2, p3)); + } + + function log(bool p0, bool p1, uint p2, string memory p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bool,bool,uint,string)", p0, p1, p2, p3)); + } + + function log(bool p0, bool p1, uint p2, bool p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bool,bool,uint,bool)", p0, p1, p2, p3)); + } + + function log(bool p0, bool p1, uint p2, address p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bool,bool,uint,address)", p0, p1, p2, p3)); + } + + function log(bool p0, bool p1, string memory p2, uint p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bool,bool,string,uint)", p0, p1, p2, p3)); + } + + function log(bool p0, bool p1, string memory p2, string memory p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bool,bool,string,string)", p0, p1, p2, p3)); + } + + function log(bool p0, bool p1, string memory p2, bool p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bool,bool,string,bool)", p0, p1, p2, p3)); + } + + function log(bool p0, bool p1, string memory p2, address p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bool,bool,string,address)", p0, p1, p2, p3)); + } + + function log(bool p0, bool p1, bool p2, uint p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bool,bool,bool,uint)", p0, p1, p2, p3)); + } + + function log(bool p0, bool p1, bool p2, string memory p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bool,bool,bool,string)", p0, p1, p2, p3)); + } + + function log(bool p0, bool p1, bool p2, bool p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bool,bool,bool,bool)", p0, p1, p2, p3)); + } + + function log(bool p0, bool p1, bool p2, address p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bool,bool,bool,address)", p0, p1, p2, p3)); + } + + function log(bool p0, bool p1, address p2, uint p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bool,bool,address,uint)", p0, p1, p2, p3)); + } + + function log(bool p0, bool p1, address p2, string memory p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bool,bool,address,string)", p0, p1, p2, p3)); + } + + function log(bool p0, bool p1, address p2, bool p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bool,bool,address,bool)", p0, p1, p2, p3)); + } + + function log(bool p0, bool p1, address p2, address p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bool,bool,address,address)", p0, p1, p2, p3)); + } + + function log(bool p0, address p1, uint p2, uint p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bool,address,uint,uint)", p0, p1, p2, p3)); + } + + function log(bool p0, address p1, uint p2, string memory p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bool,address,uint,string)", p0, p1, p2, p3)); + } + + function log(bool p0, address p1, uint p2, bool p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bool,address,uint,bool)", p0, p1, p2, p3)); + } + + function log(bool p0, address p1, uint p2, address p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bool,address,uint,address)", p0, p1, p2, p3)); + } + + function log(bool p0, address p1, string memory p2, uint p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bool,address,string,uint)", p0, p1, p2, p3)); + } + + function log(bool p0, address p1, string memory p2, string memory p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bool,address,string,string)", p0, p1, p2, p3)); + } + + function log(bool p0, address p1, string memory p2, bool p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bool,address,string,bool)", p0, p1, p2, p3)); + } + + function log(bool p0, address p1, string memory p2, address p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bool,address,string,address)", p0, p1, p2, p3)); + } + + function log(bool p0, address p1, bool p2, uint p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bool,address,bool,uint)", p0, p1, p2, p3)); + } + + function log(bool p0, address p1, bool p2, string memory p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bool,address,bool,string)", p0, p1, p2, p3)); + } + + function log(bool p0, address p1, bool p2, bool p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bool,address,bool,bool)", p0, p1, p2, p3)); + } + + function log(bool p0, address p1, bool p2, address p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bool,address,bool,address)", p0, p1, p2, p3)); + } + + function log(bool p0, address p1, address p2, uint p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bool,address,address,uint)", p0, p1, p2, p3)); + } + + function log(bool p0, address p1, address p2, string memory p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bool,address,address,string)", p0, p1, p2, p3)); + } + + function log(bool p0, address p1, address p2, bool p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bool,address,address,bool)", p0, p1, p2, p3)); + } + + function log(bool p0, address p1, address p2, address p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(bool,address,address,address)", p0, p1, p2, p3)); + } + + function log(address p0, uint p1, uint p2, uint p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(address,uint,uint,uint)", p0, p1, p2, p3)); + } + + function log(address p0, uint p1, uint p2, string memory p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(address,uint,uint,string)", p0, p1, p2, p3)); + } + + function log(address p0, uint p1, uint p2, bool p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(address,uint,uint,bool)", p0, p1, p2, p3)); + } + + function log(address p0, uint p1, uint p2, address p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(address,uint,uint,address)", p0, p1, p2, p3)); + } + + function log(address p0, uint p1, string memory p2, uint p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(address,uint,string,uint)", p0, p1, p2, p3)); + } + + function log(address p0, uint p1, string memory p2, string memory p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(address,uint,string,string)", p0, p1, p2, p3)); + } + + function log(address p0, uint p1, string memory p2, bool p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(address,uint,string,bool)", p0, p1, p2, p3)); + } + + function log(address p0, uint p1, string memory p2, address p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(address,uint,string,address)", p0, p1, p2, p3)); + } + + function log(address p0, uint p1, bool p2, uint p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(address,uint,bool,uint)", p0, p1, p2, p3)); + } + + function log(address p0, uint p1, bool p2, string memory p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(address,uint,bool,string)", p0, p1, p2, p3)); + } + + function log(address p0, uint p1, bool p2, bool p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(address,uint,bool,bool)", p0, p1, p2, p3)); + } + + function log(address p0, uint p1, bool p2, address p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(address,uint,bool,address)", p0, p1, p2, p3)); + } + + function log(address p0, uint p1, address p2, uint p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(address,uint,address,uint)", p0, p1, p2, p3)); + } + + function log(address p0, uint p1, address p2, string memory p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(address,uint,address,string)", p0, p1, p2, p3)); + } + + function log(address p0, uint p1, address p2, bool p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(address,uint,address,bool)", p0, p1, p2, p3)); + } + + function log(address p0, uint p1, address p2, address p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(address,uint,address,address)", p0, p1, p2, p3)); + } + + function log(address p0, string memory p1, uint p2, uint p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(address,string,uint,uint)", p0, p1, p2, p3)); + } + + function log(address p0, string memory p1, uint p2, string memory p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(address,string,uint,string)", p0, p1, p2, p3)); + } + + function log(address p0, string memory p1, uint p2, bool p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(address,string,uint,bool)", p0, p1, p2, p3)); + } + + function log(address p0, string memory p1, uint p2, address p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(address,string,uint,address)", p0, p1, p2, p3)); + } + + function log(address p0, string memory p1, string memory p2, uint p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(address,string,string,uint)", p0, p1, p2, p3)); + } + + function log(address p0, string memory p1, string memory p2, string memory p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(address,string,string,string)", p0, p1, p2, p3)); + } + + function log(address p0, string memory p1, string memory p2, bool p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(address,string,string,bool)", p0, p1, p2, p3)); + } + + function log(address p0, string memory p1, string memory p2, address p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(address,string,string,address)", p0, p1, p2, p3)); + } + + function log(address p0, string memory p1, bool p2, uint p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(address,string,bool,uint)", p0, p1, p2, p3)); + } + + function log(address p0, string memory p1, bool p2, string memory p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(address,string,bool,string)", p0, p1, p2, p3)); + } + + function log(address p0, string memory p1, bool p2, bool p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(address,string,bool,bool)", p0, p1, p2, p3)); + } + + function log(address p0, string memory p1, bool p2, address p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(address,string,bool,address)", p0, p1, p2, p3)); + } + + function log(address p0, string memory p1, address p2, uint p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(address,string,address,uint)", p0, p1, p2, p3)); + } + + function log(address p0, string memory p1, address p2, string memory p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(address,string,address,string)", p0, p1, p2, p3)); + } + + function log(address p0, string memory p1, address p2, bool p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(address,string,address,bool)", p0, p1, p2, p3)); + } + + function log(address p0, string memory p1, address p2, address p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(address,string,address,address)", p0, p1, p2, p3)); + } + + function log(address p0, bool p1, uint p2, uint p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(address,bool,uint,uint)", p0, p1, p2, p3)); + } + + function log(address p0, bool p1, uint p2, string memory p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(address,bool,uint,string)", p0, p1, p2, p3)); + } + + function log(address p0, bool p1, uint p2, bool p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(address,bool,uint,bool)", p0, p1, p2, p3)); + } + + function log(address p0, bool p1, uint p2, address p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(address,bool,uint,address)", p0, p1, p2, p3)); + } + + function log(address p0, bool p1, string memory p2, uint p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(address,bool,string,uint)", p0, p1, p2, p3)); + } + + function log(address p0, bool p1, string memory p2, string memory p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(address,bool,string,string)", p0, p1, p2, p3)); + } + + function log(address p0, bool p1, string memory p2, bool p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(address,bool,string,bool)", p0, p1, p2, p3)); + } + + function log(address p0, bool p1, string memory p2, address p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(address,bool,string,address)", p0, p1, p2, p3)); + } + + function log(address p0, bool p1, bool p2, uint p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(address,bool,bool,uint)", p0, p1, p2, p3)); + } + + function log(address p0, bool p1, bool p2, string memory p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(address,bool,bool,string)", p0, p1, p2, p3)); + } + + function log(address p0, bool p1, bool p2, bool p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(address,bool,bool,bool)", p0, p1, p2, p3)); + } + + function log(address p0, bool p1, bool p2, address p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(address,bool,bool,address)", p0, p1, p2, p3)); + } + + function log(address p0, bool p1, address p2, uint p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(address,bool,address,uint)", p0, p1, p2, p3)); + } + + function log(address p0, bool p1, address p2, string memory p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(address,bool,address,string)", p0, p1, p2, p3)); + } + + function log(address p0, bool p1, address p2, bool p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(address,bool,address,bool)", p0, p1, p2, p3)); + } + + function log(address p0, bool p1, address p2, address p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(address,bool,address,address)", p0, p1, p2, p3)); + } + + function log(address p0, address p1, uint p2, uint p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(address,address,uint,uint)", p0, p1, p2, p3)); + } + + function log(address p0, address p1, uint p2, string memory p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(address,address,uint,string)", p0, p1, p2, p3)); + } + + function log(address p0, address p1, uint p2, bool p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(address,address,uint,bool)", p0, p1, p2, p3)); + } + + function log(address p0, address p1, uint p2, address p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(address,address,uint,address)", p0, p1, p2, p3)); + } + + function log(address p0, address p1, string memory p2, uint p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(address,address,string,uint)", p0, p1, p2, p3)); + } + + function log(address p0, address p1, string memory p2, string memory p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(address,address,string,string)", p0, p1, p2, p3)); + } + + function log(address p0, address p1, string memory p2, bool p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(address,address,string,bool)", p0, p1, p2, p3)); + } + + function log(address p0, address p1, string memory p2, address p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(address,address,string,address)", p0, p1, p2, p3)); + } + + function log(address p0, address p1, bool p2, uint p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(address,address,bool,uint)", p0, p1, p2, p3)); + } + + function log(address p0, address p1, bool p2, string memory p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(address,address,bool,string)", p0, p1, p2, p3)); + } + + function log(address p0, address p1, bool p2, bool p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(address,address,bool,bool)", p0, p1, p2, p3)); + } + + function log(address p0, address p1, bool p2, address p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(address,address,bool,address)", p0, p1, p2, p3)); + } + + function log(address p0, address p1, address p2, uint p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(address,address,address,uint)", p0, p1, p2, p3)); + } + + function log(address p0, address p1, address p2, string memory p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(address,address,address,string)", p0, p1, p2, p3)); + } + + function log(address p0, address p1, address p2, bool p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(address,address,address,bool)", p0, p1, p2, p3)); + } + + function log(address p0, address p1, address p2, address p3) internal view { + _sendLogPayload(abi.encodeWithSignature("log(address,address,address,address)", p0, p1, p2, p3)); + } + +} \ No newline at end of file diff --git a/docs/crypto/zkCTF/day1/Ethereal/mint-contracts/lib/forge-std/src/console2.sol b/docs/crypto/zkCTF/day1/Ethereal/mint-contracts/lib/forge-std/src/console2.sol new file mode 100644 index 0000000..c1e2cd7 --- /dev/null +++ b/docs/crypto/zkCTF/day1/Ethereal/mint-contracts/lib/forge-std/src/console2.sol @@ -0,0 +1,1558 @@ +// SPDX-License-Identifier: MIT +pragma solidity >=0.4.22 <0.9.0; + +/// @dev The original console.sol uses `int` and `uint` for computing function selectors, but it should +/// use `int256` and `uint256`. This modified version fixes that. This version is recommended +/// over `console.sol` if you don't need compatibility with Hardhat as the logs will show up in +/// forge stack traces. If you do need compatibility with Hardhat, you must use `console.sol`. +/// Reference: https://github.com/NomicFoundation/hardhat/issues/2178 +library console2 { + address constant CONSOLE_ADDRESS = address(0x000000000000000000636F6e736F6c652e6c6f67); + + function _castLogPayloadViewToPure( + function(bytes memory) internal view fnIn + ) internal pure returns (function(bytes memory) internal pure fnOut) { + assembly { + fnOut := fnIn + } + } + + function _sendLogPayload(bytes memory payload) internal pure { + _castLogPayloadViewToPure(_sendLogPayloadView)(payload); + } + + function _sendLogPayloadView(bytes memory payload) private view { + uint256 payloadLength = payload.length; + address consoleAddress = CONSOLE_ADDRESS; + /// @solidity memory-safe-assembly + assembly { + let payloadStart := add(payload, 32) + let r := staticcall(gas(), consoleAddress, payloadStart, payloadLength, 0, 0) + } + } + + function log() internal pure { + _sendLogPayload(abi.encodeWithSignature("log()")); + } + + function logInt(int256 p0) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(int256)", p0)); + } + + function logUint(uint256 p0) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(uint256)", p0)); + } + + function logString(string memory p0) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(string)", p0)); + } + + function logBool(bool p0) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(bool)", p0)); + } + + function logAddress(address p0) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(address)", p0)); + } + + function logBytes(bytes memory p0) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(bytes)", p0)); + } + + function logBytes1(bytes1 p0) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(bytes1)", p0)); + } + + function logBytes2(bytes2 p0) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(bytes2)", p0)); + } + + function logBytes3(bytes3 p0) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(bytes3)", p0)); + } + + function logBytes4(bytes4 p0) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(bytes4)", p0)); + } + + function logBytes5(bytes5 p0) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(bytes5)", p0)); + } + + function logBytes6(bytes6 p0) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(bytes6)", p0)); + } + + function logBytes7(bytes7 p0) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(bytes7)", p0)); + } + + function logBytes8(bytes8 p0) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(bytes8)", p0)); + } + + function logBytes9(bytes9 p0) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(bytes9)", p0)); + } + + function logBytes10(bytes10 p0) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(bytes10)", p0)); + } + + function logBytes11(bytes11 p0) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(bytes11)", p0)); + } + + function logBytes12(bytes12 p0) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(bytes12)", p0)); + } + + function logBytes13(bytes13 p0) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(bytes13)", p0)); + } + + function logBytes14(bytes14 p0) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(bytes14)", p0)); + } + + function logBytes15(bytes15 p0) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(bytes15)", p0)); + } + + function logBytes16(bytes16 p0) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(bytes16)", p0)); + } + + function logBytes17(bytes17 p0) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(bytes17)", p0)); + } + + function logBytes18(bytes18 p0) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(bytes18)", p0)); + } + + function logBytes19(bytes19 p0) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(bytes19)", p0)); + } + + function logBytes20(bytes20 p0) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(bytes20)", p0)); + } + + function logBytes21(bytes21 p0) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(bytes21)", p0)); + } + + function logBytes22(bytes22 p0) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(bytes22)", p0)); + } + + function logBytes23(bytes23 p0) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(bytes23)", p0)); + } + + function logBytes24(bytes24 p0) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(bytes24)", p0)); + } + + function logBytes25(bytes25 p0) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(bytes25)", p0)); + } + + function logBytes26(bytes26 p0) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(bytes26)", p0)); + } + + function logBytes27(bytes27 p0) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(bytes27)", p0)); + } + + function logBytes28(bytes28 p0) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(bytes28)", p0)); + } + + function logBytes29(bytes29 p0) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(bytes29)", p0)); + } + + function logBytes30(bytes30 p0) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(bytes30)", p0)); + } + + function logBytes31(bytes31 p0) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(bytes31)", p0)); + } + + function logBytes32(bytes32 p0) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(bytes32)", p0)); + } + + function log(uint256 p0) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(uint256)", p0)); + } + + function log(int256 p0) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(int256)", p0)); + } + + function log(string memory p0) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(string)", p0)); + } + + function log(bool p0) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(bool)", p0)); + } + + function log(address p0) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(address)", p0)); + } + + function log(uint256 p0, uint256 p1) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(uint256,uint256)", p0, p1)); + } + + function log(uint256 p0, string memory p1) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(uint256,string)", p0, p1)); + } + + function log(uint256 p0, bool p1) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(uint256,bool)", p0, p1)); + } + + function log(uint256 p0, address p1) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(uint256,address)", p0, p1)); + } + + function log(string memory p0, uint256 p1) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(string,uint256)", p0, p1)); + } + + function log(string memory p0, int256 p1) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(string,int256)", p0, p1)); + } + + function log(string memory p0, string memory p1) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(string,string)", p0, p1)); + } + + function log(string memory p0, bool p1) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(string,bool)", p0, p1)); + } + + function log(string memory p0, address p1) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(string,address)", p0, p1)); + } + + function log(bool p0, uint256 p1) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(bool,uint256)", p0, p1)); + } + + function log(bool p0, string memory p1) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(bool,string)", p0, p1)); + } + + function log(bool p0, bool p1) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(bool,bool)", p0, p1)); + } + + function log(bool p0, address p1) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(bool,address)", p0, p1)); + } + + function log(address p0, uint256 p1) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(address,uint256)", p0, p1)); + } + + function log(address p0, string memory p1) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(address,string)", p0, p1)); + } + + function log(address p0, bool p1) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(address,bool)", p0, p1)); + } + + function log(address p0, address p1) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(address,address)", p0, p1)); + } + + function log(uint256 p0, uint256 p1, uint256 p2) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,uint256)", p0, p1, p2)); + } + + function log(uint256 p0, uint256 p1, string memory p2) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,string)", p0, p1, p2)); + } + + function log(uint256 p0, uint256 p1, bool p2) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,bool)", p0, p1, p2)); + } + + function log(uint256 p0, uint256 p1, address p2) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,address)", p0, p1, p2)); + } + + function log(uint256 p0, string memory p1, uint256 p2) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(uint256,string,uint256)", p0, p1, p2)); + } + + function log(uint256 p0, string memory p1, string memory p2) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(uint256,string,string)", p0, p1, p2)); + } + + function log(uint256 p0, string memory p1, bool p2) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(uint256,string,bool)", p0, p1, p2)); + } + + function log(uint256 p0, string memory p1, address p2) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(uint256,string,address)", p0, p1, p2)); + } + + function log(uint256 p0, bool p1, uint256 p2) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(uint256,bool,uint256)", p0, p1, p2)); + } + + function log(uint256 p0, bool p1, string memory p2) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(uint256,bool,string)", p0, p1, p2)); + } + + function log(uint256 p0, bool p1, bool p2) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(uint256,bool,bool)", p0, p1, p2)); + } + + function log(uint256 p0, bool p1, address p2) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(uint256,bool,address)", p0, p1, p2)); + } + + function log(uint256 p0, address p1, uint256 p2) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(uint256,address,uint256)", p0, p1, p2)); + } + + function log(uint256 p0, address p1, string memory p2) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(uint256,address,string)", p0, p1, p2)); + } + + function log(uint256 p0, address p1, bool p2) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(uint256,address,bool)", p0, p1, p2)); + } + + function log(uint256 p0, address p1, address p2) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(uint256,address,address)", p0, p1, p2)); + } + + function log(string memory p0, uint256 p1, uint256 p2) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(string,uint256,uint256)", p0, p1, p2)); + } + + function log(string memory p0, uint256 p1, string memory p2) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(string,uint256,string)", p0, p1, p2)); + } + + function log(string memory p0, uint256 p1, bool p2) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(string,uint256,bool)", p0, p1, p2)); + } + + function log(string memory p0, uint256 p1, address p2) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(string,uint256,address)", p0, p1, p2)); + } + + function log(string memory p0, string memory p1, uint256 p2) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(string,string,uint256)", p0, p1, p2)); + } + + function log(string memory p0, string memory p1, string memory p2) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(string,string,string)", p0, p1, p2)); + } + + function log(string memory p0, string memory p1, bool p2) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(string,string,bool)", p0, p1, p2)); + } + + function log(string memory p0, string memory p1, address p2) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(string,string,address)", p0, p1, p2)); + } + + function log(string memory p0, bool p1, uint256 p2) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(string,bool,uint256)", p0, p1, p2)); + } + + function log(string memory p0, bool p1, string memory p2) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(string,bool,string)", p0, p1, p2)); + } + + function log(string memory p0, bool p1, bool p2) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(string,bool,bool)", p0, p1, p2)); + } + + function log(string memory p0, bool p1, address p2) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(string,bool,address)", p0, p1, p2)); + } + + function log(string memory p0, address p1, uint256 p2) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(string,address,uint256)", p0, p1, p2)); + } + + function log(string memory p0, address p1, string memory p2) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(string,address,string)", p0, p1, p2)); + } + + function log(string memory p0, address p1, bool p2) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(string,address,bool)", p0, p1, p2)); + } + + function log(string memory p0, address p1, address p2) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(string,address,address)", p0, p1, p2)); + } + + function log(bool p0, uint256 p1, uint256 p2) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(bool,uint256,uint256)", p0, p1, p2)); + } + + function log(bool p0, uint256 p1, string memory p2) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(bool,uint256,string)", p0, p1, p2)); + } + + function log(bool p0, uint256 p1, bool p2) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(bool,uint256,bool)", p0, p1, p2)); + } + + function log(bool p0, uint256 p1, address p2) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(bool,uint256,address)", p0, p1, p2)); + } + + function log(bool p0, string memory p1, uint256 p2) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(bool,string,uint256)", p0, p1, p2)); + } + + function log(bool p0, string memory p1, string memory p2) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(bool,string,string)", p0, p1, p2)); + } + + function log(bool p0, string memory p1, bool p2) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(bool,string,bool)", p0, p1, p2)); + } + + function log(bool p0, string memory p1, address p2) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(bool,string,address)", p0, p1, p2)); + } + + function log(bool p0, bool p1, uint256 p2) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(bool,bool,uint256)", p0, p1, p2)); + } + + function log(bool p0, bool p1, string memory p2) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(bool,bool,string)", p0, p1, p2)); + } + + function log(bool p0, bool p1, bool p2) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(bool,bool,bool)", p0, p1, p2)); + } + + function log(bool p0, bool p1, address p2) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(bool,bool,address)", p0, p1, p2)); + } + + function log(bool p0, address p1, uint256 p2) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(bool,address,uint256)", p0, p1, p2)); + } + + function log(bool p0, address p1, string memory p2) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(bool,address,string)", p0, p1, p2)); + } + + function log(bool p0, address p1, bool p2) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(bool,address,bool)", p0, p1, p2)); + } + + function log(bool p0, address p1, address p2) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(bool,address,address)", p0, p1, p2)); + } + + function log(address p0, uint256 p1, uint256 p2) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(address,uint256,uint256)", p0, p1, p2)); + } + + function log(address p0, uint256 p1, string memory p2) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(address,uint256,string)", p0, p1, p2)); + } + + function log(address p0, uint256 p1, bool p2) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(address,uint256,bool)", p0, p1, p2)); + } + + function log(address p0, uint256 p1, address p2) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(address,uint256,address)", p0, p1, p2)); + } + + function log(address p0, string memory p1, uint256 p2) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(address,string,uint256)", p0, p1, p2)); + } + + function log(address p0, string memory p1, string memory p2) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(address,string,string)", p0, p1, p2)); + } + + function log(address p0, string memory p1, bool p2) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(address,string,bool)", p0, p1, p2)); + } + + function log(address p0, string memory p1, address p2) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(address,string,address)", p0, p1, p2)); + } + + function log(address p0, bool p1, uint256 p2) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(address,bool,uint256)", p0, p1, p2)); + } + + function log(address p0, bool p1, string memory p2) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(address,bool,string)", p0, p1, p2)); + } + + function log(address p0, bool p1, bool p2) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(address,bool,bool)", p0, p1, p2)); + } + + function log(address p0, bool p1, address p2) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(address,bool,address)", p0, p1, p2)); + } + + function log(address p0, address p1, uint256 p2) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(address,address,uint256)", p0, p1, p2)); + } + + function log(address p0, address p1, string memory p2) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(address,address,string)", p0, p1, p2)); + } + + function log(address p0, address p1, bool p2) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(address,address,bool)", p0, p1, p2)); + } + + function log(address p0, address p1, address p2) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(address,address,address)", p0, p1, p2)); + } + + function log(uint256 p0, uint256 p1, uint256 p2, uint256 p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,uint256,uint256)", p0, p1, p2, p3)); + } + + function log(uint256 p0, uint256 p1, uint256 p2, string memory p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,uint256,string)", p0, p1, p2, p3)); + } + + function log(uint256 p0, uint256 p1, uint256 p2, bool p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,uint256,bool)", p0, p1, p2, p3)); + } + + function log(uint256 p0, uint256 p1, uint256 p2, address p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,uint256,address)", p0, p1, p2, p3)); + } + + function log(uint256 p0, uint256 p1, string memory p2, uint256 p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,string,uint256)", p0, p1, p2, p3)); + } + + function log(uint256 p0, uint256 p1, string memory p2, string memory p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,string,string)", p0, p1, p2, p3)); + } + + function log(uint256 p0, uint256 p1, string memory p2, bool p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,string,bool)", p0, p1, p2, p3)); + } + + function log(uint256 p0, uint256 p1, string memory p2, address p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,string,address)", p0, p1, p2, p3)); + } + + function log(uint256 p0, uint256 p1, bool p2, uint256 p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,bool,uint256)", p0, p1, p2, p3)); + } + + function log(uint256 p0, uint256 p1, bool p2, string memory p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,bool,string)", p0, p1, p2, p3)); + } + + function log(uint256 p0, uint256 p1, bool p2, bool p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,bool,bool)", p0, p1, p2, p3)); + } + + function log(uint256 p0, uint256 p1, bool p2, address p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,bool,address)", p0, p1, p2, p3)); + } + + function log(uint256 p0, uint256 p1, address p2, uint256 p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,address,uint256)", p0, p1, p2, p3)); + } + + function log(uint256 p0, uint256 p1, address p2, string memory p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,address,string)", p0, p1, p2, p3)); + } + + function log(uint256 p0, uint256 p1, address p2, bool p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,address,bool)", p0, p1, p2, p3)); + } + + function log(uint256 p0, uint256 p1, address p2, address p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,address,address)", p0, p1, p2, p3)); + } + + function log(uint256 p0, string memory p1, uint256 p2, uint256 p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(uint256,string,uint256,uint256)", p0, p1, p2, p3)); + } + + function log(uint256 p0, string memory p1, uint256 p2, string memory p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(uint256,string,uint256,string)", p0, p1, p2, p3)); + } + + function log(uint256 p0, string memory p1, uint256 p2, bool p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(uint256,string,uint256,bool)", p0, p1, p2, p3)); + } + + function log(uint256 p0, string memory p1, uint256 p2, address p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(uint256,string,uint256,address)", p0, p1, p2, p3)); + } + + function log(uint256 p0, string memory p1, string memory p2, uint256 p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(uint256,string,string,uint256)", p0, p1, p2, p3)); + } + + function log(uint256 p0, string memory p1, string memory p2, string memory p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(uint256,string,string,string)", p0, p1, p2, p3)); + } + + function log(uint256 p0, string memory p1, string memory p2, bool p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(uint256,string,string,bool)", p0, p1, p2, p3)); + } + + function log(uint256 p0, string memory p1, string memory p2, address p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(uint256,string,string,address)", p0, p1, p2, p3)); + } + + function log(uint256 p0, string memory p1, bool p2, uint256 p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(uint256,string,bool,uint256)", p0, p1, p2, p3)); + } + + function log(uint256 p0, string memory p1, bool p2, string memory p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(uint256,string,bool,string)", p0, p1, p2, p3)); + } + + function log(uint256 p0, string memory p1, bool p2, bool p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(uint256,string,bool,bool)", p0, p1, p2, p3)); + } + + function log(uint256 p0, string memory p1, bool p2, address p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(uint256,string,bool,address)", p0, p1, p2, p3)); + } + + function log(uint256 p0, string memory p1, address p2, uint256 p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(uint256,string,address,uint256)", p0, p1, p2, p3)); + } + + function log(uint256 p0, string memory p1, address p2, string memory p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(uint256,string,address,string)", p0, p1, p2, p3)); + } + + function log(uint256 p0, string memory p1, address p2, bool p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(uint256,string,address,bool)", p0, p1, p2, p3)); + } + + function log(uint256 p0, string memory p1, address p2, address p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(uint256,string,address,address)", p0, p1, p2, p3)); + } + + function log(uint256 p0, bool p1, uint256 p2, uint256 p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(uint256,bool,uint256,uint256)", p0, p1, p2, p3)); + } + + function log(uint256 p0, bool p1, uint256 p2, string memory p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(uint256,bool,uint256,string)", p0, p1, p2, p3)); + } + + function log(uint256 p0, bool p1, uint256 p2, bool p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(uint256,bool,uint256,bool)", p0, p1, p2, p3)); + } + + function log(uint256 p0, bool p1, uint256 p2, address p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(uint256,bool,uint256,address)", p0, p1, p2, p3)); + } + + function log(uint256 p0, bool p1, string memory p2, uint256 p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(uint256,bool,string,uint256)", p0, p1, p2, p3)); + } + + function log(uint256 p0, bool p1, string memory p2, string memory p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(uint256,bool,string,string)", p0, p1, p2, p3)); + } + + function log(uint256 p0, bool p1, string memory p2, bool p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(uint256,bool,string,bool)", p0, p1, p2, p3)); + } + + function log(uint256 p0, bool p1, string memory p2, address p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(uint256,bool,string,address)", p0, p1, p2, p3)); + } + + function log(uint256 p0, bool p1, bool p2, uint256 p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(uint256,bool,bool,uint256)", p0, p1, p2, p3)); + } + + function log(uint256 p0, bool p1, bool p2, string memory p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(uint256,bool,bool,string)", p0, p1, p2, p3)); + } + + function log(uint256 p0, bool p1, bool p2, bool p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(uint256,bool,bool,bool)", p0, p1, p2, p3)); + } + + function log(uint256 p0, bool p1, bool p2, address p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(uint256,bool,bool,address)", p0, p1, p2, p3)); + } + + function log(uint256 p0, bool p1, address p2, uint256 p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(uint256,bool,address,uint256)", p0, p1, p2, p3)); + } + + function log(uint256 p0, bool p1, address p2, string memory p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(uint256,bool,address,string)", p0, p1, p2, p3)); + } + + function log(uint256 p0, bool p1, address p2, bool p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(uint256,bool,address,bool)", p0, p1, p2, p3)); + } + + function log(uint256 p0, bool p1, address p2, address p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(uint256,bool,address,address)", p0, p1, p2, p3)); + } + + function log(uint256 p0, address p1, uint256 p2, uint256 p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(uint256,address,uint256,uint256)", p0, p1, p2, p3)); + } + + function log(uint256 p0, address p1, uint256 p2, string memory p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(uint256,address,uint256,string)", p0, p1, p2, p3)); + } + + function log(uint256 p0, address p1, uint256 p2, bool p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(uint256,address,uint256,bool)", p0, p1, p2, p3)); + } + + function log(uint256 p0, address p1, uint256 p2, address p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(uint256,address,uint256,address)", p0, p1, p2, p3)); + } + + function log(uint256 p0, address p1, string memory p2, uint256 p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(uint256,address,string,uint256)", p0, p1, p2, p3)); + } + + function log(uint256 p0, address p1, string memory p2, string memory p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(uint256,address,string,string)", p0, p1, p2, p3)); + } + + function log(uint256 p0, address p1, string memory p2, bool p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(uint256,address,string,bool)", p0, p1, p2, p3)); + } + + function log(uint256 p0, address p1, string memory p2, address p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(uint256,address,string,address)", p0, p1, p2, p3)); + } + + function log(uint256 p0, address p1, bool p2, uint256 p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(uint256,address,bool,uint256)", p0, p1, p2, p3)); + } + + function log(uint256 p0, address p1, bool p2, string memory p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(uint256,address,bool,string)", p0, p1, p2, p3)); + } + + function log(uint256 p0, address p1, bool p2, bool p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(uint256,address,bool,bool)", p0, p1, p2, p3)); + } + + function log(uint256 p0, address p1, bool p2, address p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(uint256,address,bool,address)", p0, p1, p2, p3)); + } + + function log(uint256 p0, address p1, address p2, uint256 p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(uint256,address,address,uint256)", p0, p1, p2, p3)); + } + + function log(uint256 p0, address p1, address p2, string memory p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(uint256,address,address,string)", p0, p1, p2, p3)); + } + + function log(uint256 p0, address p1, address p2, bool p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(uint256,address,address,bool)", p0, p1, p2, p3)); + } + + function log(uint256 p0, address p1, address p2, address p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(uint256,address,address,address)", p0, p1, p2, p3)); + } + + function log(string memory p0, uint256 p1, uint256 p2, uint256 p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(string,uint256,uint256,uint256)", p0, p1, p2, p3)); + } + + function log(string memory p0, uint256 p1, uint256 p2, string memory p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(string,uint256,uint256,string)", p0, p1, p2, p3)); + } + + function log(string memory p0, uint256 p1, uint256 p2, bool p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(string,uint256,uint256,bool)", p0, p1, p2, p3)); + } + + function log(string memory p0, uint256 p1, uint256 p2, address p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(string,uint256,uint256,address)", p0, p1, p2, p3)); + } + + function log(string memory p0, uint256 p1, string memory p2, uint256 p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(string,uint256,string,uint256)", p0, p1, p2, p3)); + } + + function log(string memory p0, uint256 p1, string memory p2, string memory p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(string,uint256,string,string)", p0, p1, p2, p3)); + } + + function log(string memory p0, uint256 p1, string memory p2, bool p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(string,uint256,string,bool)", p0, p1, p2, p3)); + } + + function log(string memory p0, uint256 p1, string memory p2, address p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(string,uint256,string,address)", p0, p1, p2, p3)); + } + + function log(string memory p0, uint256 p1, bool p2, uint256 p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(string,uint256,bool,uint256)", p0, p1, p2, p3)); + } + + function log(string memory p0, uint256 p1, bool p2, string memory p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(string,uint256,bool,string)", p0, p1, p2, p3)); + } + + function log(string memory p0, uint256 p1, bool p2, bool p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(string,uint256,bool,bool)", p0, p1, p2, p3)); + } + + function log(string memory p0, uint256 p1, bool p2, address p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(string,uint256,bool,address)", p0, p1, p2, p3)); + } + + function log(string memory p0, uint256 p1, address p2, uint256 p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(string,uint256,address,uint256)", p0, p1, p2, p3)); + } + + function log(string memory p0, uint256 p1, address p2, string memory p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(string,uint256,address,string)", p0, p1, p2, p3)); + } + + function log(string memory p0, uint256 p1, address p2, bool p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(string,uint256,address,bool)", p0, p1, p2, p3)); + } + + function log(string memory p0, uint256 p1, address p2, address p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(string,uint256,address,address)", p0, p1, p2, p3)); + } + + function log(string memory p0, string memory p1, uint256 p2, uint256 p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(string,string,uint256,uint256)", p0, p1, p2, p3)); + } + + function log(string memory p0, string memory p1, uint256 p2, string memory p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(string,string,uint256,string)", p0, p1, p2, p3)); + } + + function log(string memory p0, string memory p1, uint256 p2, bool p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(string,string,uint256,bool)", p0, p1, p2, p3)); + } + + function log(string memory p0, string memory p1, uint256 p2, address p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(string,string,uint256,address)", p0, p1, p2, p3)); + } + + function log(string memory p0, string memory p1, string memory p2, uint256 p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(string,string,string,uint256)", p0, p1, p2, p3)); + } + + function log(string memory p0, string memory p1, string memory p2, string memory p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(string,string,string,string)", p0, p1, p2, p3)); + } + + function log(string memory p0, string memory p1, string memory p2, bool p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(string,string,string,bool)", p0, p1, p2, p3)); + } + + function log(string memory p0, string memory p1, string memory p2, address p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(string,string,string,address)", p0, p1, p2, p3)); + } + + function log(string memory p0, string memory p1, bool p2, uint256 p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(string,string,bool,uint256)", p0, p1, p2, p3)); + } + + function log(string memory p0, string memory p1, bool p2, string memory p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(string,string,bool,string)", p0, p1, p2, p3)); + } + + function log(string memory p0, string memory p1, bool p2, bool p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(string,string,bool,bool)", p0, p1, p2, p3)); + } + + function log(string memory p0, string memory p1, bool p2, address p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(string,string,bool,address)", p0, p1, p2, p3)); + } + + function log(string memory p0, string memory p1, address p2, uint256 p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(string,string,address,uint256)", p0, p1, p2, p3)); + } + + function log(string memory p0, string memory p1, address p2, string memory p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(string,string,address,string)", p0, p1, p2, p3)); + } + + function log(string memory p0, string memory p1, address p2, bool p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(string,string,address,bool)", p0, p1, p2, p3)); + } + + function log(string memory p0, string memory p1, address p2, address p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(string,string,address,address)", p0, p1, p2, p3)); + } + + function log(string memory p0, bool p1, uint256 p2, uint256 p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(string,bool,uint256,uint256)", p0, p1, p2, p3)); + } + + function log(string memory p0, bool p1, uint256 p2, string memory p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(string,bool,uint256,string)", p0, p1, p2, p3)); + } + + function log(string memory p0, bool p1, uint256 p2, bool p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(string,bool,uint256,bool)", p0, p1, p2, p3)); + } + + function log(string memory p0, bool p1, uint256 p2, address p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(string,bool,uint256,address)", p0, p1, p2, p3)); + } + + function log(string memory p0, bool p1, string memory p2, uint256 p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(string,bool,string,uint256)", p0, p1, p2, p3)); + } + + function log(string memory p0, bool p1, string memory p2, string memory p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(string,bool,string,string)", p0, p1, p2, p3)); + } + + function log(string memory p0, bool p1, string memory p2, bool p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(string,bool,string,bool)", p0, p1, p2, p3)); + } + + function log(string memory p0, bool p1, string memory p2, address p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(string,bool,string,address)", p0, p1, p2, p3)); + } + + function log(string memory p0, bool p1, bool p2, uint256 p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(string,bool,bool,uint256)", p0, p1, p2, p3)); + } + + function log(string memory p0, bool p1, bool p2, string memory p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(string,bool,bool,string)", p0, p1, p2, p3)); + } + + function log(string memory p0, bool p1, bool p2, bool p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(string,bool,bool,bool)", p0, p1, p2, p3)); + } + + function log(string memory p0, bool p1, bool p2, address p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(string,bool,bool,address)", p0, p1, p2, p3)); + } + + function log(string memory p0, bool p1, address p2, uint256 p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(string,bool,address,uint256)", p0, p1, p2, p3)); + } + + function log(string memory p0, bool p1, address p2, string memory p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(string,bool,address,string)", p0, p1, p2, p3)); + } + + function log(string memory p0, bool p1, address p2, bool p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(string,bool,address,bool)", p0, p1, p2, p3)); + } + + function log(string memory p0, bool p1, address p2, address p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(string,bool,address,address)", p0, p1, p2, p3)); + } + + function log(string memory p0, address p1, uint256 p2, uint256 p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(string,address,uint256,uint256)", p0, p1, p2, p3)); + } + + function log(string memory p0, address p1, uint256 p2, string memory p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(string,address,uint256,string)", p0, p1, p2, p3)); + } + + function log(string memory p0, address p1, uint256 p2, bool p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(string,address,uint256,bool)", p0, p1, p2, p3)); + } + + function log(string memory p0, address p1, uint256 p2, address p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(string,address,uint256,address)", p0, p1, p2, p3)); + } + + function log(string memory p0, address p1, string memory p2, uint256 p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(string,address,string,uint256)", p0, p1, p2, p3)); + } + + function log(string memory p0, address p1, string memory p2, string memory p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(string,address,string,string)", p0, p1, p2, p3)); + } + + function log(string memory p0, address p1, string memory p2, bool p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(string,address,string,bool)", p0, p1, p2, p3)); + } + + function log(string memory p0, address p1, string memory p2, address p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(string,address,string,address)", p0, p1, p2, p3)); + } + + function log(string memory p0, address p1, bool p2, uint256 p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(string,address,bool,uint256)", p0, p1, p2, p3)); + } + + function log(string memory p0, address p1, bool p2, string memory p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(string,address,bool,string)", p0, p1, p2, p3)); + } + + function log(string memory p0, address p1, bool p2, bool p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(string,address,bool,bool)", p0, p1, p2, p3)); + } + + function log(string memory p0, address p1, bool p2, address p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(string,address,bool,address)", p0, p1, p2, p3)); + } + + function log(string memory p0, address p1, address p2, uint256 p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(string,address,address,uint256)", p0, p1, p2, p3)); + } + + function log(string memory p0, address p1, address p2, string memory p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(string,address,address,string)", p0, p1, p2, p3)); + } + + function log(string memory p0, address p1, address p2, bool p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(string,address,address,bool)", p0, p1, p2, p3)); + } + + function log(string memory p0, address p1, address p2, address p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(string,address,address,address)", p0, p1, p2, p3)); + } + + function log(bool p0, uint256 p1, uint256 p2, uint256 p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(bool,uint256,uint256,uint256)", p0, p1, p2, p3)); + } + + function log(bool p0, uint256 p1, uint256 p2, string memory p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(bool,uint256,uint256,string)", p0, p1, p2, p3)); + } + + function log(bool p0, uint256 p1, uint256 p2, bool p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(bool,uint256,uint256,bool)", p0, p1, p2, p3)); + } + + function log(bool p0, uint256 p1, uint256 p2, address p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(bool,uint256,uint256,address)", p0, p1, p2, p3)); + } + + function log(bool p0, uint256 p1, string memory p2, uint256 p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(bool,uint256,string,uint256)", p0, p1, p2, p3)); + } + + function log(bool p0, uint256 p1, string memory p2, string memory p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(bool,uint256,string,string)", p0, p1, p2, p3)); + } + + function log(bool p0, uint256 p1, string memory p2, bool p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(bool,uint256,string,bool)", p0, p1, p2, p3)); + } + + function log(bool p0, uint256 p1, string memory p2, address p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(bool,uint256,string,address)", p0, p1, p2, p3)); + } + + function log(bool p0, uint256 p1, bool p2, uint256 p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(bool,uint256,bool,uint256)", p0, p1, p2, p3)); + } + + function log(bool p0, uint256 p1, bool p2, string memory p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(bool,uint256,bool,string)", p0, p1, p2, p3)); + } + + function log(bool p0, uint256 p1, bool p2, bool p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(bool,uint256,bool,bool)", p0, p1, p2, p3)); + } + + function log(bool p0, uint256 p1, bool p2, address p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(bool,uint256,bool,address)", p0, p1, p2, p3)); + } + + function log(bool p0, uint256 p1, address p2, uint256 p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(bool,uint256,address,uint256)", p0, p1, p2, p3)); + } + + function log(bool p0, uint256 p1, address p2, string memory p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(bool,uint256,address,string)", p0, p1, p2, p3)); + } + + function log(bool p0, uint256 p1, address p2, bool p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(bool,uint256,address,bool)", p0, p1, p2, p3)); + } + + function log(bool p0, uint256 p1, address p2, address p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(bool,uint256,address,address)", p0, p1, p2, p3)); + } + + function log(bool p0, string memory p1, uint256 p2, uint256 p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(bool,string,uint256,uint256)", p0, p1, p2, p3)); + } + + function log(bool p0, string memory p1, uint256 p2, string memory p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(bool,string,uint256,string)", p0, p1, p2, p3)); + } + + function log(bool p0, string memory p1, uint256 p2, bool p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(bool,string,uint256,bool)", p0, p1, p2, p3)); + } + + function log(bool p0, string memory p1, uint256 p2, address p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(bool,string,uint256,address)", p0, p1, p2, p3)); + } + + function log(bool p0, string memory p1, string memory p2, uint256 p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(bool,string,string,uint256)", p0, p1, p2, p3)); + } + + function log(bool p0, string memory p1, string memory p2, string memory p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(bool,string,string,string)", p0, p1, p2, p3)); + } + + function log(bool p0, string memory p1, string memory p2, bool p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(bool,string,string,bool)", p0, p1, p2, p3)); + } + + function log(bool p0, string memory p1, string memory p2, address p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(bool,string,string,address)", p0, p1, p2, p3)); + } + + function log(bool p0, string memory p1, bool p2, uint256 p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(bool,string,bool,uint256)", p0, p1, p2, p3)); + } + + function log(bool p0, string memory p1, bool p2, string memory p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(bool,string,bool,string)", p0, p1, p2, p3)); + } + + function log(bool p0, string memory p1, bool p2, bool p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(bool,string,bool,bool)", p0, p1, p2, p3)); + } + + function log(bool p0, string memory p1, bool p2, address p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(bool,string,bool,address)", p0, p1, p2, p3)); + } + + function log(bool p0, string memory p1, address p2, uint256 p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(bool,string,address,uint256)", p0, p1, p2, p3)); + } + + function log(bool p0, string memory p1, address p2, string memory p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(bool,string,address,string)", p0, p1, p2, p3)); + } + + function log(bool p0, string memory p1, address p2, bool p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(bool,string,address,bool)", p0, p1, p2, p3)); + } + + function log(bool p0, string memory p1, address p2, address p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(bool,string,address,address)", p0, p1, p2, p3)); + } + + function log(bool p0, bool p1, uint256 p2, uint256 p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(bool,bool,uint256,uint256)", p0, p1, p2, p3)); + } + + function log(bool p0, bool p1, uint256 p2, string memory p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(bool,bool,uint256,string)", p0, p1, p2, p3)); + } + + function log(bool p0, bool p1, uint256 p2, bool p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(bool,bool,uint256,bool)", p0, p1, p2, p3)); + } + + function log(bool p0, bool p1, uint256 p2, address p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(bool,bool,uint256,address)", p0, p1, p2, p3)); + } + + function log(bool p0, bool p1, string memory p2, uint256 p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(bool,bool,string,uint256)", p0, p1, p2, p3)); + } + + function log(bool p0, bool p1, string memory p2, string memory p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(bool,bool,string,string)", p0, p1, p2, p3)); + } + + function log(bool p0, bool p1, string memory p2, bool p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(bool,bool,string,bool)", p0, p1, p2, p3)); + } + + function log(bool p0, bool p1, string memory p2, address p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(bool,bool,string,address)", p0, p1, p2, p3)); + } + + function log(bool p0, bool p1, bool p2, uint256 p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(bool,bool,bool,uint256)", p0, p1, p2, p3)); + } + + function log(bool p0, bool p1, bool p2, string memory p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(bool,bool,bool,string)", p0, p1, p2, p3)); + } + + function log(bool p0, bool p1, bool p2, bool p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(bool,bool,bool,bool)", p0, p1, p2, p3)); + } + + function log(bool p0, bool p1, bool p2, address p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(bool,bool,bool,address)", p0, p1, p2, p3)); + } + + function log(bool p0, bool p1, address p2, uint256 p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(bool,bool,address,uint256)", p0, p1, p2, p3)); + } + + function log(bool p0, bool p1, address p2, string memory p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(bool,bool,address,string)", p0, p1, p2, p3)); + } + + function log(bool p0, bool p1, address p2, bool p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(bool,bool,address,bool)", p0, p1, p2, p3)); + } + + function log(bool p0, bool p1, address p2, address p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(bool,bool,address,address)", p0, p1, p2, p3)); + } + + function log(bool p0, address p1, uint256 p2, uint256 p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(bool,address,uint256,uint256)", p0, p1, p2, p3)); + } + + function log(bool p0, address p1, uint256 p2, string memory p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(bool,address,uint256,string)", p0, p1, p2, p3)); + } + + function log(bool p0, address p1, uint256 p2, bool p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(bool,address,uint256,bool)", p0, p1, p2, p3)); + } + + function log(bool p0, address p1, uint256 p2, address p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(bool,address,uint256,address)", p0, p1, p2, p3)); + } + + function log(bool p0, address p1, string memory p2, uint256 p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(bool,address,string,uint256)", p0, p1, p2, p3)); + } + + function log(bool p0, address p1, string memory p2, string memory p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(bool,address,string,string)", p0, p1, p2, p3)); + } + + function log(bool p0, address p1, string memory p2, bool p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(bool,address,string,bool)", p0, p1, p2, p3)); + } + + function log(bool p0, address p1, string memory p2, address p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(bool,address,string,address)", p0, p1, p2, p3)); + } + + function log(bool p0, address p1, bool p2, uint256 p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(bool,address,bool,uint256)", p0, p1, p2, p3)); + } + + function log(bool p0, address p1, bool p2, string memory p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(bool,address,bool,string)", p0, p1, p2, p3)); + } + + function log(bool p0, address p1, bool p2, bool p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(bool,address,bool,bool)", p0, p1, p2, p3)); + } + + function log(bool p0, address p1, bool p2, address p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(bool,address,bool,address)", p0, p1, p2, p3)); + } + + function log(bool p0, address p1, address p2, uint256 p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(bool,address,address,uint256)", p0, p1, p2, p3)); + } + + function log(bool p0, address p1, address p2, string memory p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(bool,address,address,string)", p0, p1, p2, p3)); + } + + function log(bool p0, address p1, address p2, bool p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(bool,address,address,bool)", p0, p1, p2, p3)); + } + + function log(bool p0, address p1, address p2, address p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(bool,address,address,address)", p0, p1, p2, p3)); + } + + function log(address p0, uint256 p1, uint256 p2, uint256 p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(address,uint256,uint256,uint256)", p0, p1, p2, p3)); + } + + function log(address p0, uint256 p1, uint256 p2, string memory p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(address,uint256,uint256,string)", p0, p1, p2, p3)); + } + + function log(address p0, uint256 p1, uint256 p2, bool p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(address,uint256,uint256,bool)", p0, p1, p2, p3)); + } + + function log(address p0, uint256 p1, uint256 p2, address p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(address,uint256,uint256,address)", p0, p1, p2, p3)); + } + + function log(address p0, uint256 p1, string memory p2, uint256 p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(address,uint256,string,uint256)", p0, p1, p2, p3)); + } + + function log(address p0, uint256 p1, string memory p2, string memory p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(address,uint256,string,string)", p0, p1, p2, p3)); + } + + function log(address p0, uint256 p1, string memory p2, bool p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(address,uint256,string,bool)", p0, p1, p2, p3)); + } + + function log(address p0, uint256 p1, string memory p2, address p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(address,uint256,string,address)", p0, p1, p2, p3)); + } + + function log(address p0, uint256 p1, bool p2, uint256 p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(address,uint256,bool,uint256)", p0, p1, p2, p3)); + } + + function log(address p0, uint256 p1, bool p2, string memory p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(address,uint256,bool,string)", p0, p1, p2, p3)); + } + + function log(address p0, uint256 p1, bool p2, bool p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(address,uint256,bool,bool)", p0, p1, p2, p3)); + } + + function log(address p0, uint256 p1, bool p2, address p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(address,uint256,bool,address)", p0, p1, p2, p3)); + } + + function log(address p0, uint256 p1, address p2, uint256 p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(address,uint256,address,uint256)", p0, p1, p2, p3)); + } + + function log(address p0, uint256 p1, address p2, string memory p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(address,uint256,address,string)", p0, p1, p2, p3)); + } + + function log(address p0, uint256 p1, address p2, bool p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(address,uint256,address,bool)", p0, p1, p2, p3)); + } + + function log(address p0, uint256 p1, address p2, address p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(address,uint256,address,address)", p0, p1, p2, p3)); + } + + function log(address p0, string memory p1, uint256 p2, uint256 p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(address,string,uint256,uint256)", p0, p1, p2, p3)); + } + + function log(address p0, string memory p1, uint256 p2, string memory p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(address,string,uint256,string)", p0, p1, p2, p3)); + } + + function log(address p0, string memory p1, uint256 p2, bool p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(address,string,uint256,bool)", p0, p1, p2, p3)); + } + + function log(address p0, string memory p1, uint256 p2, address p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(address,string,uint256,address)", p0, p1, p2, p3)); + } + + function log(address p0, string memory p1, string memory p2, uint256 p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(address,string,string,uint256)", p0, p1, p2, p3)); + } + + function log(address p0, string memory p1, string memory p2, string memory p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(address,string,string,string)", p0, p1, p2, p3)); + } + + function log(address p0, string memory p1, string memory p2, bool p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(address,string,string,bool)", p0, p1, p2, p3)); + } + + function log(address p0, string memory p1, string memory p2, address p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(address,string,string,address)", p0, p1, p2, p3)); + } + + function log(address p0, string memory p1, bool p2, uint256 p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(address,string,bool,uint256)", p0, p1, p2, p3)); + } + + function log(address p0, string memory p1, bool p2, string memory p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(address,string,bool,string)", p0, p1, p2, p3)); + } + + function log(address p0, string memory p1, bool p2, bool p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(address,string,bool,bool)", p0, p1, p2, p3)); + } + + function log(address p0, string memory p1, bool p2, address p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(address,string,bool,address)", p0, p1, p2, p3)); + } + + function log(address p0, string memory p1, address p2, uint256 p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(address,string,address,uint256)", p0, p1, p2, p3)); + } + + function log(address p0, string memory p1, address p2, string memory p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(address,string,address,string)", p0, p1, p2, p3)); + } + + function log(address p0, string memory p1, address p2, bool p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(address,string,address,bool)", p0, p1, p2, p3)); + } + + function log(address p0, string memory p1, address p2, address p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(address,string,address,address)", p0, p1, p2, p3)); + } + + function log(address p0, bool p1, uint256 p2, uint256 p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(address,bool,uint256,uint256)", p0, p1, p2, p3)); + } + + function log(address p0, bool p1, uint256 p2, string memory p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(address,bool,uint256,string)", p0, p1, p2, p3)); + } + + function log(address p0, bool p1, uint256 p2, bool p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(address,bool,uint256,bool)", p0, p1, p2, p3)); + } + + function log(address p0, bool p1, uint256 p2, address p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(address,bool,uint256,address)", p0, p1, p2, p3)); + } + + function log(address p0, bool p1, string memory p2, uint256 p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(address,bool,string,uint256)", p0, p1, p2, p3)); + } + + function log(address p0, bool p1, string memory p2, string memory p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(address,bool,string,string)", p0, p1, p2, p3)); + } + + function log(address p0, bool p1, string memory p2, bool p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(address,bool,string,bool)", p0, p1, p2, p3)); + } + + function log(address p0, bool p1, string memory p2, address p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(address,bool,string,address)", p0, p1, p2, p3)); + } + + function log(address p0, bool p1, bool p2, uint256 p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(address,bool,bool,uint256)", p0, p1, p2, p3)); + } + + function log(address p0, bool p1, bool p2, string memory p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(address,bool,bool,string)", p0, p1, p2, p3)); + } + + function log(address p0, bool p1, bool p2, bool p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(address,bool,bool,bool)", p0, p1, p2, p3)); + } + + function log(address p0, bool p1, bool p2, address p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(address,bool,bool,address)", p0, p1, p2, p3)); + } + + function log(address p0, bool p1, address p2, uint256 p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(address,bool,address,uint256)", p0, p1, p2, p3)); + } + + function log(address p0, bool p1, address p2, string memory p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(address,bool,address,string)", p0, p1, p2, p3)); + } + + function log(address p0, bool p1, address p2, bool p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(address,bool,address,bool)", p0, p1, p2, p3)); + } + + function log(address p0, bool p1, address p2, address p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(address,bool,address,address)", p0, p1, p2, p3)); + } + + function log(address p0, address p1, uint256 p2, uint256 p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(address,address,uint256,uint256)", p0, p1, p2, p3)); + } + + function log(address p0, address p1, uint256 p2, string memory p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(address,address,uint256,string)", p0, p1, p2, p3)); + } + + function log(address p0, address p1, uint256 p2, bool p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(address,address,uint256,bool)", p0, p1, p2, p3)); + } + + function log(address p0, address p1, uint256 p2, address p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(address,address,uint256,address)", p0, p1, p2, p3)); + } + + function log(address p0, address p1, string memory p2, uint256 p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(address,address,string,uint256)", p0, p1, p2, p3)); + } + + function log(address p0, address p1, string memory p2, string memory p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(address,address,string,string)", p0, p1, p2, p3)); + } + + function log(address p0, address p1, string memory p2, bool p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(address,address,string,bool)", p0, p1, p2, p3)); + } + + function log(address p0, address p1, string memory p2, address p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(address,address,string,address)", p0, p1, p2, p3)); + } + + function log(address p0, address p1, bool p2, uint256 p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(address,address,bool,uint256)", p0, p1, p2, p3)); + } + + function log(address p0, address p1, bool p2, string memory p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(address,address,bool,string)", p0, p1, p2, p3)); + } + + function log(address p0, address p1, bool p2, bool p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(address,address,bool,bool)", p0, p1, p2, p3)); + } + + function log(address p0, address p1, bool p2, address p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(address,address,bool,address)", p0, p1, p2, p3)); + } + + function log(address p0, address p1, address p2, uint256 p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(address,address,address,uint256)", p0, p1, p2, p3)); + } + + function log(address p0, address p1, address p2, string memory p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(address,address,address,string)", p0, p1, p2, p3)); + } + + function log(address p0, address p1, address p2, bool p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(address,address,address,bool)", p0, p1, p2, p3)); + } + + function log(address p0, address p1, address p2, address p3) internal pure { + _sendLogPayload(abi.encodeWithSignature("log(address,address,address,address)", p0, p1, p2, p3)); + } + +} \ No newline at end of file diff --git a/docs/crypto/zkCTF/day1/Ethereal/mint-contracts/lib/forge-std/src/interfaces/IERC1155.sol b/docs/crypto/zkCTF/day1/Ethereal/mint-contracts/lib/forge-std/src/interfaces/IERC1155.sol new file mode 100644 index 0000000..f7dd2b4 --- /dev/null +++ b/docs/crypto/zkCTF/day1/Ethereal/mint-contracts/lib/forge-std/src/interfaces/IERC1155.sol @@ -0,0 +1,105 @@ +// SPDX-License-Identifier: MIT +pragma solidity >=0.6.2; + +import "./IERC165.sol"; + +/// @title ERC-1155 Multi Token Standard +/// @dev See https://eips.ethereum.org/EIPS/eip-1155 +/// Note: The ERC-165 identifier for this interface is 0xd9b67a26. +interface IERC1155 is IERC165 { + /// @dev + /// - Either `TransferSingle` or `TransferBatch` MUST emit when tokens are transferred, including zero value transfers as well as minting or burning (see "Safe Transfer Rules" section of the standard). + /// - The `_operator` argument MUST be the address of an account/contract that is approved to make the transfer (SHOULD be msg.sender). + /// - The `_from` argument MUST be the address of the holder whose balance is decreased. + /// - The `_to` argument MUST be the address of the recipient whose balance is increased. + /// - The `_id` argument MUST be the token type being transferred. + /// - The `_value` argument MUST be the number of tokens the holder balance is decreased by and match what the recipient balance is increased by. + /// - When minting/creating tokens, the `_from` argument MUST be set to `0x0` (i.e. zero address). + /// - When burning/destroying tokens, the `_to` argument MUST be set to `0x0` (i.e. zero address). + event TransferSingle( + address indexed _operator, address indexed _from, address indexed _to, uint256 _id, uint256 _value + ); + + /// @dev + /// - Either `TransferSingle` or `TransferBatch` MUST emit when tokens are transferred, including zero value transfers as well as minting or burning (see "Safe Transfer Rules" section of the standard). + /// - The `_operator` argument MUST be the address of an account/contract that is approved to make the transfer (SHOULD be msg.sender). + /// - The `_from` argument MUST be the address of the holder whose balance is decreased. + /// - The `_to` argument MUST be the address of the recipient whose balance is increased. + /// - The `_ids` argument MUST be the list of tokens being transferred. + /// - The `_values` argument MUST be the list of number of tokens (matching the list and order of tokens specified in _ids) the holder balance is decreased by and match what the recipient balance is increased by. + /// - When minting/creating tokens, the `_from` argument MUST be set to `0x0` (i.e. zero address). + /// - When burning/destroying tokens, the `_to` argument MUST be set to `0x0` (i.e. zero address). + event TransferBatch( + address indexed _operator, address indexed _from, address indexed _to, uint256[] _ids, uint256[] _values + ); + + /// @dev MUST emit when approval for a second party/operator address to manage all tokens for an owner address is enabled or disabled (absence of an event assumes disabled). + event ApprovalForAll(address indexed _owner, address indexed _operator, bool _approved); + + /// @dev MUST emit when the URI is updated for a token ID. URIs are defined in RFC 3986. + /// The URI MUST point to a JSON file that conforms to the "ERC-1155 Metadata URI JSON Schema". + event URI(string _value, uint256 indexed _id); + + /// @notice Transfers `_value` amount of an `_id` from the `_from` address to the `_to` address specified (with safety call). + /// @dev Caller must be approved to manage the tokens being transferred out of the `_from` account (see "Approval" section of the standard). + /// - MUST revert if `_to` is the zero address. + /// - MUST revert if balance of holder for token `_id` is lower than the `_value` sent. + /// - MUST revert on any other error. + /// - MUST emit the `TransferSingle` event to reflect the balance change (see "Safe Transfer Rules" section of the standard). + /// - After the above conditions are met, this function MUST check if `_to` is a smart contract (e.g. code size > 0). If so, it MUST call `onERC1155Received` on `_to` and act appropriately (see "Safe Transfer Rules" section of the standard). + /// @param _from Source address + /// @param _to Target address + /// @param _id ID of the token type + /// @param _value Transfer amount + /// @param _data Additional data with no specified format, MUST be sent unaltered in call to `onERC1155Received` on `_to` + function safeTransferFrom(address _from, address _to, uint256 _id, uint256 _value, bytes calldata _data) external; + + /// @notice Transfers `_values` amount(s) of `_ids` from the `_from` address to the `_to` address specified (with safety call). + /// @dev Caller must be approved to manage the tokens being transferred out of the `_from` account (see "Approval" section of the standard). + /// - MUST revert if `_to` is the zero address. + /// - MUST revert if length of `_ids` is not the same as length of `_values`. + /// - MUST revert if any of the balance(s) of the holder(s) for token(s) in `_ids` is lower than the respective amount(s) in `_values` sent to the recipient. + /// - MUST revert on any other error. + /// - MUST emit `TransferSingle` or `TransferBatch` event(s) such that all the balance changes are reflected (see "Safe Transfer Rules" section of the standard). + /// - Balance changes and events MUST follow the ordering of the arrays (_ids[0]/_values[0] before _ids[1]/_values[1], etc). + /// - After the above conditions for the transfer(s) in the batch are met, this function MUST check if `_to` is a smart contract (e.g. code size > 0). If so, it MUST call the relevant `ERC1155TokenReceiver` hook(s) on `_to` and act appropriately (see "Safe Transfer Rules" section of the standard). + /// @param _from Source address + /// @param _to Target address + /// @param _ids IDs of each token type (order and length must match _values array) + /// @param _values Transfer amounts per token type (order and length must match _ids array) + /// @param _data Additional data with no specified format, MUST be sent unaltered in call to the `ERC1155TokenReceiver` hook(s) on `_to` + function safeBatchTransferFrom( + address _from, + address _to, + uint256[] calldata _ids, + uint256[] calldata _values, + bytes calldata _data + ) external; + + /// @notice Get the balance of an account's tokens. + /// @param _owner The address of the token holder + /// @param _id ID of the token + /// @return The _owner's balance of the token type requested + function balanceOf(address _owner, uint256 _id) external view returns (uint256); + + /// @notice Get the balance of multiple account/token pairs + /// @param _owners The addresses of the token holders + /// @param _ids ID of the tokens + /// @return The _owner's balance of the token types requested (i.e. balance for each (owner, id) pair) + function balanceOfBatch(address[] calldata _owners, uint256[] calldata _ids) + external + view + returns (uint256[] memory); + + /// @notice Enable or disable approval for a third party ("operator") to manage all of the caller's tokens. + /// @dev MUST emit the ApprovalForAll event on success. + /// @param _operator Address to add to the set of authorized operators + /// @param _approved True if the operator is approved, false to revoke approval + function setApprovalForAll(address _operator, bool _approved) external; + + /// @notice Queries the approval status of an operator for a given owner. + /// @param _owner The owner of the tokens + /// @param _operator Address of authorized operator + /// @return True if the operator is approved, false if not + function isApprovedForAll(address _owner, address _operator) external view returns (bool); +} diff --git a/docs/crypto/zkCTF/day1/Ethereal/mint-contracts/lib/forge-std/src/interfaces/IERC165.sol b/docs/crypto/zkCTF/day1/Ethereal/mint-contracts/lib/forge-std/src/interfaces/IERC165.sol new file mode 100644 index 0000000..9af4bf8 --- /dev/null +++ b/docs/crypto/zkCTF/day1/Ethereal/mint-contracts/lib/forge-std/src/interfaces/IERC165.sol @@ -0,0 +1,12 @@ +// SPDX-License-Identifier: MIT +pragma solidity >=0.6.2; + +interface IERC165 { + /// @notice Query if a contract implements an interface + /// @param interfaceID The interface identifier, as specified in ERC-165 + /// @dev Interface identification is specified in ERC-165. This function + /// uses less than 30,000 gas. + /// @return `true` if the contract implements `interfaceID` and + /// `interfaceID` is not 0xffffffff, `false` otherwise + function supportsInterface(bytes4 interfaceID) external view returns (bool); +} diff --git a/docs/crypto/zkCTF/day1/Ethereal/mint-contracts/lib/forge-std/src/interfaces/IERC20.sol b/docs/crypto/zkCTF/day1/Ethereal/mint-contracts/lib/forge-std/src/interfaces/IERC20.sol new file mode 100644 index 0000000..ba40806 --- /dev/null +++ b/docs/crypto/zkCTF/day1/Ethereal/mint-contracts/lib/forge-std/src/interfaces/IERC20.sol @@ -0,0 +1,43 @@ +// SPDX-License-Identifier: MIT +pragma solidity >=0.6.2; + +/// @dev Interface of the ERC20 standard as defined in the EIP. +/// @dev This includes the optional name, symbol, and decimals metadata. +interface IERC20 { + /// @dev Emitted when `value` tokens are moved from one account (`from`) to another (`to`). + event Transfer(address indexed from, address indexed to, uint256 value); + + /// @dev Emitted when the allowance of a `spender` for an `owner` is set, where `value` + /// is the new allowance. + event Approval(address indexed owner, address indexed spender, uint256 value); + + /// @notice Returns the amount of tokens in existence. + function totalSupply() external view returns (uint256); + + /// @notice Returns the amount of tokens owned by `account`. + function balanceOf(address account) external view returns (uint256); + + /// @notice Moves `amount` tokens from the caller's account to `to`. + function transfer(address to, uint256 amount) external returns (bool); + + /// @notice Returns the remaining number of tokens that `spender` is allowed + /// to spend on behalf of `owner` + function allowance(address owner, address spender) external view returns (uint256); + + /// @notice Sets `amount` as the allowance of `spender` over the caller's tokens. + /// @dev Be aware of front-running risks: https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729 + function approve(address spender, uint256 amount) external returns (bool); + + /// @notice Moves `amount` tokens from `from` to `to` using the allowance mechanism. + /// `amount` is then deducted from the caller's allowance. + function transferFrom(address from, address to, uint256 amount) external returns (bool); + + /// @notice Returns the name of the token. + function name() external view returns (string memory); + + /// @notice Returns the symbol of the token. + function symbol() external view returns (string memory); + + /// @notice Returns the decimals places of the token. + function decimals() external view returns (uint8); +} diff --git a/docs/crypto/zkCTF/day1/Ethereal/mint-contracts/lib/forge-std/src/interfaces/IERC4626.sol b/docs/crypto/zkCTF/day1/Ethereal/mint-contracts/lib/forge-std/src/interfaces/IERC4626.sol new file mode 100644 index 0000000..bfe3a11 --- /dev/null +++ b/docs/crypto/zkCTF/day1/Ethereal/mint-contracts/lib/forge-std/src/interfaces/IERC4626.sol @@ -0,0 +1,190 @@ +// SPDX-License-Identifier: MIT +pragma solidity >=0.6.2; + +import "./IERC20.sol"; + +/// @dev Interface of the ERC4626 "Tokenized Vault Standard", as defined in +/// https://eips.ethereum.org/EIPS/eip-4626 +interface IERC4626 is IERC20 { + event Deposit(address indexed sender, address indexed owner, uint256 assets, uint256 shares); + + event Withdraw( + address indexed sender, address indexed receiver, address indexed owner, uint256 assets, uint256 shares + ); + + /// @notice Returns the address of the underlying token used for the Vault for accounting, depositing, and withdrawing. + /// @dev + /// - MUST be an ERC-20 token contract. + /// - MUST NOT revert. + function asset() external view returns (address assetTokenAddress); + + /// @notice Returns the total amount of the underlying asset that is “managed” by Vault. + /// @dev + /// - SHOULD include any compounding that occurs from yield. + /// - MUST be inclusive of any fees that are charged against assets in the Vault. + /// - MUST NOT revert. + function totalAssets() external view returns (uint256 totalManagedAssets); + + /// @notice Returns the amount of shares that the Vault would exchange for the amount of assets provided, in an ideal + /// scenario where all the conditions are met. + /// @dev + /// - MUST NOT be inclusive of any fees that are charged against assets in the Vault. + /// - MUST NOT show any variations depending on the caller. + /// - MUST NOT reflect slippage or other on-chain conditions, when performing the actual exchange. + /// - MUST NOT revert. + /// + /// NOTE: This calculation MAY NOT reflect the “per-user” price-per-share, and instead should reflect the + /// “average-user’s” price-per-share, meaning what the average user should expect to see when exchanging to and + /// from. + function convertToShares(uint256 assets) external view returns (uint256 shares); + + /// @notice Returns the amount of assets that the Vault would exchange for the amount of shares provided, in an ideal + /// scenario where all the conditions are met. + /// @dev + /// - MUST NOT be inclusive of any fees that are charged against assets in the Vault. + /// - MUST NOT show any variations depending on the caller. + /// - MUST NOT reflect slippage or other on-chain conditions, when performing the actual exchange. + /// - MUST NOT revert. + /// + /// NOTE: This calculation MAY NOT reflect the “per-user” price-per-share, and instead should reflect the + /// “average-user’s” price-per-share, meaning what the average user should expect to see when exchanging to and + /// from. + function convertToAssets(uint256 shares) external view returns (uint256 assets); + + /// @notice Returns the maximum amount of the underlying asset that can be deposited into the Vault for the receiver, + /// through a deposit call. + /// @dev + /// - MUST return a limited value if receiver is subject to some deposit limit. + /// - MUST return 2 ** 256 - 1 if there is no limit on the maximum amount of assets that may be deposited. + /// - MUST NOT revert. + function maxDeposit(address receiver) external view returns (uint256 maxAssets); + + /// @notice Allows an on-chain or off-chain user to simulate the effects of their deposit at the current block, given + /// current on-chain conditions. + /// @dev + /// - MUST return as close to and no more than the exact amount of Vault shares that would be minted in a deposit + /// call in the same transaction. I.e. deposit should return the same or more shares as previewDeposit if called + /// in the same transaction. + /// - MUST NOT account for deposit limits like those returned from maxDeposit and should always act as though the + /// deposit would be accepted, regardless if the user has enough tokens approved, etc. + /// - MUST be inclusive of deposit fees. Integrators should be aware of the existence of deposit fees. + /// - MUST NOT revert. + /// + /// NOTE: any unfavorable discrepancy between convertToShares and previewDeposit SHOULD be considered slippage in + /// share price or some other type of condition, meaning the depositor will lose assets by depositing. + function previewDeposit(uint256 assets) external view returns (uint256 shares); + + /// @notice Mints shares Vault shares to receiver by depositing exactly amount of underlying tokens. + /// @dev + /// - MUST emit the Deposit event. + /// - MAY support an additional flow in which the underlying tokens are owned by the Vault contract before the + /// deposit execution, and are accounted for during deposit. + /// - MUST revert if all of assets cannot be deposited (due to deposit limit being reached, slippage, the user not + /// approving enough underlying tokens to the Vault contract, etc). + /// + /// NOTE: most implementations will require pre-approval of the Vault with the Vault’s underlying asset token. + function deposit(uint256 assets, address receiver) external returns (uint256 shares); + + /// @notice Returns the maximum amount of the Vault shares that can be minted for the receiver, through a mint call. + /// @dev + /// - MUST return a limited value if receiver is subject to some mint limit. + /// - MUST return 2 ** 256 - 1 if there is no limit on the maximum amount of shares that may be minted. + /// - MUST NOT revert. + function maxMint(address receiver) external view returns (uint256 maxShares); + + /// @notice Allows an on-chain or off-chain user to simulate the effects of their mint at the current block, given + /// current on-chain conditions. + /// @dev + /// - MUST return as close to and no fewer than the exact amount of assets that would be deposited in a mint call + /// in the same transaction. I.e. mint should return the same or fewer assets as previewMint if called in the + /// same transaction. + /// - MUST NOT account for mint limits like those returned from maxMint and should always act as though the mint + /// would be accepted, regardless if the user has enough tokens approved, etc. + /// - MUST be inclusive of deposit fees. Integrators should be aware of the existence of deposit fees. + /// - MUST NOT revert. + /// + /// NOTE: any unfavorable discrepancy between convertToAssets and previewMint SHOULD be considered slippage in + /// share price or some other type of condition, meaning the depositor will lose assets by minting. + function previewMint(uint256 shares) external view returns (uint256 assets); + + /// @notice Mints exactly shares Vault shares to receiver by depositing amount of underlying tokens. + /// @dev + /// - MUST emit the Deposit event. + /// - MAY support an additional flow in which the underlying tokens are owned by the Vault contract before the mint + /// execution, and are accounted for during mint. + /// - MUST revert if all of shares cannot be minted (due to deposit limit being reached, slippage, the user not + /// approving enough underlying tokens to the Vault contract, etc). + /// + /// NOTE: most implementations will require pre-approval of the Vault with the Vault’s underlying asset token. + function mint(uint256 shares, address receiver) external returns (uint256 assets); + + /// @notice Returns the maximum amount of the underlying asset that can be withdrawn from the owner balance in the + /// Vault, through a withdraw call. + /// @dev + /// - MUST return a limited value if owner is subject to some withdrawal limit or timelock. + /// - MUST NOT revert. + function maxWithdraw(address owner) external view returns (uint256 maxAssets); + + /// @notice Allows an on-chain or off-chain user to simulate the effects of their withdrawal at the current block, + /// given current on-chain conditions. + /// @dev + /// - MUST return as close to and no fewer than the exact amount of Vault shares that would be burned in a withdraw + /// call in the same transaction. I.e. withdraw should return the same or fewer shares as previewWithdraw if + /// called + /// in the same transaction. + /// - MUST NOT account for withdrawal limits like those returned from maxWithdraw and should always act as though + /// the withdrawal would be accepted, regardless if the user has enough shares, etc. + /// - MUST be inclusive of withdrawal fees. Integrators should be aware of the existence of withdrawal fees. + /// - MUST NOT revert. + /// + /// NOTE: any unfavorable discrepancy between convertToShares and previewWithdraw SHOULD be considered slippage in + /// share price or some other type of condition, meaning the depositor will lose assets by depositing. + function previewWithdraw(uint256 assets) external view returns (uint256 shares); + + /// @notice Burns shares from owner and sends exactly assets of underlying tokens to receiver. + /// @dev + /// - MUST emit the Withdraw event. + /// - MAY support an additional flow in which the underlying tokens are owned by the Vault contract before the + /// withdraw execution, and are accounted for during withdraw. + /// - MUST revert if all of assets cannot be withdrawn (due to withdrawal limit being reached, slippage, the owner + /// not having enough shares, etc). + /// + /// Note that some implementations will require pre-requesting to the Vault before a withdrawal may be performed. + /// Those methods should be performed separately. + function withdraw(uint256 assets, address receiver, address owner) external returns (uint256 shares); + + /// @notice Returns the maximum amount of Vault shares that can be redeemed from the owner balance in the Vault, + /// through a redeem call. + /// @dev + /// - MUST return a limited value if owner is subject to some withdrawal limit or timelock. + /// - MUST return balanceOf(owner) if owner is not subject to any withdrawal limit or timelock. + /// - MUST NOT revert. + function maxRedeem(address owner) external view returns (uint256 maxShares); + + /// @notice Allows an on-chain or off-chain user to simulate the effects of their redeemption at the current block, + /// given current on-chain conditions. + /// @dev + /// - MUST return as close to and no more than the exact amount of assets that would be withdrawn in a redeem call + /// in the same transaction. I.e. redeem should return the same or more assets as previewRedeem if called in the + /// same transaction. + /// - MUST NOT account for redemption limits like those returned from maxRedeem and should always act as though the + /// redemption would be accepted, regardless if the user has enough shares, etc. + /// - MUST be inclusive of withdrawal fees. Integrators should be aware of the existence of withdrawal fees. + /// - MUST NOT revert. + /// + /// NOTE: any unfavorable discrepancy between convertToAssets and previewRedeem SHOULD be considered slippage in + /// share price or some other type of condition, meaning the depositor will lose assets by redeeming. + function previewRedeem(uint256 shares) external view returns (uint256 assets); + + /// @notice Burns exactly shares from owner and sends assets of underlying tokens to receiver. + /// @dev + /// - MUST emit the Withdraw event. + /// - MAY support an additional flow in which the underlying tokens are owned by the Vault contract before the + /// redeem execution, and are accounted for during redeem. + /// - MUST revert if all of shares cannot be redeemed (due to withdrawal limit being reached, slippage, the owner + /// not having enough shares, etc). + /// + /// NOTE: some implementations will require pre-requesting to the Vault before a withdrawal may be performed. + /// Those methods should be performed separately. + function redeem(uint256 shares, address receiver, address owner) external returns (uint256 assets); +} diff --git a/docs/crypto/zkCTF/day1/Ethereal/mint-contracts/lib/forge-std/src/interfaces/IERC721.sol b/docs/crypto/zkCTF/day1/Ethereal/mint-contracts/lib/forge-std/src/interfaces/IERC721.sol new file mode 100644 index 0000000..0a16f45 --- /dev/null +++ b/docs/crypto/zkCTF/day1/Ethereal/mint-contracts/lib/forge-std/src/interfaces/IERC721.sol @@ -0,0 +1,164 @@ +// SPDX-License-Identifier: MIT +pragma solidity >=0.6.2; + +import "./IERC165.sol"; + +/// @title ERC-721 Non-Fungible Token Standard +/// @dev See https://eips.ethereum.org/EIPS/eip-721 +/// Note: the ERC-165 identifier for this interface is 0x80ac58cd. +interface IERC721 is IERC165 { + /// @dev This emits when ownership of any NFT changes by any mechanism. + /// This event emits when NFTs are created (`from` == 0) and destroyed + /// (`to` == 0). Exception: during contract creation, any number of NFTs + /// may be created and assigned without emitting Transfer. At the time of + /// any transfer, the approved address for that NFT (if any) is reset to none. + event Transfer(address indexed _from, address indexed _to, uint256 indexed _tokenId); + + /// @dev This emits when the approved address for an NFT is changed or + /// reaffirmed. The zero address indicates there is no approved address. + /// When a Transfer event emits, this also indicates that the approved + /// address for that NFT (if any) is reset to none. + event Approval(address indexed _owner, address indexed _approved, uint256 indexed _tokenId); + + /// @dev This emits when an operator is enabled or disabled for an owner. + /// The operator can manage all NFTs of the owner. + event ApprovalForAll(address indexed _owner, address indexed _operator, bool _approved); + + /// @notice Count all NFTs assigned to an owner + /// @dev NFTs assigned to the zero address are considered invalid, and this + /// function throws for queries about the zero address. + /// @param _owner An address for whom to query the balance + /// @return The number of NFTs owned by `_owner`, possibly zero + function balanceOf(address _owner) external view returns (uint256); + + /// @notice Find the owner of an NFT + /// @dev NFTs assigned to zero address are considered invalid, and queries + /// about them do throw. + /// @param _tokenId The identifier for an NFT + /// @return The address of the owner of the NFT + function ownerOf(uint256 _tokenId) external view returns (address); + + /// @notice Transfers the ownership of an NFT from one address to another address + /// @dev Throws unless `msg.sender` is the current owner, an authorized + /// operator, or the approved address for this NFT. Throws if `_from` is + /// not the current owner. Throws if `_to` is the zero address. Throws if + /// `_tokenId` is not a valid NFT. When transfer is complete, this function + /// checks if `_to` is a smart contract (code size > 0). If so, it calls + /// `onERC721Received` on `_to` and throws if the return value is not + /// `bytes4(keccak256("onERC721Received(address,address,uint256,bytes)"))`. + /// @param _from The current owner of the NFT + /// @param _to The new owner + /// @param _tokenId The NFT to transfer + /// @param data Additional data with no specified format, sent in call to `_to` + function safeTransferFrom(address _from, address _to, uint256 _tokenId, bytes calldata data) external payable; + + /// @notice Transfers the ownership of an NFT from one address to another address + /// @dev This works identically to the other function with an extra data parameter, + /// except this function just sets data to "". + /// @param _from The current owner of the NFT + /// @param _to The new owner + /// @param _tokenId The NFT to transfer + function safeTransferFrom(address _from, address _to, uint256 _tokenId) external payable; + + /// @notice Transfer ownership of an NFT -- THE CALLER IS RESPONSIBLE + /// TO CONFIRM THAT `_to` IS CAPABLE OF RECEIVING NFTS OR ELSE + /// THEY MAY BE PERMANENTLY LOST + /// @dev Throws unless `msg.sender` is the current owner, an authorized + /// operator, or the approved address for this NFT. Throws if `_from` is + /// not the current owner. Throws if `_to` is the zero address. Throws if + /// `_tokenId` is not a valid NFT. + /// @param _from The current owner of the NFT + /// @param _to The new owner + /// @param _tokenId The NFT to transfer + function transferFrom(address _from, address _to, uint256 _tokenId) external payable; + + /// @notice Change or reaffirm the approved address for an NFT + /// @dev The zero address indicates there is no approved address. + /// Throws unless `msg.sender` is the current NFT owner, or an authorized + /// operator of the current owner. + /// @param _approved The new approved NFT controller + /// @param _tokenId The NFT to approve + function approve(address _approved, uint256 _tokenId) external payable; + + /// @notice Enable or disable approval for a third party ("operator") to manage + /// all of `msg.sender`'s assets + /// @dev Emits the ApprovalForAll event. The contract MUST allow + /// multiple operators per owner. + /// @param _operator Address to add to the set of authorized operators + /// @param _approved True if the operator is approved, false to revoke approval + function setApprovalForAll(address _operator, bool _approved) external; + + /// @notice Get the approved address for a single NFT + /// @dev Throws if `_tokenId` is not a valid NFT. + /// @param _tokenId The NFT to find the approved address for + /// @return The approved address for this NFT, or the zero address if there is none + function getApproved(uint256 _tokenId) external view returns (address); + + /// @notice Query if an address is an authorized operator for another address + /// @param _owner The address that owns the NFTs + /// @param _operator The address that acts on behalf of the owner + /// @return True if `_operator` is an approved operator for `_owner`, false otherwise + function isApprovedForAll(address _owner, address _operator) external view returns (bool); +} + +/// @dev Note: the ERC-165 identifier for this interface is 0x150b7a02. +interface IERC721TokenReceiver { + /// @notice Handle the receipt of an NFT + /// @dev The ERC721 smart contract calls this function on the recipient + /// after a `transfer`. This function MAY throw to revert and reject the + /// transfer. Return of other than the magic value MUST result in the + /// transaction being reverted. + /// Note: the contract address is always the message sender. + /// @param _operator The address which called `safeTransferFrom` function + /// @param _from The address which previously owned the token + /// @param _tokenId The NFT identifier which is being transferred + /// @param _data Additional data with no specified format + /// @return `bytes4(keccak256("onERC721Received(address,address,uint256,bytes)"))` + /// unless throwing + function onERC721Received(address _operator, address _from, uint256 _tokenId, bytes calldata _data) + external + returns (bytes4); +} + +/// @title ERC-721 Non-Fungible Token Standard, optional metadata extension +/// @dev See https://eips.ethereum.org/EIPS/eip-721 +/// Note: the ERC-165 identifier for this interface is 0x5b5e139f. +interface IERC721Metadata is IERC721 { + /// @notice A descriptive name for a collection of NFTs in this contract + function name() external view returns (string memory _name); + + /// @notice An abbreviated name for NFTs in this contract + function symbol() external view returns (string memory _symbol); + + /// @notice A distinct Uniform Resource Identifier (URI) for a given asset. + /// @dev Throws if `_tokenId` is not a valid NFT. URIs are defined in RFC + /// 3986. The URI may point to a JSON file that conforms to the "ERC721 + /// Metadata JSON Schema". + function tokenURI(uint256 _tokenId) external view returns (string memory); +} + +/// @title ERC-721 Non-Fungible Token Standard, optional enumeration extension +/// @dev See https://eips.ethereum.org/EIPS/eip-721 +/// Note: the ERC-165 identifier for this interface is 0x780e9d63. +interface IERC721Enumerable is IERC721 { + /// @notice Count NFTs tracked by this contract + /// @return A count of valid NFTs tracked by this contract, where each one of + /// them has an assigned and queryable owner not equal to the zero address + function totalSupply() external view returns (uint256); + + /// @notice Enumerate valid NFTs + /// @dev Throws if `_index` >= `totalSupply()`. + /// @param _index A counter less than `totalSupply()` + /// @return The token identifier for the `_index`th NFT, + /// (sort order not specified) + function tokenByIndex(uint256 _index) external view returns (uint256); + + /// @notice Enumerate NFTs assigned to an owner + /// @dev Throws if `_index` >= `balanceOf(_owner)` or if + /// `_owner` is the zero address, representing invalid NFTs. + /// @param _owner An address where we are interested in NFTs owned by them + /// @param _index A counter less than `balanceOf(_owner)` + /// @return The token identifier for the `_index`th NFT assigned to `_owner`, + /// (sort order not specified) + function tokenOfOwnerByIndex(address _owner, uint256 _index) external view returns (uint256); +} diff --git a/docs/crypto/zkCTF/day1/Ethereal/mint-contracts/lib/forge-std/src/interfaces/IMulticall3.sol b/docs/crypto/zkCTF/day1/Ethereal/mint-contracts/lib/forge-std/src/interfaces/IMulticall3.sol new file mode 100644 index 0000000..0d031b7 --- /dev/null +++ b/docs/crypto/zkCTF/day1/Ethereal/mint-contracts/lib/forge-std/src/interfaces/IMulticall3.sol @@ -0,0 +1,73 @@ +// SPDX-License-Identifier: MIT +pragma solidity >=0.6.2 <0.9.0; + +pragma experimental ABIEncoderV2; + +interface IMulticall3 { + struct Call { + address target; + bytes callData; + } + + struct Call3 { + address target; + bool allowFailure; + bytes callData; + } + + struct Call3Value { + address target; + bool allowFailure; + uint256 value; + bytes callData; + } + + struct Result { + bool success; + bytes returnData; + } + + function aggregate(Call[] calldata calls) + external + payable + returns (uint256 blockNumber, bytes[] memory returnData); + + function aggregate3(Call3[] calldata calls) external payable returns (Result[] memory returnData); + + function aggregate3Value(Call3Value[] calldata calls) external payable returns (Result[] memory returnData); + + function blockAndAggregate(Call[] calldata calls) + external + payable + returns (uint256 blockNumber, bytes32 blockHash, Result[] memory returnData); + + function getBasefee() external view returns (uint256 basefee); + + function getBlockHash(uint256 blockNumber) external view returns (bytes32 blockHash); + + function getBlockNumber() external view returns (uint256 blockNumber); + + function getChainId() external view returns (uint256 chainid); + + function getCurrentBlockCoinbase() external view returns (address coinbase); + + function getCurrentBlockDifficulty() external view returns (uint256 difficulty); + + function getCurrentBlockGasLimit() external view returns (uint256 gaslimit); + + function getCurrentBlockTimestamp() external view returns (uint256 timestamp); + + function getEthBalance(address addr) external view returns (uint256 balance); + + function getLastBlockHash() external view returns (bytes32 blockHash); + + function tryAggregate(bool requireSuccess, Call[] calldata calls) + external + payable + returns (Result[] memory returnData); + + function tryBlockAndAggregate(bool requireSuccess, Call[] calldata calls) + external + payable + returns (uint256 blockNumber, bytes32 blockHash, Result[] memory returnData); +} diff --git a/docs/crypto/zkCTF/day1/Ethereal/mint-contracts/lib/forge-std/src/mocks/MockERC20.sol b/docs/crypto/zkCTF/day1/Ethereal/mint-contracts/lib/forge-std/src/mocks/MockERC20.sol new file mode 100644 index 0000000..6b825a0 --- /dev/null +++ b/docs/crypto/zkCTF/day1/Ethereal/mint-contracts/lib/forge-std/src/mocks/MockERC20.sol @@ -0,0 +1,216 @@ +// SPDX-License-Identifier: MIT +pragma solidity >=0.6.2 <0.9.0; + +/// @notice This is a mock contract of the ERC20 standard for testing purposes only, it SHOULD NOT be used in production. +/// @dev Forked from: https://github.com/transmissions11/solmate/blob/0384dbaaa4fcb5715738a9254a7c0a4cb62cf458/src/tokens/ERC20.sol +contract MockERC20 { + /*////////////////////////////////////////////////////////////// + EVENTS + //////////////////////////////////////////////////////////////*/ + + event Transfer(address indexed from, address indexed to, uint256 amount); + + event Approval(address indexed owner, address indexed spender, uint256 amount); + + /*////////////////////////////////////////////////////////////// + METADATA STORAGE + //////////////////////////////////////////////////////////////*/ + + string public name; + + string public symbol; + + uint8 public decimals; + + /*////////////////////////////////////////////////////////////// + ERC20 STORAGE + //////////////////////////////////////////////////////////////*/ + + uint256 public totalSupply; + + mapping(address => uint256) public balanceOf; + + mapping(address => mapping(address => uint256)) public allowance; + + /*////////////////////////////////////////////////////////////// + EIP-2612 STORAGE + //////////////////////////////////////////////////////////////*/ + + uint256 internal INITIAL_CHAIN_ID; + + bytes32 internal INITIAL_DOMAIN_SEPARATOR; + + mapping(address => uint256) public nonces; + + /*////////////////////////////////////////////////////////////// + INITIALIZE + //////////////////////////////////////////////////////////////*/ + + /// @dev A bool to track whether the contract has been initialized. + bool private initialized; + + /// @dev To hide constructor warnings across solc versions due to different constructor visibility requirements and + /// syntaxes, we add an initialization function that can be called only once. + function initialize(string memory _name, string memory _symbol, uint8 _decimals) public { + require(!initialized, "ALREADY_INITIALIZED"); + + name = _name; + symbol = _symbol; + decimals = _decimals; + + INITIAL_CHAIN_ID = _pureChainId(); + INITIAL_DOMAIN_SEPARATOR = computeDomainSeparator(); + + initialized = true; + } + + /*////////////////////////////////////////////////////////////// + ERC20 LOGIC + //////////////////////////////////////////////////////////////*/ + + function approve(address spender, uint256 amount) public virtual returns (bool) { + allowance[msg.sender][spender] = amount; + + emit Approval(msg.sender, spender, amount); + + return true; + } + + function transfer(address to, uint256 amount) public virtual returns (bool) { + balanceOf[msg.sender] = _sub(balanceOf[msg.sender], amount); + balanceOf[to] = _add(balanceOf[to], amount); + + emit Transfer(msg.sender, to, amount); + + return true; + } + + function transferFrom(address from, address to, uint256 amount) public virtual returns (bool) { + uint256 allowed = allowance[from][msg.sender]; // Saves gas for limited approvals. + + if (allowed != ~uint256(0)) allowance[from][msg.sender] = _sub(allowed, amount); + + balanceOf[from] = _sub(balanceOf[from], amount); + balanceOf[to] = _add(balanceOf[to], amount); + + emit Transfer(from, to, amount); + + return true; + } + + /*////////////////////////////////////////////////////////////// + EIP-2612 LOGIC + //////////////////////////////////////////////////////////////*/ + + function permit(address owner, address spender, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s) + public + virtual + { + require(deadline >= block.timestamp, "PERMIT_DEADLINE_EXPIRED"); + + address recoveredAddress = ecrecover( + keccak256( + abi.encodePacked( + "\x19\x01", + DOMAIN_SEPARATOR(), + keccak256( + abi.encode( + keccak256( + "Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)" + ), + owner, + spender, + value, + nonces[owner]++, + deadline + ) + ) + ) + ), + v, + r, + s + ); + + require(recoveredAddress != address(0) && recoveredAddress == owner, "INVALID_SIGNER"); + + allowance[recoveredAddress][spender] = value; + + emit Approval(owner, spender, value); + } + + function DOMAIN_SEPARATOR() public view virtual returns (bytes32) { + return _pureChainId() == INITIAL_CHAIN_ID ? INITIAL_DOMAIN_SEPARATOR : computeDomainSeparator(); + } + + function computeDomainSeparator() internal view virtual returns (bytes32) { + return keccak256( + abi.encode( + keccak256("EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)"), + keccak256(bytes(name)), + keccak256("1"), + _pureChainId(), + address(this) + ) + ); + } + + /*////////////////////////////////////////////////////////////// + INTERNAL MINT/BURN LOGIC + //////////////////////////////////////////////////////////////*/ + + function _mint(address to, uint256 amount) internal virtual { + totalSupply = _add(totalSupply, amount); + balanceOf[to] = _add(balanceOf[to], amount); + + emit Transfer(address(0), to, amount); + } + + function _burn(address from, uint256 amount) internal virtual { + balanceOf[from] = _sub(balanceOf[from], amount); + totalSupply = _sub(totalSupply, amount); + + emit Transfer(from, address(0), amount); + } + + /*////////////////////////////////////////////////////////////// + INTERNAL SAFE MATH LOGIC + //////////////////////////////////////////////////////////////*/ + + function _add(uint256 a, uint256 b) internal pure returns (uint256) { + uint256 c = a + b; + require(c >= a, "ERC20: addition overflow"); + return c; + } + + function _sub(uint256 a, uint256 b) internal pure returns (uint256) { + require(a >= b, "ERC20: subtraction underflow"); + return a - b; + } + + /*////////////////////////////////////////////////////////////// + HELPERS + //////////////////////////////////////////////////////////////*/ + + // We use this complex approach of `_viewChainId` and `_pureChainId` to ensure there are no + // compiler warnings when accessing chain ID in any solidity version supported by forge-std. We + // can't simply access the chain ID in a normal view or pure function because the solc View Pure + // Checker changed `chainid` from pure to view in 0.8.0. + function _viewChainId() private view returns (uint256 chainId) { + // Assembly required since `block.chainid` was introduced in 0.8.0. + assembly { + chainId := chainid() + } + + address(this); // Silence warnings in older Solc versions. + } + + function _pureChainId() private pure returns (uint256 chainId) { + function() internal view returns (uint256) fnIn = _viewChainId; + function() internal pure returns (uint256) pureChainId; + assembly { + pureChainId := fnIn + } + chainId = pureChainId(); + } +} diff --git a/docs/crypto/zkCTF/day1/Ethereal/mint-contracts/lib/forge-std/src/mocks/MockERC721.sol b/docs/crypto/zkCTF/day1/Ethereal/mint-contracts/lib/forge-std/src/mocks/MockERC721.sol new file mode 100644 index 0000000..7584087 --- /dev/null +++ b/docs/crypto/zkCTF/day1/Ethereal/mint-contracts/lib/forge-std/src/mocks/MockERC721.sol @@ -0,0 +1,221 @@ +// SPDX-License-Identifier: MIT +pragma solidity >=0.6.2 <0.9.0; + +/// @notice This is a mock contract of the ERC721 standard for testing purposes only, it SHOULD NOT be used in production. +/// @dev Forked from: https://github.com/transmissions11/solmate/blob/0384dbaaa4fcb5715738a9254a7c0a4cb62cf458/src/tokens/ERC721.sol +contract MockERC721 { + /*////////////////////////////////////////////////////////////// + EVENTS + //////////////////////////////////////////////////////////////*/ + + event Transfer(address indexed from, address indexed to, uint256 indexed id); + + event Approval(address indexed owner, address indexed spender, uint256 indexed id); + + event ApprovalForAll(address indexed owner, address indexed operator, bool approved); + + /*////////////////////////////////////////////////////////////// + METADATA STORAGE/LOGIC + //////////////////////////////////////////////////////////////*/ + + string public name; + + string public symbol; + + function tokenURI(uint256 id) public view virtual returns (string memory) {} + + /*////////////////////////////////////////////////////////////// + ERC721 BALANCE/OWNER STORAGE + //////////////////////////////////////////////////////////////*/ + + mapping(uint256 => address) internal _ownerOf; + + mapping(address => uint256) internal _balanceOf; + + function ownerOf(uint256 id) public view virtual returns (address owner) { + require((owner = _ownerOf[id]) != address(0), "NOT_MINTED"); + } + + function balanceOf(address owner) public view virtual returns (uint256) { + require(owner != address(0), "ZERO_ADDRESS"); + + return _balanceOf[owner]; + } + + /*////////////////////////////////////////////////////////////// + ERC721 APPROVAL STORAGE + //////////////////////////////////////////////////////////////*/ + + mapping(uint256 => address) public getApproved; + + mapping(address => mapping(address => bool)) public isApprovedForAll; + + /*////////////////////////////////////////////////////////////// + INITIALIZE + //////////////////////////////////////////////////////////////*/ + + /// @dev A bool to track whether the contract has been initialized. + bool private initialized; + + /// @dev To hide constructor warnings across solc versions due to different constructor visibility requirements and + /// syntaxes, we add an initialization function that can be called only once. + function initialize(string memory _name, string memory _symbol) public { + require(!initialized, "ALREADY_INITIALIZED"); + + name = _name; + symbol = _symbol; + + initialized = true; + } + + /*////////////////////////////////////////////////////////////// + ERC721 LOGIC + //////////////////////////////////////////////////////////////*/ + + function approve(address spender, uint256 id) public virtual { + address owner = _ownerOf[id]; + + require(msg.sender == owner || isApprovedForAll[owner][msg.sender], "NOT_AUTHORIZED"); + + getApproved[id] = spender; + + emit Approval(owner, spender, id); + } + + function setApprovalForAll(address operator, bool approved) public virtual { + isApprovedForAll[msg.sender][operator] = approved; + + emit ApprovalForAll(msg.sender, operator, approved); + } + + function transferFrom(address from, address to, uint256 id) public virtual { + require(from == _ownerOf[id], "WRONG_FROM"); + + require(to != address(0), "INVALID_RECIPIENT"); + + require( + msg.sender == from || isApprovedForAll[from][msg.sender] || msg.sender == getApproved[id], "NOT_AUTHORIZED" + ); + + // Underflow of the sender's balance is impossible because we check for + // ownership above and the recipient's balance can't realistically overflow. + _balanceOf[from]--; + + _balanceOf[to]++; + + _ownerOf[id] = to; + + delete getApproved[id]; + + emit Transfer(from, to, id); + } + + function safeTransferFrom(address from, address to, uint256 id) public virtual { + transferFrom(from, to, id); + + require( + !_isContract(to) + || IERC721TokenReceiver(to).onERC721Received(msg.sender, from, id, "") + == IERC721TokenReceiver.onERC721Received.selector, + "UNSAFE_RECIPIENT" + ); + } + + function safeTransferFrom(address from, address to, uint256 id, bytes memory data) public virtual { + transferFrom(from, to, id); + + require( + !_isContract(to) + || IERC721TokenReceiver(to).onERC721Received(msg.sender, from, id, data) + == IERC721TokenReceiver.onERC721Received.selector, + "UNSAFE_RECIPIENT" + ); + } + + /*////////////////////////////////////////////////////////////// + ERC165 LOGIC + //////////////////////////////////////////////////////////////*/ + + function supportsInterface(bytes4 interfaceId) public pure virtual returns (bool) { + return interfaceId == 0x01ffc9a7 // ERC165 Interface ID for ERC165 + || interfaceId == 0x80ac58cd // ERC165 Interface ID for ERC721 + || interfaceId == 0x5b5e139f; // ERC165 Interface ID for ERC721Metadata + } + + /*////////////////////////////////////////////////////////////// + INTERNAL MINT/BURN LOGIC + //////////////////////////////////////////////////////////////*/ + + function _mint(address to, uint256 id) internal virtual { + require(to != address(0), "INVALID_RECIPIENT"); + + require(_ownerOf[id] == address(0), "ALREADY_MINTED"); + + // Counter overflow is incredibly unrealistic. + + _balanceOf[to]++; + + _ownerOf[id] = to; + + emit Transfer(address(0), to, id); + } + + function _burn(uint256 id) internal virtual { + address owner = _ownerOf[id]; + + require(owner != address(0), "NOT_MINTED"); + + _balanceOf[owner]--; + + delete _ownerOf[id]; + + delete getApproved[id]; + + emit Transfer(owner, address(0), id); + } + + /*////////////////////////////////////////////////////////////// + INTERNAL SAFE MINT LOGIC + //////////////////////////////////////////////////////////////*/ + + function _safeMint(address to, uint256 id) internal virtual { + _mint(to, id); + + require( + !_isContract(to) + || IERC721TokenReceiver(to).onERC721Received(msg.sender, address(0), id, "") + == IERC721TokenReceiver.onERC721Received.selector, + "UNSAFE_RECIPIENT" + ); + } + + function _safeMint(address to, uint256 id, bytes memory data) internal virtual { + _mint(to, id); + + require( + !_isContract(to) + || IERC721TokenReceiver(to).onERC721Received(msg.sender, address(0), id, data) + == IERC721TokenReceiver.onERC721Received.selector, + "UNSAFE_RECIPIENT" + ); + } + + /*////////////////////////////////////////////////////////////// + HELPERS + //////////////////////////////////////////////////////////////*/ + + function _isContract(address _addr) private view returns (bool) { + uint256 codeLength; + + // Assembly required for versions < 0.8.0 to check extcodesize. + assembly { + codeLength := extcodesize(_addr) + } + + return codeLength > 0; + } +} + +interface IERC721TokenReceiver { + function onERC721Received(address, address, uint256, bytes calldata) external returns (bytes4); +} diff --git a/docs/crypto/zkCTF/day1/Ethereal/mint-contracts/lib/forge-std/src/safeconsole.sol b/docs/crypto/zkCTF/day1/Ethereal/mint-contracts/lib/forge-std/src/safeconsole.sol new file mode 100644 index 0000000..5714d09 --- /dev/null +++ b/docs/crypto/zkCTF/day1/Ethereal/mint-contracts/lib/forge-std/src/safeconsole.sol @@ -0,0 +1,13248 @@ +// SPDX-License-Identifier: MIT +pragma solidity >=0.6.2 <0.9.0; + +/// @author philogy +/// @dev Code generated automatically by script. +library safeconsole { + uint256 constant CONSOLE_ADDR = 0x000000000000000000000000000000000000000000636F6e736F6c652e6c6f67; + + // Credit to [0age](https://twitter.com/z0age/status/1654922202930888704) and [0xdapper](https://github.com/foundry-rs/forge-std/pull/374) + // for the view-to-pure log trick. + function _sendLogPayload(uint256 offset, uint256 size) private pure { + function(uint256, uint256) internal view fnIn = _sendLogPayloadView; + function(uint256, uint256) internal pure pureSendLogPayload; + assembly { + pureSendLogPayload := fnIn + } + pureSendLogPayload(offset, size); + } + + function _sendLogPayloadView(uint256 offset, uint256 size) private view { + assembly { + pop(staticcall(gas(), CONSOLE_ADDR, offset, size, 0x0, 0x0)) + } + } + + function _memcopy(uint256 fromOffset, uint256 toOffset, uint256 length) private pure { + function(uint256, uint256, uint256) internal view fnIn = _memcopyView; + function(uint256, uint256, uint256) internal pure pureMemcopy; + assembly { + pureMemcopy := fnIn + } + pureMemcopy(fromOffset, toOffset, length); + } + + function _memcopyView(uint256 fromOffset, uint256 toOffset, uint256 length) private view { + assembly { + pop(staticcall(gas(), 0x4, fromOffset, length, toOffset, length)) + } + } + + function logMemory(uint256 offset, uint256 length) internal pure { + if (offset >= 0x60) { + // Sufficient memory before slice to prepare call header. + bytes32 m0; + bytes32 m1; + bytes32 m2; + assembly { + m0 := mload(sub(offset, 0x60)) + m1 := mload(sub(offset, 0x40)) + m2 := mload(sub(offset, 0x20)) + // Selector of `logBytes(bytes)`. + mstore(sub(offset, 0x60), 0xe17bf956) + mstore(sub(offset, 0x40), 0x20) + mstore(sub(offset, 0x20), length) + } + _sendLogPayload(offset - 0x44, length + 0x44); + assembly { + mstore(sub(offset, 0x60), m0) + mstore(sub(offset, 0x40), m1) + mstore(sub(offset, 0x20), m2) + } + } else { + // Insufficient space, so copy slice forward, add header and reverse. + bytes32 m0; + bytes32 m1; + bytes32 m2; + uint256 endOffset = offset + length; + assembly { + m0 := mload(add(endOffset, 0x00)) + m1 := mload(add(endOffset, 0x20)) + m2 := mload(add(endOffset, 0x40)) + } + _memcopy(offset, offset + 0x60, length); + assembly { + // Selector of `logBytes(bytes)`. + mstore(add(offset, 0x00), 0xe17bf956) + mstore(add(offset, 0x20), 0x20) + mstore(add(offset, 0x40), length) + } + _sendLogPayload(offset + 0x1c, length + 0x44); + _memcopy(offset + 0x60, offset, length); + assembly { + mstore(add(endOffset, 0x00), m0) + mstore(add(endOffset, 0x20), m1) + mstore(add(endOffset, 0x40), m2) + } + } + } + + function log(address p0) internal pure { + bytes32 m0; + bytes32 m1; + assembly { + m0 := mload(0x00) + m1 := mload(0x20) + // Selector of `log(address)`. + mstore(0x00, 0x2c2ecbc2) + mstore(0x20, p0) + } + _sendLogPayload(0x1c, 0x24); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + } + } + + function log(bool p0) internal pure { + bytes32 m0; + bytes32 m1; + assembly { + m0 := mload(0x00) + m1 := mload(0x20) + // Selector of `log(bool)`. + mstore(0x00, 0x32458eed) + mstore(0x20, p0) + } + _sendLogPayload(0x1c, 0x24); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + } + } + + function log(uint256 p0) internal pure { + bytes32 m0; + bytes32 m1; + assembly { + m0 := mload(0x00) + m1 := mload(0x20) + // Selector of `log(uint256)`. + mstore(0x00, 0xf82c50f1) + mstore(0x20, p0) + } + _sendLogPayload(0x1c, 0x24); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + } + } + + function log(bytes32 p0) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + assembly { + function writeString(pos, w) { + let length := 0 + for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } + mstore(pos, length) + let shift := sub(256, shl(3, length)) + mstore(add(pos, 0x20), shl(shift, shr(shift, w))) + } + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + // Selector of `log(string)`. + mstore(0x00, 0x41304fac) + mstore(0x20, 0x20) + writeString(0x40, p0) + } + _sendLogPayload(0x1c, 0x64); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + } + } + + function log(address p0, address p1) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + assembly { + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + // Selector of `log(address,address)`. + mstore(0x00, 0xdaf0d4aa) + mstore(0x20, p0) + mstore(0x40, p1) + } + _sendLogPayload(0x1c, 0x44); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + } + } + + function log(address p0, bool p1) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + assembly { + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + // Selector of `log(address,bool)`. + mstore(0x00, 0x75b605d3) + mstore(0x20, p0) + mstore(0x40, p1) + } + _sendLogPayload(0x1c, 0x44); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + } + } + + function log(address p0, uint256 p1) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + assembly { + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + // Selector of `log(address,uint256)`. + mstore(0x00, 0x8309e8a8) + mstore(0x20, p0) + mstore(0x40, p1) + } + _sendLogPayload(0x1c, 0x44); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + } + } + + function log(address p0, bytes32 p1) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + assembly { + function writeString(pos, w) { + let length := 0 + for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } + mstore(pos, length) + let shift := sub(256, shl(3, length)) + mstore(add(pos, 0x20), shl(shift, shr(shift, w))) + } + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + // Selector of `log(address,string)`. + mstore(0x00, 0x759f86bb) + mstore(0x20, p0) + mstore(0x40, 0x40) + writeString(0x60, p1) + } + _sendLogPayload(0x1c, 0x84); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + } + } + + function log(bool p0, address p1) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + assembly { + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + // Selector of `log(bool,address)`. + mstore(0x00, 0x853c4849) + mstore(0x20, p0) + mstore(0x40, p1) + } + _sendLogPayload(0x1c, 0x44); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + } + } + + function log(bool p0, bool p1) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + assembly { + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + // Selector of `log(bool,bool)`. + mstore(0x00, 0x2a110e83) + mstore(0x20, p0) + mstore(0x40, p1) + } + _sendLogPayload(0x1c, 0x44); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + } + } + + function log(bool p0, uint256 p1) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + assembly { + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + // Selector of `log(bool,uint256)`. + mstore(0x00, 0x399174d3) + mstore(0x20, p0) + mstore(0x40, p1) + } + _sendLogPayload(0x1c, 0x44); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + } + } + + function log(bool p0, bytes32 p1) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + assembly { + function writeString(pos, w) { + let length := 0 + for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } + mstore(pos, length) + let shift := sub(256, shl(3, length)) + mstore(add(pos, 0x20), shl(shift, shr(shift, w))) + } + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + // Selector of `log(bool,string)`. + mstore(0x00, 0x8feac525) + mstore(0x20, p0) + mstore(0x40, 0x40) + writeString(0x60, p1) + } + _sendLogPayload(0x1c, 0x84); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + } + } + + function log(uint256 p0, address p1) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + assembly { + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + // Selector of `log(uint256,address)`. + mstore(0x00, 0x69276c86) + mstore(0x20, p0) + mstore(0x40, p1) + } + _sendLogPayload(0x1c, 0x44); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + } + } + + function log(uint256 p0, bool p1) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + assembly { + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + // Selector of `log(uint256,bool)`. + mstore(0x00, 0x1c9d7eb3) + mstore(0x20, p0) + mstore(0x40, p1) + } + _sendLogPayload(0x1c, 0x44); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + } + } + + function log(uint256 p0, uint256 p1) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + assembly { + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + // Selector of `log(uint256,uint256)`. + mstore(0x00, 0xf666715a) + mstore(0x20, p0) + mstore(0x40, p1) + } + _sendLogPayload(0x1c, 0x44); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + } + } + + function log(uint256 p0, bytes32 p1) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + assembly { + function writeString(pos, w) { + let length := 0 + for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } + mstore(pos, length) + let shift := sub(256, shl(3, length)) + mstore(add(pos, 0x20), shl(shift, shr(shift, w))) + } + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + // Selector of `log(uint256,string)`. + mstore(0x00, 0x643fd0df) + mstore(0x20, p0) + mstore(0x40, 0x40) + writeString(0x60, p1) + } + _sendLogPayload(0x1c, 0x84); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + } + } + + function log(bytes32 p0, address p1) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + assembly { + function writeString(pos, w) { + let length := 0 + for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } + mstore(pos, length) + let shift := sub(256, shl(3, length)) + mstore(add(pos, 0x20), shl(shift, shr(shift, w))) + } + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + // Selector of `log(string,address)`. + mstore(0x00, 0x319af333) + mstore(0x20, 0x40) + mstore(0x40, p1) + writeString(0x60, p0) + } + _sendLogPayload(0x1c, 0x84); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + } + } + + function log(bytes32 p0, bool p1) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + assembly { + function writeString(pos, w) { + let length := 0 + for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } + mstore(pos, length) + let shift := sub(256, shl(3, length)) + mstore(add(pos, 0x20), shl(shift, shr(shift, w))) + } + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + // Selector of `log(string,bool)`. + mstore(0x00, 0xc3b55635) + mstore(0x20, 0x40) + mstore(0x40, p1) + writeString(0x60, p0) + } + _sendLogPayload(0x1c, 0x84); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + } + } + + function log(bytes32 p0, uint256 p1) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + assembly { + function writeString(pos, w) { + let length := 0 + for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } + mstore(pos, length) + let shift := sub(256, shl(3, length)) + mstore(add(pos, 0x20), shl(shift, shr(shift, w))) + } + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + // Selector of `log(string,uint256)`. + mstore(0x00, 0xb60e72cc) + mstore(0x20, 0x40) + mstore(0x40, p1) + writeString(0x60, p0) + } + _sendLogPayload(0x1c, 0x84); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + } + } + + function log(bytes32 p0, bytes32 p1) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + bytes32 m5; + bytes32 m6; + assembly { + function writeString(pos, w) { + let length := 0 + for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } + mstore(pos, length) + let shift := sub(256, shl(3, length)) + mstore(add(pos, 0x20), shl(shift, shr(shift, w))) + } + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + m5 := mload(0xa0) + m6 := mload(0xc0) + // Selector of `log(string,string)`. + mstore(0x00, 0x4b5c4277) + mstore(0x20, 0x40) + mstore(0x40, 0x80) + writeString(0x60, p0) + writeString(0xa0, p1) + } + _sendLogPayload(0x1c, 0xc4); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + mstore(0xa0, m5) + mstore(0xc0, m6) + } + } + + function log(address p0, address p1, address p2) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + assembly { + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + // Selector of `log(address,address,address)`. + mstore(0x00, 0x018c84c2) + mstore(0x20, p0) + mstore(0x40, p1) + mstore(0x60, p2) + } + _sendLogPayload(0x1c, 0x64); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + } + } + + function log(address p0, address p1, bool p2) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + assembly { + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + // Selector of `log(address,address,bool)`. + mstore(0x00, 0xf2a66286) + mstore(0x20, p0) + mstore(0x40, p1) + mstore(0x60, p2) + } + _sendLogPayload(0x1c, 0x64); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + } + } + + function log(address p0, address p1, uint256 p2) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + assembly { + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + // Selector of `log(address,address,uint256)`. + mstore(0x00, 0x17fe6185) + mstore(0x20, p0) + mstore(0x40, p1) + mstore(0x60, p2) + } + _sendLogPayload(0x1c, 0x64); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + } + } + + function log(address p0, address p1, bytes32 p2) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + bytes32 m5; + assembly { + function writeString(pos, w) { + let length := 0 + for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } + mstore(pos, length) + let shift := sub(256, shl(3, length)) + mstore(add(pos, 0x20), shl(shift, shr(shift, w))) + } + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + m5 := mload(0xa0) + // Selector of `log(address,address,string)`. + mstore(0x00, 0x007150be) + mstore(0x20, p0) + mstore(0x40, p1) + mstore(0x60, 0x60) + writeString(0x80, p2) + } + _sendLogPayload(0x1c, 0xa4); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + mstore(0xa0, m5) + } + } + + function log(address p0, bool p1, address p2) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + assembly { + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + // Selector of `log(address,bool,address)`. + mstore(0x00, 0xf11699ed) + mstore(0x20, p0) + mstore(0x40, p1) + mstore(0x60, p2) + } + _sendLogPayload(0x1c, 0x64); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + } + } + + function log(address p0, bool p1, bool p2) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + assembly { + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + // Selector of `log(address,bool,bool)`. + mstore(0x00, 0xeb830c92) + mstore(0x20, p0) + mstore(0x40, p1) + mstore(0x60, p2) + } + _sendLogPayload(0x1c, 0x64); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + } + } + + function log(address p0, bool p1, uint256 p2) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + assembly { + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + // Selector of `log(address,bool,uint256)`. + mstore(0x00, 0x9c4f99fb) + mstore(0x20, p0) + mstore(0x40, p1) + mstore(0x60, p2) + } + _sendLogPayload(0x1c, 0x64); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + } + } + + function log(address p0, bool p1, bytes32 p2) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + bytes32 m5; + assembly { + function writeString(pos, w) { + let length := 0 + for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } + mstore(pos, length) + let shift := sub(256, shl(3, length)) + mstore(add(pos, 0x20), shl(shift, shr(shift, w))) + } + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + m5 := mload(0xa0) + // Selector of `log(address,bool,string)`. + mstore(0x00, 0x212255cc) + mstore(0x20, p0) + mstore(0x40, p1) + mstore(0x60, 0x60) + writeString(0x80, p2) + } + _sendLogPayload(0x1c, 0xa4); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + mstore(0xa0, m5) + } + } + + function log(address p0, uint256 p1, address p2) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + assembly { + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + // Selector of `log(address,uint256,address)`. + mstore(0x00, 0x7bc0d848) + mstore(0x20, p0) + mstore(0x40, p1) + mstore(0x60, p2) + } + _sendLogPayload(0x1c, 0x64); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + } + } + + function log(address p0, uint256 p1, bool p2) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + assembly { + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + // Selector of `log(address,uint256,bool)`. + mstore(0x00, 0x678209a8) + mstore(0x20, p0) + mstore(0x40, p1) + mstore(0x60, p2) + } + _sendLogPayload(0x1c, 0x64); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + } + } + + function log(address p0, uint256 p1, uint256 p2) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + assembly { + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + // Selector of `log(address,uint256,uint256)`. + mstore(0x00, 0xb69bcaf6) + mstore(0x20, p0) + mstore(0x40, p1) + mstore(0x60, p2) + } + _sendLogPayload(0x1c, 0x64); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + } + } + + function log(address p0, uint256 p1, bytes32 p2) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + bytes32 m5; + assembly { + function writeString(pos, w) { + let length := 0 + for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } + mstore(pos, length) + let shift := sub(256, shl(3, length)) + mstore(add(pos, 0x20), shl(shift, shr(shift, w))) + } + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + m5 := mload(0xa0) + // Selector of `log(address,uint256,string)`. + mstore(0x00, 0xa1f2e8aa) + mstore(0x20, p0) + mstore(0x40, p1) + mstore(0x60, 0x60) + writeString(0x80, p2) + } + _sendLogPayload(0x1c, 0xa4); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + mstore(0xa0, m5) + } + } + + function log(address p0, bytes32 p1, address p2) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + bytes32 m5; + assembly { + function writeString(pos, w) { + let length := 0 + for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } + mstore(pos, length) + let shift := sub(256, shl(3, length)) + mstore(add(pos, 0x20), shl(shift, shr(shift, w))) + } + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + m5 := mload(0xa0) + // Selector of `log(address,string,address)`. + mstore(0x00, 0xf08744e8) + mstore(0x20, p0) + mstore(0x40, 0x60) + mstore(0x60, p2) + writeString(0x80, p1) + } + _sendLogPayload(0x1c, 0xa4); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + mstore(0xa0, m5) + } + } + + function log(address p0, bytes32 p1, bool p2) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + bytes32 m5; + assembly { + function writeString(pos, w) { + let length := 0 + for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } + mstore(pos, length) + let shift := sub(256, shl(3, length)) + mstore(add(pos, 0x20), shl(shift, shr(shift, w))) + } + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + m5 := mload(0xa0) + // Selector of `log(address,string,bool)`. + mstore(0x00, 0xcf020fb1) + mstore(0x20, p0) + mstore(0x40, 0x60) + mstore(0x60, p2) + writeString(0x80, p1) + } + _sendLogPayload(0x1c, 0xa4); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + mstore(0xa0, m5) + } + } + + function log(address p0, bytes32 p1, uint256 p2) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + bytes32 m5; + assembly { + function writeString(pos, w) { + let length := 0 + for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } + mstore(pos, length) + let shift := sub(256, shl(3, length)) + mstore(add(pos, 0x20), shl(shift, shr(shift, w))) + } + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + m5 := mload(0xa0) + // Selector of `log(address,string,uint256)`. + mstore(0x00, 0x67dd6ff1) + mstore(0x20, p0) + mstore(0x40, 0x60) + mstore(0x60, p2) + writeString(0x80, p1) + } + _sendLogPayload(0x1c, 0xa4); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + mstore(0xa0, m5) + } + } + + function log(address p0, bytes32 p1, bytes32 p2) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + bytes32 m5; + bytes32 m6; + bytes32 m7; + assembly { + function writeString(pos, w) { + let length := 0 + for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } + mstore(pos, length) + let shift := sub(256, shl(3, length)) + mstore(add(pos, 0x20), shl(shift, shr(shift, w))) + } + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + m5 := mload(0xa0) + m6 := mload(0xc0) + m7 := mload(0xe0) + // Selector of `log(address,string,string)`. + mstore(0x00, 0xfb772265) + mstore(0x20, p0) + mstore(0x40, 0x60) + mstore(0x60, 0xa0) + writeString(0x80, p1) + writeString(0xc0, p2) + } + _sendLogPayload(0x1c, 0xe4); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + mstore(0xa0, m5) + mstore(0xc0, m6) + mstore(0xe0, m7) + } + } + + function log(bool p0, address p1, address p2) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + assembly { + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + // Selector of `log(bool,address,address)`. + mstore(0x00, 0xd2763667) + mstore(0x20, p0) + mstore(0x40, p1) + mstore(0x60, p2) + } + _sendLogPayload(0x1c, 0x64); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + } + } + + function log(bool p0, address p1, bool p2) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + assembly { + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + // Selector of `log(bool,address,bool)`. + mstore(0x00, 0x18c9c746) + mstore(0x20, p0) + mstore(0x40, p1) + mstore(0x60, p2) + } + _sendLogPayload(0x1c, 0x64); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + } + } + + function log(bool p0, address p1, uint256 p2) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + assembly { + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + // Selector of `log(bool,address,uint256)`. + mstore(0x00, 0x5f7b9afb) + mstore(0x20, p0) + mstore(0x40, p1) + mstore(0x60, p2) + } + _sendLogPayload(0x1c, 0x64); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + } + } + + function log(bool p0, address p1, bytes32 p2) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + bytes32 m5; + assembly { + function writeString(pos, w) { + let length := 0 + for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } + mstore(pos, length) + let shift := sub(256, shl(3, length)) + mstore(add(pos, 0x20), shl(shift, shr(shift, w))) + } + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + m5 := mload(0xa0) + // Selector of `log(bool,address,string)`. + mstore(0x00, 0xde9a9270) + mstore(0x20, p0) + mstore(0x40, p1) + mstore(0x60, 0x60) + writeString(0x80, p2) + } + _sendLogPayload(0x1c, 0xa4); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + mstore(0xa0, m5) + } + } + + function log(bool p0, bool p1, address p2) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + assembly { + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + // Selector of `log(bool,bool,address)`. + mstore(0x00, 0x1078f68d) + mstore(0x20, p0) + mstore(0x40, p1) + mstore(0x60, p2) + } + _sendLogPayload(0x1c, 0x64); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + } + } + + function log(bool p0, bool p1, bool p2) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + assembly { + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + // Selector of `log(bool,bool,bool)`. + mstore(0x00, 0x50709698) + mstore(0x20, p0) + mstore(0x40, p1) + mstore(0x60, p2) + } + _sendLogPayload(0x1c, 0x64); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + } + } + + function log(bool p0, bool p1, uint256 p2) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + assembly { + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + // Selector of `log(bool,bool,uint256)`. + mstore(0x00, 0x12f21602) + mstore(0x20, p0) + mstore(0x40, p1) + mstore(0x60, p2) + } + _sendLogPayload(0x1c, 0x64); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + } + } + + function log(bool p0, bool p1, bytes32 p2) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + bytes32 m5; + assembly { + function writeString(pos, w) { + let length := 0 + for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } + mstore(pos, length) + let shift := sub(256, shl(3, length)) + mstore(add(pos, 0x20), shl(shift, shr(shift, w))) + } + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + m5 := mload(0xa0) + // Selector of `log(bool,bool,string)`. + mstore(0x00, 0x2555fa46) + mstore(0x20, p0) + mstore(0x40, p1) + mstore(0x60, 0x60) + writeString(0x80, p2) + } + _sendLogPayload(0x1c, 0xa4); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + mstore(0xa0, m5) + } + } + + function log(bool p0, uint256 p1, address p2) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + assembly { + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + // Selector of `log(bool,uint256,address)`. + mstore(0x00, 0x088ef9d2) + mstore(0x20, p0) + mstore(0x40, p1) + mstore(0x60, p2) + } + _sendLogPayload(0x1c, 0x64); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + } + } + + function log(bool p0, uint256 p1, bool p2) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + assembly { + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + // Selector of `log(bool,uint256,bool)`. + mstore(0x00, 0xe8defba9) + mstore(0x20, p0) + mstore(0x40, p1) + mstore(0x60, p2) + } + _sendLogPayload(0x1c, 0x64); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + } + } + + function log(bool p0, uint256 p1, uint256 p2) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + assembly { + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + // Selector of `log(bool,uint256,uint256)`. + mstore(0x00, 0x37103367) + mstore(0x20, p0) + mstore(0x40, p1) + mstore(0x60, p2) + } + _sendLogPayload(0x1c, 0x64); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + } + } + + function log(bool p0, uint256 p1, bytes32 p2) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + bytes32 m5; + assembly { + function writeString(pos, w) { + let length := 0 + for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } + mstore(pos, length) + let shift := sub(256, shl(3, length)) + mstore(add(pos, 0x20), shl(shift, shr(shift, w))) + } + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + m5 := mload(0xa0) + // Selector of `log(bool,uint256,string)`. + mstore(0x00, 0xc3fc3970) + mstore(0x20, p0) + mstore(0x40, p1) + mstore(0x60, 0x60) + writeString(0x80, p2) + } + _sendLogPayload(0x1c, 0xa4); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + mstore(0xa0, m5) + } + } + + function log(bool p0, bytes32 p1, address p2) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + bytes32 m5; + assembly { + function writeString(pos, w) { + let length := 0 + for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } + mstore(pos, length) + let shift := sub(256, shl(3, length)) + mstore(add(pos, 0x20), shl(shift, shr(shift, w))) + } + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + m5 := mload(0xa0) + // Selector of `log(bool,string,address)`. + mstore(0x00, 0x9591b953) + mstore(0x20, p0) + mstore(0x40, 0x60) + mstore(0x60, p2) + writeString(0x80, p1) + } + _sendLogPayload(0x1c, 0xa4); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + mstore(0xa0, m5) + } + } + + function log(bool p0, bytes32 p1, bool p2) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + bytes32 m5; + assembly { + function writeString(pos, w) { + let length := 0 + for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } + mstore(pos, length) + let shift := sub(256, shl(3, length)) + mstore(add(pos, 0x20), shl(shift, shr(shift, w))) + } + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + m5 := mload(0xa0) + // Selector of `log(bool,string,bool)`. + mstore(0x00, 0xdbb4c247) + mstore(0x20, p0) + mstore(0x40, 0x60) + mstore(0x60, p2) + writeString(0x80, p1) + } + _sendLogPayload(0x1c, 0xa4); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + mstore(0xa0, m5) + } + } + + function log(bool p0, bytes32 p1, uint256 p2) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + bytes32 m5; + assembly { + function writeString(pos, w) { + let length := 0 + for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } + mstore(pos, length) + let shift := sub(256, shl(3, length)) + mstore(add(pos, 0x20), shl(shift, shr(shift, w))) + } + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + m5 := mload(0xa0) + // Selector of `log(bool,string,uint256)`. + mstore(0x00, 0x1093ee11) + mstore(0x20, p0) + mstore(0x40, 0x60) + mstore(0x60, p2) + writeString(0x80, p1) + } + _sendLogPayload(0x1c, 0xa4); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + mstore(0xa0, m5) + } + } + + function log(bool p0, bytes32 p1, bytes32 p2) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + bytes32 m5; + bytes32 m6; + bytes32 m7; + assembly { + function writeString(pos, w) { + let length := 0 + for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } + mstore(pos, length) + let shift := sub(256, shl(3, length)) + mstore(add(pos, 0x20), shl(shift, shr(shift, w))) + } + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + m5 := mload(0xa0) + m6 := mload(0xc0) + m7 := mload(0xe0) + // Selector of `log(bool,string,string)`. + mstore(0x00, 0xb076847f) + mstore(0x20, p0) + mstore(0x40, 0x60) + mstore(0x60, 0xa0) + writeString(0x80, p1) + writeString(0xc0, p2) + } + _sendLogPayload(0x1c, 0xe4); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + mstore(0xa0, m5) + mstore(0xc0, m6) + mstore(0xe0, m7) + } + } + + function log(uint256 p0, address p1, address p2) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + assembly { + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + // Selector of `log(uint256,address,address)`. + mstore(0x00, 0xbcfd9be0) + mstore(0x20, p0) + mstore(0x40, p1) + mstore(0x60, p2) + } + _sendLogPayload(0x1c, 0x64); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + } + } + + function log(uint256 p0, address p1, bool p2) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + assembly { + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + // Selector of `log(uint256,address,bool)`. + mstore(0x00, 0x9b6ec042) + mstore(0x20, p0) + mstore(0x40, p1) + mstore(0x60, p2) + } + _sendLogPayload(0x1c, 0x64); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + } + } + + function log(uint256 p0, address p1, uint256 p2) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + assembly { + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + // Selector of `log(uint256,address,uint256)`. + mstore(0x00, 0x5a9b5ed5) + mstore(0x20, p0) + mstore(0x40, p1) + mstore(0x60, p2) + } + _sendLogPayload(0x1c, 0x64); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + } + } + + function log(uint256 p0, address p1, bytes32 p2) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + bytes32 m5; + assembly { + function writeString(pos, w) { + let length := 0 + for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } + mstore(pos, length) + let shift := sub(256, shl(3, length)) + mstore(add(pos, 0x20), shl(shift, shr(shift, w))) + } + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + m5 := mload(0xa0) + // Selector of `log(uint256,address,string)`. + mstore(0x00, 0x63cb41f9) + mstore(0x20, p0) + mstore(0x40, p1) + mstore(0x60, 0x60) + writeString(0x80, p2) + } + _sendLogPayload(0x1c, 0xa4); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + mstore(0xa0, m5) + } + } + + function log(uint256 p0, bool p1, address p2) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + assembly { + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + // Selector of `log(uint256,bool,address)`. + mstore(0x00, 0x35085f7b) + mstore(0x20, p0) + mstore(0x40, p1) + mstore(0x60, p2) + } + _sendLogPayload(0x1c, 0x64); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + } + } + + function log(uint256 p0, bool p1, bool p2) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + assembly { + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + // Selector of `log(uint256,bool,bool)`. + mstore(0x00, 0x20718650) + mstore(0x20, p0) + mstore(0x40, p1) + mstore(0x60, p2) + } + _sendLogPayload(0x1c, 0x64); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + } + } + + function log(uint256 p0, bool p1, uint256 p2) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + assembly { + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + // Selector of `log(uint256,bool,uint256)`. + mstore(0x00, 0x20098014) + mstore(0x20, p0) + mstore(0x40, p1) + mstore(0x60, p2) + } + _sendLogPayload(0x1c, 0x64); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + } + } + + function log(uint256 p0, bool p1, bytes32 p2) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + bytes32 m5; + assembly { + function writeString(pos, w) { + let length := 0 + for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } + mstore(pos, length) + let shift := sub(256, shl(3, length)) + mstore(add(pos, 0x20), shl(shift, shr(shift, w))) + } + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + m5 := mload(0xa0) + // Selector of `log(uint256,bool,string)`. + mstore(0x00, 0x85775021) + mstore(0x20, p0) + mstore(0x40, p1) + mstore(0x60, 0x60) + writeString(0x80, p2) + } + _sendLogPayload(0x1c, 0xa4); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + mstore(0xa0, m5) + } + } + + function log(uint256 p0, uint256 p1, address p2) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + assembly { + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + // Selector of `log(uint256,uint256,address)`. + mstore(0x00, 0x5c96b331) + mstore(0x20, p0) + mstore(0x40, p1) + mstore(0x60, p2) + } + _sendLogPayload(0x1c, 0x64); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + } + } + + function log(uint256 p0, uint256 p1, bool p2) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + assembly { + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + // Selector of `log(uint256,uint256,bool)`. + mstore(0x00, 0x4766da72) + mstore(0x20, p0) + mstore(0x40, p1) + mstore(0x60, p2) + } + _sendLogPayload(0x1c, 0x64); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + } + } + + function log(uint256 p0, uint256 p1, uint256 p2) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + assembly { + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + // Selector of `log(uint256,uint256,uint256)`. + mstore(0x00, 0xd1ed7a3c) + mstore(0x20, p0) + mstore(0x40, p1) + mstore(0x60, p2) + } + _sendLogPayload(0x1c, 0x64); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + } + } + + function log(uint256 p0, uint256 p1, bytes32 p2) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + bytes32 m5; + assembly { + function writeString(pos, w) { + let length := 0 + for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } + mstore(pos, length) + let shift := sub(256, shl(3, length)) + mstore(add(pos, 0x20), shl(shift, shr(shift, w))) + } + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + m5 := mload(0xa0) + // Selector of `log(uint256,uint256,string)`. + mstore(0x00, 0x71d04af2) + mstore(0x20, p0) + mstore(0x40, p1) + mstore(0x60, 0x60) + writeString(0x80, p2) + } + _sendLogPayload(0x1c, 0xa4); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + mstore(0xa0, m5) + } + } + + function log(uint256 p0, bytes32 p1, address p2) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + bytes32 m5; + assembly { + function writeString(pos, w) { + let length := 0 + for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } + mstore(pos, length) + let shift := sub(256, shl(3, length)) + mstore(add(pos, 0x20), shl(shift, shr(shift, w))) + } + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + m5 := mload(0xa0) + // Selector of `log(uint256,string,address)`. + mstore(0x00, 0x7afac959) + mstore(0x20, p0) + mstore(0x40, 0x60) + mstore(0x60, p2) + writeString(0x80, p1) + } + _sendLogPayload(0x1c, 0xa4); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + mstore(0xa0, m5) + } + } + + function log(uint256 p0, bytes32 p1, bool p2) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + bytes32 m5; + assembly { + function writeString(pos, w) { + let length := 0 + for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } + mstore(pos, length) + let shift := sub(256, shl(3, length)) + mstore(add(pos, 0x20), shl(shift, shr(shift, w))) + } + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + m5 := mload(0xa0) + // Selector of `log(uint256,string,bool)`. + mstore(0x00, 0x4ceda75a) + mstore(0x20, p0) + mstore(0x40, 0x60) + mstore(0x60, p2) + writeString(0x80, p1) + } + _sendLogPayload(0x1c, 0xa4); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + mstore(0xa0, m5) + } + } + + function log(uint256 p0, bytes32 p1, uint256 p2) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + bytes32 m5; + assembly { + function writeString(pos, w) { + let length := 0 + for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } + mstore(pos, length) + let shift := sub(256, shl(3, length)) + mstore(add(pos, 0x20), shl(shift, shr(shift, w))) + } + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + m5 := mload(0xa0) + // Selector of `log(uint256,string,uint256)`. + mstore(0x00, 0x37aa7d4c) + mstore(0x20, p0) + mstore(0x40, 0x60) + mstore(0x60, p2) + writeString(0x80, p1) + } + _sendLogPayload(0x1c, 0xa4); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + mstore(0xa0, m5) + } + } + + function log(uint256 p0, bytes32 p1, bytes32 p2) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + bytes32 m5; + bytes32 m6; + bytes32 m7; + assembly { + function writeString(pos, w) { + let length := 0 + for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } + mstore(pos, length) + let shift := sub(256, shl(3, length)) + mstore(add(pos, 0x20), shl(shift, shr(shift, w))) + } + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + m5 := mload(0xa0) + m6 := mload(0xc0) + m7 := mload(0xe0) + // Selector of `log(uint256,string,string)`. + mstore(0x00, 0xb115611f) + mstore(0x20, p0) + mstore(0x40, 0x60) + mstore(0x60, 0xa0) + writeString(0x80, p1) + writeString(0xc0, p2) + } + _sendLogPayload(0x1c, 0xe4); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + mstore(0xa0, m5) + mstore(0xc0, m6) + mstore(0xe0, m7) + } + } + + function log(bytes32 p0, address p1, address p2) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + bytes32 m5; + assembly { + function writeString(pos, w) { + let length := 0 + for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } + mstore(pos, length) + let shift := sub(256, shl(3, length)) + mstore(add(pos, 0x20), shl(shift, shr(shift, w))) + } + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + m5 := mload(0xa0) + // Selector of `log(string,address,address)`. + mstore(0x00, 0xfcec75e0) + mstore(0x20, 0x60) + mstore(0x40, p1) + mstore(0x60, p2) + writeString(0x80, p0) + } + _sendLogPayload(0x1c, 0xa4); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + mstore(0xa0, m5) + } + } + + function log(bytes32 p0, address p1, bool p2) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + bytes32 m5; + assembly { + function writeString(pos, w) { + let length := 0 + for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } + mstore(pos, length) + let shift := sub(256, shl(3, length)) + mstore(add(pos, 0x20), shl(shift, shr(shift, w))) + } + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + m5 := mload(0xa0) + // Selector of `log(string,address,bool)`. + mstore(0x00, 0xc91d5ed4) + mstore(0x20, 0x60) + mstore(0x40, p1) + mstore(0x60, p2) + writeString(0x80, p0) + } + _sendLogPayload(0x1c, 0xa4); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + mstore(0xa0, m5) + } + } + + function log(bytes32 p0, address p1, uint256 p2) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + bytes32 m5; + assembly { + function writeString(pos, w) { + let length := 0 + for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } + mstore(pos, length) + let shift := sub(256, shl(3, length)) + mstore(add(pos, 0x20), shl(shift, shr(shift, w))) + } + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + m5 := mload(0xa0) + // Selector of `log(string,address,uint256)`. + mstore(0x00, 0x0d26b925) + mstore(0x20, 0x60) + mstore(0x40, p1) + mstore(0x60, p2) + writeString(0x80, p0) + } + _sendLogPayload(0x1c, 0xa4); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + mstore(0xa0, m5) + } + } + + function log(bytes32 p0, address p1, bytes32 p2) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + bytes32 m5; + bytes32 m6; + bytes32 m7; + assembly { + function writeString(pos, w) { + let length := 0 + for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } + mstore(pos, length) + let shift := sub(256, shl(3, length)) + mstore(add(pos, 0x20), shl(shift, shr(shift, w))) + } + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + m5 := mload(0xa0) + m6 := mload(0xc0) + m7 := mload(0xe0) + // Selector of `log(string,address,string)`. + mstore(0x00, 0xe0e9ad4f) + mstore(0x20, 0x60) + mstore(0x40, p1) + mstore(0x60, 0xa0) + writeString(0x80, p0) + writeString(0xc0, p2) + } + _sendLogPayload(0x1c, 0xe4); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + mstore(0xa0, m5) + mstore(0xc0, m6) + mstore(0xe0, m7) + } + } + + function log(bytes32 p0, bool p1, address p2) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + bytes32 m5; + assembly { + function writeString(pos, w) { + let length := 0 + for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } + mstore(pos, length) + let shift := sub(256, shl(3, length)) + mstore(add(pos, 0x20), shl(shift, shr(shift, w))) + } + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + m5 := mload(0xa0) + // Selector of `log(string,bool,address)`. + mstore(0x00, 0x932bbb38) + mstore(0x20, 0x60) + mstore(0x40, p1) + mstore(0x60, p2) + writeString(0x80, p0) + } + _sendLogPayload(0x1c, 0xa4); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + mstore(0xa0, m5) + } + } + + function log(bytes32 p0, bool p1, bool p2) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + bytes32 m5; + assembly { + function writeString(pos, w) { + let length := 0 + for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } + mstore(pos, length) + let shift := sub(256, shl(3, length)) + mstore(add(pos, 0x20), shl(shift, shr(shift, w))) + } + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + m5 := mload(0xa0) + // Selector of `log(string,bool,bool)`. + mstore(0x00, 0x850b7ad6) + mstore(0x20, 0x60) + mstore(0x40, p1) + mstore(0x60, p2) + writeString(0x80, p0) + } + _sendLogPayload(0x1c, 0xa4); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + mstore(0xa0, m5) + } + } + + function log(bytes32 p0, bool p1, uint256 p2) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + bytes32 m5; + assembly { + function writeString(pos, w) { + let length := 0 + for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } + mstore(pos, length) + let shift := sub(256, shl(3, length)) + mstore(add(pos, 0x20), shl(shift, shr(shift, w))) + } + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + m5 := mload(0xa0) + // Selector of `log(string,bool,uint256)`. + mstore(0x00, 0xc95958d6) + mstore(0x20, 0x60) + mstore(0x40, p1) + mstore(0x60, p2) + writeString(0x80, p0) + } + _sendLogPayload(0x1c, 0xa4); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + mstore(0xa0, m5) + } + } + + function log(bytes32 p0, bool p1, bytes32 p2) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + bytes32 m5; + bytes32 m6; + bytes32 m7; + assembly { + function writeString(pos, w) { + let length := 0 + for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } + mstore(pos, length) + let shift := sub(256, shl(3, length)) + mstore(add(pos, 0x20), shl(shift, shr(shift, w))) + } + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + m5 := mload(0xa0) + m6 := mload(0xc0) + m7 := mload(0xe0) + // Selector of `log(string,bool,string)`. + mstore(0x00, 0xe298f47d) + mstore(0x20, 0x60) + mstore(0x40, p1) + mstore(0x60, 0xa0) + writeString(0x80, p0) + writeString(0xc0, p2) + } + _sendLogPayload(0x1c, 0xe4); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + mstore(0xa0, m5) + mstore(0xc0, m6) + mstore(0xe0, m7) + } + } + + function log(bytes32 p0, uint256 p1, address p2) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + bytes32 m5; + assembly { + function writeString(pos, w) { + let length := 0 + for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } + mstore(pos, length) + let shift := sub(256, shl(3, length)) + mstore(add(pos, 0x20), shl(shift, shr(shift, w))) + } + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + m5 := mload(0xa0) + // Selector of `log(string,uint256,address)`. + mstore(0x00, 0x1c7ec448) + mstore(0x20, 0x60) + mstore(0x40, p1) + mstore(0x60, p2) + writeString(0x80, p0) + } + _sendLogPayload(0x1c, 0xa4); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + mstore(0xa0, m5) + } + } + + function log(bytes32 p0, uint256 p1, bool p2) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + bytes32 m5; + assembly { + function writeString(pos, w) { + let length := 0 + for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } + mstore(pos, length) + let shift := sub(256, shl(3, length)) + mstore(add(pos, 0x20), shl(shift, shr(shift, w))) + } + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + m5 := mload(0xa0) + // Selector of `log(string,uint256,bool)`. + mstore(0x00, 0xca7733b1) + mstore(0x20, 0x60) + mstore(0x40, p1) + mstore(0x60, p2) + writeString(0x80, p0) + } + _sendLogPayload(0x1c, 0xa4); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + mstore(0xa0, m5) + } + } + + function log(bytes32 p0, uint256 p1, uint256 p2) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + bytes32 m5; + assembly { + function writeString(pos, w) { + let length := 0 + for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } + mstore(pos, length) + let shift := sub(256, shl(3, length)) + mstore(add(pos, 0x20), shl(shift, shr(shift, w))) + } + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + m5 := mload(0xa0) + // Selector of `log(string,uint256,uint256)`. + mstore(0x00, 0xca47c4eb) + mstore(0x20, 0x60) + mstore(0x40, p1) + mstore(0x60, p2) + writeString(0x80, p0) + } + _sendLogPayload(0x1c, 0xa4); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + mstore(0xa0, m5) + } + } + + function log(bytes32 p0, uint256 p1, bytes32 p2) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + bytes32 m5; + bytes32 m6; + bytes32 m7; + assembly { + function writeString(pos, w) { + let length := 0 + for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } + mstore(pos, length) + let shift := sub(256, shl(3, length)) + mstore(add(pos, 0x20), shl(shift, shr(shift, w))) + } + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + m5 := mload(0xa0) + m6 := mload(0xc0) + m7 := mload(0xe0) + // Selector of `log(string,uint256,string)`. + mstore(0x00, 0x5970e089) + mstore(0x20, 0x60) + mstore(0x40, p1) + mstore(0x60, 0xa0) + writeString(0x80, p0) + writeString(0xc0, p2) + } + _sendLogPayload(0x1c, 0xe4); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + mstore(0xa0, m5) + mstore(0xc0, m6) + mstore(0xe0, m7) + } + } + + function log(bytes32 p0, bytes32 p1, address p2) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + bytes32 m5; + bytes32 m6; + bytes32 m7; + assembly { + function writeString(pos, w) { + let length := 0 + for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } + mstore(pos, length) + let shift := sub(256, shl(3, length)) + mstore(add(pos, 0x20), shl(shift, shr(shift, w))) + } + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + m5 := mload(0xa0) + m6 := mload(0xc0) + m7 := mload(0xe0) + // Selector of `log(string,string,address)`. + mstore(0x00, 0x95ed0195) + mstore(0x20, 0x60) + mstore(0x40, 0xa0) + mstore(0x60, p2) + writeString(0x80, p0) + writeString(0xc0, p1) + } + _sendLogPayload(0x1c, 0xe4); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + mstore(0xa0, m5) + mstore(0xc0, m6) + mstore(0xe0, m7) + } + } + + function log(bytes32 p0, bytes32 p1, bool p2) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + bytes32 m5; + bytes32 m6; + bytes32 m7; + assembly { + function writeString(pos, w) { + let length := 0 + for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } + mstore(pos, length) + let shift := sub(256, shl(3, length)) + mstore(add(pos, 0x20), shl(shift, shr(shift, w))) + } + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + m5 := mload(0xa0) + m6 := mload(0xc0) + m7 := mload(0xe0) + // Selector of `log(string,string,bool)`. + mstore(0x00, 0xb0e0f9b5) + mstore(0x20, 0x60) + mstore(0x40, 0xa0) + mstore(0x60, p2) + writeString(0x80, p0) + writeString(0xc0, p1) + } + _sendLogPayload(0x1c, 0xe4); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + mstore(0xa0, m5) + mstore(0xc0, m6) + mstore(0xe0, m7) + } + } + + function log(bytes32 p0, bytes32 p1, uint256 p2) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + bytes32 m5; + bytes32 m6; + bytes32 m7; + assembly { + function writeString(pos, w) { + let length := 0 + for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } + mstore(pos, length) + let shift := sub(256, shl(3, length)) + mstore(add(pos, 0x20), shl(shift, shr(shift, w))) + } + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + m5 := mload(0xa0) + m6 := mload(0xc0) + m7 := mload(0xe0) + // Selector of `log(string,string,uint256)`. + mstore(0x00, 0x5821efa1) + mstore(0x20, 0x60) + mstore(0x40, 0xa0) + mstore(0x60, p2) + writeString(0x80, p0) + writeString(0xc0, p1) + } + _sendLogPayload(0x1c, 0xe4); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + mstore(0xa0, m5) + mstore(0xc0, m6) + mstore(0xe0, m7) + } + } + + function log(bytes32 p0, bytes32 p1, bytes32 p2) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + bytes32 m5; + bytes32 m6; + bytes32 m7; + bytes32 m8; + bytes32 m9; + assembly { + function writeString(pos, w) { + let length := 0 + for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } + mstore(pos, length) + let shift := sub(256, shl(3, length)) + mstore(add(pos, 0x20), shl(shift, shr(shift, w))) + } + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + m5 := mload(0xa0) + m6 := mload(0xc0) + m7 := mload(0xe0) + m8 := mload(0x100) + m9 := mload(0x120) + // Selector of `log(string,string,string)`. + mstore(0x00, 0x2ced7cef) + mstore(0x20, 0x60) + mstore(0x40, 0xa0) + mstore(0x60, 0xe0) + writeString(0x80, p0) + writeString(0xc0, p1) + writeString(0x100, p2) + } + _sendLogPayload(0x1c, 0x124); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + mstore(0xa0, m5) + mstore(0xc0, m6) + mstore(0xe0, m7) + mstore(0x100, m8) + mstore(0x120, m9) + } + } + + function log(address p0, address p1, address p2, address p3) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + assembly { + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + // Selector of `log(address,address,address,address)`. + mstore(0x00, 0x665bf134) + mstore(0x20, p0) + mstore(0x40, p1) + mstore(0x60, p2) + mstore(0x80, p3) + } + _sendLogPayload(0x1c, 0x84); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + } + } + + function log(address p0, address p1, address p2, bool p3) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + assembly { + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + // Selector of `log(address,address,address,bool)`. + mstore(0x00, 0x0e378994) + mstore(0x20, p0) + mstore(0x40, p1) + mstore(0x60, p2) + mstore(0x80, p3) + } + _sendLogPayload(0x1c, 0x84); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + } + } + + function log(address p0, address p1, address p2, uint256 p3) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + assembly { + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + // Selector of `log(address,address,address,uint256)`. + mstore(0x00, 0x94250d77) + mstore(0x20, p0) + mstore(0x40, p1) + mstore(0x60, p2) + mstore(0x80, p3) + } + _sendLogPayload(0x1c, 0x84); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + } + } + + function log(address p0, address p1, address p2, bytes32 p3) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + bytes32 m5; + bytes32 m6; + assembly { + function writeString(pos, w) { + let length := 0 + for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } + mstore(pos, length) + let shift := sub(256, shl(3, length)) + mstore(add(pos, 0x20), shl(shift, shr(shift, w))) + } + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + m5 := mload(0xa0) + m6 := mload(0xc0) + // Selector of `log(address,address,address,string)`. + mstore(0x00, 0xf808da20) + mstore(0x20, p0) + mstore(0x40, p1) + mstore(0x60, p2) + mstore(0x80, 0x80) + writeString(0xa0, p3) + } + _sendLogPayload(0x1c, 0xc4); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + mstore(0xa0, m5) + mstore(0xc0, m6) + } + } + + function log(address p0, address p1, bool p2, address p3) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + assembly { + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + // Selector of `log(address,address,bool,address)`. + mstore(0x00, 0x9f1bc36e) + mstore(0x20, p0) + mstore(0x40, p1) + mstore(0x60, p2) + mstore(0x80, p3) + } + _sendLogPayload(0x1c, 0x84); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + } + } + + function log(address p0, address p1, bool p2, bool p3) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + assembly { + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + // Selector of `log(address,address,bool,bool)`. + mstore(0x00, 0x2cd4134a) + mstore(0x20, p0) + mstore(0x40, p1) + mstore(0x60, p2) + mstore(0x80, p3) + } + _sendLogPayload(0x1c, 0x84); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + } + } + + function log(address p0, address p1, bool p2, uint256 p3) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + assembly { + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + // Selector of `log(address,address,bool,uint256)`. + mstore(0x00, 0x3971e78c) + mstore(0x20, p0) + mstore(0x40, p1) + mstore(0x60, p2) + mstore(0x80, p3) + } + _sendLogPayload(0x1c, 0x84); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + } + } + + function log(address p0, address p1, bool p2, bytes32 p3) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + bytes32 m5; + bytes32 m6; + assembly { + function writeString(pos, w) { + let length := 0 + for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } + mstore(pos, length) + let shift := sub(256, shl(3, length)) + mstore(add(pos, 0x20), shl(shift, shr(shift, w))) + } + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + m5 := mload(0xa0) + m6 := mload(0xc0) + // Selector of `log(address,address,bool,string)`. + mstore(0x00, 0xaa6540c8) + mstore(0x20, p0) + mstore(0x40, p1) + mstore(0x60, p2) + mstore(0x80, 0x80) + writeString(0xa0, p3) + } + _sendLogPayload(0x1c, 0xc4); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + mstore(0xa0, m5) + mstore(0xc0, m6) + } + } + + function log(address p0, address p1, uint256 p2, address p3) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + assembly { + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + // Selector of `log(address,address,uint256,address)`. + mstore(0x00, 0x8da6def5) + mstore(0x20, p0) + mstore(0x40, p1) + mstore(0x60, p2) + mstore(0x80, p3) + } + _sendLogPayload(0x1c, 0x84); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + } + } + + function log(address p0, address p1, uint256 p2, bool p3) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + assembly { + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + // Selector of `log(address,address,uint256,bool)`. + mstore(0x00, 0x9b4254e2) + mstore(0x20, p0) + mstore(0x40, p1) + mstore(0x60, p2) + mstore(0x80, p3) + } + _sendLogPayload(0x1c, 0x84); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + } + } + + function log(address p0, address p1, uint256 p2, uint256 p3) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + assembly { + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + // Selector of `log(address,address,uint256,uint256)`. + mstore(0x00, 0xbe553481) + mstore(0x20, p0) + mstore(0x40, p1) + mstore(0x60, p2) + mstore(0x80, p3) + } + _sendLogPayload(0x1c, 0x84); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + } + } + + function log(address p0, address p1, uint256 p2, bytes32 p3) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + bytes32 m5; + bytes32 m6; + assembly { + function writeString(pos, w) { + let length := 0 + for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } + mstore(pos, length) + let shift := sub(256, shl(3, length)) + mstore(add(pos, 0x20), shl(shift, shr(shift, w))) + } + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + m5 := mload(0xa0) + m6 := mload(0xc0) + // Selector of `log(address,address,uint256,string)`. + mstore(0x00, 0xfdb4f990) + mstore(0x20, p0) + mstore(0x40, p1) + mstore(0x60, p2) + mstore(0x80, 0x80) + writeString(0xa0, p3) + } + _sendLogPayload(0x1c, 0xc4); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + mstore(0xa0, m5) + mstore(0xc0, m6) + } + } + + function log(address p0, address p1, bytes32 p2, address p3) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + bytes32 m5; + bytes32 m6; + assembly { + function writeString(pos, w) { + let length := 0 + for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } + mstore(pos, length) + let shift := sub(256, shl(3, length)) + mstore(add(pos, 0x20), shl(shift, shr(shift, w))) + } + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + m5 := mload(0xa0) + m6 := mload(0xc0) + // Selector of `log(address,address,string,address)`. + mstore(0x00, 0x8f736d16) + mstore(0x20, p0) + mstore(0x40, p1) + mstore(0x60, 0x80) + mstore(0x80, p3) + writeString(0xa0, p2) + } + _sendLogPayload(0x1c, 0xc4); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + mstore(0xa0, m5) + mstore(0xc0, m6) + } + } + + function log(address p0, address p1, bytes32 p2, bool p3) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + bytes32 m5; + bytes32 m6; + assembly { + function writeString(pos, w) { + let length := 0 + for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } + mstore(pos, length) + let shift := sub(256, shl(3, length)) + mstore(add(pos, 0x20), shl(shift, shr(shift, w))) + } + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + m5 := mload(0xa0) + m6 := mload(0xc0) + // Selector of `log(address,address,string,bool)`. + mstore(0x00, 0x6f1a594e) + mstore(0x20, p0) + mstore(0x40, p1) + mstore(0x60, 0x80) + mstore(0x80, p3) + writeString(0xa0, p2) + } + _sendLogPayload(0x1c, 0xc4); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + mstore(0xa0, m5) + mstore(0xc0, m6) + } + } + + function log(address p0, address p1, bytes32 p2, uint256 p3) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + bytes32 m5; + bytes32 m6; + assembly { + function writeString(pos, w) { + let length := 0 + for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } + mstore(pos, length) + let shift := sub(256, shl(3, length)) + mstore(add(pos, 0x20), shl(shift, shr(shift, w))) + } + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + m5 := mload(0xa0) + m6 := mload(0xc0) + // Selector of `log(address,address,string,uint256)`. + mstore(0x00, 0xef1cefe7) + mstore(0x20, p0) + mstore(0x40, p1) + mstore(0x60, 0x80) + mstore(0x80, p3) + writeString(0xa0, p2) + } + _sendLogPayload(0x1c, 0xc4); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + mstore(0xa0, m5) + mstore(0xc0, m6) + } + } + + function log(address p0, address p1, bytes32 p2, bytes32 p3) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + bytes32 m5; + bytes32 m6; + bytes32 m7; + bytes32 m8; + assembly { + function writeString(pos, w) { + let length := 0 + for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } + mstore(pos, length) + let shift := sub(256, shl(3, length)) + mstore(add(pos, 0x20), shl(shift, shr(shift, w))) + } + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + m5 := mload(0xa0) + m6 := mload(0xc0) + m7 := mload(0xe0) + m8 := mload(0x100) + // Selector of `log(address,address,string,string)`. + mstore(0x00, 0x21bdaf25) + mstore(0x20, p0) + mstore(0x40, p1) + mstore(0x60, 0x80) + mstore(0x80, 0xc0) + writeString(0xa0, p2) + writeString(0xe0, p3) + } + _sendLogPayload(0x1c, 0x104); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + mstore(0xa0, m5) + mstore(0xc0, m6) + mstore(0xe0, m7) + mstore(0x100, m8) + } + } + + function log(address p0, bool p1, address p2, address p3) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + assembly { + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + // Selector of `log(address,bool,address,address)`. + mstore(0x00, 0x660375dd) + mstore(0x20, p0) + mstore(0x40, p1) + mstore(0x60, p2) + mstore(0x80, p3) + } + _sendLogPayload(0x1c, 0x84); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + } + } + + function log(address p0, bool p1, address p2, bool p3) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + assembly { + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + // Selector of `log(address,bool,address,bool)`. + mstore(0x00, 0xa6f50b0f) + mstore(0x20, p0) + mstore(0x40, p1) + mstore(0x60, p2) + mstore(0x80, p3) + } + _sendLogPayload(0x1c, 0x84); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + } + } + + function log(address p0, bool p1, address p2, uint256 p3) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + assembly { + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + // Selector of `log(address,bool,address,uint256)`. + mstore(0x00, 0xa75c59de) + mstore(0x20, p0) + mstore(0x40, p1) + mstore(0x60, p2) + mstore(0x80, p3) + } + _sendLogPayload(0x1c, 0x84); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + } + } + + function log(address p0, bool p1, address p2, bytes32 p3) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + bytes32 m5; + bytes32 m6; + assembly { + function writeString(pos, w) { + let length := 0 + for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } + mstore(pos, length) + let shift := sub(256, shl(3, length)) + mstore(add(pos, 0x20), shl(shift, shr(shift, w))) + } + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + m5 := mload(0xa0) + m6 := mload(0xc0) + // Selector of `log(address,bool,address,string)`. + mstore(0x00, 0x2dd778e6) + mstore(0x20, p0) + mstore(0x40, p1) + mstore(0x60, p2) + mstore(0x80, 0x80) + writeString(0xa0, p3) + } + _sendLogPayload(0x1c, 0xc4); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + mstore(0xa0, m5) + mstore(0xc0, m6) + } + } + + function log(address p0, bool p1, bool p2, address p3) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + assembly { + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + // Selector of `log(address,bool,bool,address)`. + mstore(0x00, 0xcf394485) + mstore(0x20, p0) + mstore(0x40, p1) + mstore(0x60, p2) + mstore(0x80, p3) + } + _sendLogPayload(0x1c, 0x84); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + } + } + + function log(address p0, bool p1, bool p2, bool p3) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + assembly { + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + // Selector of `log(address,bool,bool,bool)`. + mstore(0x00, 0xcac43479) + mstore(0x20, p0) + mstore(0x40, p1) + mstore(0x60, p2) + mstore(0x80, p3) + } + _sendLogPayload(0x1c, 0x84); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + } + } + + function log(address p0, bool p1, bool p2, uint256 p3) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + assembly { + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + // Selector of `log(address,bool,bool,uint256)`. + mstore(0x00, 0x8c4e5de6) + mstore(0x20, p0) + mstore(0x40, p1) + mstore(0x60, p2) + mstore(0x80, p3) + } + _sendLogPayload(0x1c, 0x84); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + } + } + + function log(address p0, bool p1, bool p2, bytes32 p3) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + bytes32 m5; + bytes32 m6; + assembly { + function writeString(pos, w) { + let length := 0 + for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } + mstore(pos, length) + let shift := sub(256, shl(3, length)) + mstore(add(pos, 0x20), shl(shift, shr(shift, w))) + } + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + m5 := mload(0xa0) + m6 := mload(0xc0) + // Selector of `log(address,bool,bool,string)`. + mstore(0x00, 0xdfc4a2e8) + mstore(0x20, p0) + mstore(0x40, p1) + mstore(0x60, p2) + mstore(0x80, 0x80) + writeString(0xa0, p3) + } + _sendLogPayload(0x1c, 0xc4); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + mstore(0xa0, m5) + mstore(0xc0, m6) + } + } + + function log(address p0, bool p1, uint256 p2, address p3) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + assembly { + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + // Selector of `log(address,bool,uint256,address)`. + mstore(0x00, 0xccf790a1) + mstore(0x20, p0) + mstore(0x40, p1) + mstore(0x60, p2) + mstore(0x80, p3) + } + _sendLogPayload(0x1c, 0x84); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + } + } + + function log(address p0, bool p1, uint256 p2, bool p3) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + assembly { + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + // Selector of `log(address,bool,uint256,bool)`. + mstore(0x00, 0xc4643e20) + mstore(0x20, p0) + mstore(0x40, p1) + mstore(0x60, p2) + mstore(0x80, p3) + } + _sendLogPayload(0x1c, 0x84); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + } + } + + function log(address p0, bool p1, uint256 p2, uint256 p3) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + assembly { + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + // Selector of `log(address,bool,uint256,uint256)`. + mstore(0x00, 0x386ff5f4) + mstore(0x20, p0) + mstore(0x40, p1) + mstore(0x60, p2) + mstore(0x80, p3) + } + _sendLogPayload(0x1c, 0x84); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + } + } + + function log(address p0, bool p1, uint256 p2, bytes32 p3) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + bytes32 m5; + bytes32 m6; + assembly { + function writeString(pos, w) { + let length := 0 + for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } + mstore(pos, length) + let shift := sub(256, shl(3, length)) + mstore(add(pos, 0x20), shl(shift, shr(shift, w))) + } + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + m5 := mload(0xa0) + m6 := mload(0xc0) + // Selector of `log(address,bool,uint256,string)`. + mstore(0x00, 0x0aa6cfad) + mstore(0x20, p0) + mstore(0x40, p1) + mstore(0x60, p2) + mstore(0x80, 0x80) + writeString(0xa0, p3) + } + _sendLogPayload(0x1c, 0xc4); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + mstore(0xa0, m5) + mstore(0xc0, m6) + } + } + + function log(address p0, bool p1, bytes32 p2, address p3) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + bytes32 m5; + bytes32 m6; + assembly { + function writeString(pos, w) { + let length := 0 + for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } + mstore(pos, length) + let shift := sub(256, shl(3, length)) + mstore(add(pos, 0x20), shl(shift, shr(shift, w))) + } + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + m5 := mload(0xa0) + m6 := mload(0xc0) + // Selector of `log(address,bool,string,address)`. + mstore(0x00, 0x19fd4956) + mstore(0x20, p0) + mstore(0x40, p1) + mstore(0x60, 0x80) + mstore(0x80, p3) + writeString(0xa0, p2) + } + _sendLogPayload(0x1c, 0xc4); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + mstore(0xa0, m5) + mstore(0xc0, m6) + } + } + + function log(address p0, bool p1, bytes32 p2, bool p3) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + bytes32 m5; + bytes32 m6; + assembly { + function writeString(pos, w) { + let length := 0 + for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } + mstore(pos, length) + let shift := sub(256, shl(3, length)) + mstore(add(pos, 0x20), shl(shift, shr(shift, w))) + } + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + m5 := mload(0xa0) + m6 := mload(0xc0) + // Selector of `log(address,bool,string,bool)`. + mstore(0x00, 0x50ad461d) + mstore(0x20, p0) + mstore(0x40, p1) + mstore(0x60, 0x80) + mstore(0x80, p3) + writeString(0xa0, p2) + } + _sendLogPayload(0x1c, 0xc4); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + mstore(0xa0, m5) + mstore(0xc0, m6) + } + } + + function log(address p0, bool p1, bytes32 p2, uint256 p3) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + bytes32 m5; + bytes32 m6; + assembly { + function writeString(pos, w) { + let length := 0 + for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } + mstore(pos, length) + let shift := sub(256, shl(3, length)) + mstore(add(pos, 0x20), shl(shift, shr(shift, w))) + } + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + m5 := mload(0xa0) + m6 := mload(0xc0) + // Selector of `log(address,bool,string,uint256)`. + mstore(0x00, 0x80e6a20b) + mstore(0x20, p0) + mstore(0x40, p1) + mstore(0x60, 0x80) + mstore(0x80, p3) + writeString(0xa0, p2) + } + _sendLogPayload(0x1c, 0xc4); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + mstore(0xa0, m5) + mstore(0xc0, m6) + } + } + + function log(address p0, bool p1, bytes32 p2, bytes32 p3) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + bytes32 m5; + bytes32 m6; + bytes32 m7; + bytes32 m8; + assembly { + function writeString(pos, w) { + let length := 0 + for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } + mstore(pos, length) + let shift := sub(256, shl(3, length)) + mstore(add(pos, 0x20), shl(shift, shr(shift, w))) + } + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + m5 := mload(0xa0) + m6 := mload(0xc0) + m7 := mload(0xe0) + m8 := mload(0x100) + // Selector of `log(address,bool,string,string)`. + mstore(0x00, 0x475c5c33) + mstore(0x20, p0) + mstore(0x40, p1) + mstore(0x60, 0x80) + mstore(0x80, 0xc0) + writeString(0xa0, p2) + writeString(0xe0, p3) + } + _sendLogPayload(0x1c, 0x104); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + mstore(0xa0, m5) + mstore(0xc0, m6) + mstore(0xe0, m7) + mstore(0x100, m8) + } + } + + function log(address p0, uint256 p1, address p2, address p3) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + assembly { + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + // Selector of `log(address,uint256,address,address)`. + mstore(0x00, 0x478d1c62) + mstore(0x20, p0) + mstore(0x40, p1) + mstore(0x60, p2) + mstore(0x80, p3) + } + _sendLogPayload(0x1c, 0x84); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + } + } + + function log(address p0, uint256 p1, address p2, bool p3) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + assembly { + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + // Selector of `log(address,uint256,address,bool)`. + mstore(0x00, 0xa1bcc9b3) + mstore(0x20, p0) + mstore(0x40, p1) + mstore(0x60, p2) + mstore(0x80, p3) + } + _sendLogPayload(0x1c, 0x84); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + } + } + + function log(address p0, uint256 p1, address p2, uint256 p3) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + assembly { + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + // Selector of `log(address,uint256,address,uint256)`. + mstore(0x00, 0x100f650e) + mstore(0x20, p0) + mstore(0x40, p1) + mstore(0x60, p2) + mstore(0x80, p3) + } + _sendLogPayload(0x1c, 0x84); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + } + } + + function log(address p0, uint256 p1, address p2, bytes32 p3) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + bytes32 m5; + bytes32 m6; + assembly { + function writeString(pos, w) { + let length := 0 + for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } + mstore(pos, length) + let shift := sub(256, shl(3, length)) + mstore(add(pos, 0x20), shl(shift, shr(shift, w))) + } + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + m5 := mload(0xa0) + m6 := mload(0xc0) + // Selector of `log(address,uint256,address,string)`. + mstore(0x00, 0x1da986ea) + mstore(0x20, p0) + mstore(0x40, p1) + mstore(0x60, p2) + mstore(0x80, 0x80) + writeString(0xa0, p3) + } + _sendLogPayload(0x1c, 0xc4); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + mstore(0xa0, m5) + mstore(0xc0, m6) + } + } + + function log(address p0, uint256 p1, bool p2, address p3) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + assembly { + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + // Selector of `log(address,uint256,bool,address)`. + mstore(0x00, 0xa31bfdcc) + mstore(0x20, p0) + mstore(0x40, p1) + mstore(0x60, p2) + mstore(0x80, p3) + } + _sendLogPayload(0x1c, 0x84); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + } + } + + function log(address p0, uint256 p1, bool p2, bool p3) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + assembly { + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + // Selector of `log(address,uint256,bool,bool)`. + mstore(0x00, 0x3bf5e537) + mstore(0x20, p0) + mstore(0x40, p1) + mstore(0x60, p2) + mstore(0x80, p3) + } + _sendLogPayload(0x1c, 0x84); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + } + } + + function log(address p0, uint256 p1, bool p2, uint256 p3) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + assembly { + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + // Selector of `log(address,uint256,bool,uint256)`. + mstore(0x00, 0x22f6b999) + mstore(0x20, p0) + mstore(0x40, p1) + mstore(0x60, p2) + mstore(0x80, p3) + } + _sendLogPayload(0x1c, 0x84); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + } + } + + function log(address p0, uint256 p1, bool p2, bytes32 p3) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + bytes32 m5; + bytes32 m6; + assembly { + function writeString(pos, w) { + let length := 0 + for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } + mstore(pos, length) + let shift := sub(256, shl(3, length)) + mstore(add(pos, 0x20), shl(shift, shr(shift, w))) + } + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + m5 := mload(0xa0) + m6 := mload(0xc0) + // Selector of `log(address,uint256,bool,string)`. + mstore(0x00, 0xc5ad85f9) + mstore(0x20, p0) + mstore(0x40, p1) + mstore(0x60, p2) + mstore(0x80, 0x80) + writeString(0xa0, p3) + } + _sendLogPayload(0x1c, 0xc4); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + mstore(0xa0, m5) + mstore(0xc0, m6) + } + } + + function log(address p0, uint256 p1, uint256 p2, address p3) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + assembly { + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + // Selector of `log(address,uint256,uint256,address)`. + mstore(0x00, 0x20e3984d) + mstore(0x20, p0) + mstore(0x40, p1) + mstore(0x60, p2) + mstore(0x80, p3) + } + _sendLogPayload(0x1c, 0x84); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + } + } + + function log(address p0, uint256 p1, uint256 p2, bool p3) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + assembly { + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + // Selector of `log(address,uint256,uint256,bool)`. + mstore(0x00, 0x66f1bc67) + mstore(0x20, p0) + mstore(0x40, p1) + mstore(0x60, p2) + mstore(0x80, p3) + } + _sendLogPayload(0x1c, 0x84); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + } + } + + function log(address p0, uint256 p1, uint256 p2, uint256 p3) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + assembly { + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + // Selector of `log(address,uint256,uint256,uint256)`. + mstore(0x00, 0x34f0e636) + mstore(0x20, p0) + mstore(0x40, p1) + mstore(0x60, p2) + mstore(0x80, p3) + } + _sendLogPayload(0x1c, 0x84); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + } + } + + function log(address p0, uint256 p1, uint256 p2, bytes32 p3) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + bytes32 m5; + bytes32 m6; + assembly { + function writeString(pos, w) { + let length := 0 + for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } + mstore(pos, length) + let shift := sub(256, shl(3, length)) + mstore(add(pos, 0x20), shl(shift, shr(shift, w))) + } + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + m5 := mload(0xa0) + m6 := mload(0xc0) + // Selector of `log(address,uint256,uint256,string)`. + mstore(0x00, 0x4a28c017) + mstore(0x20, p0) + mstore(0x40, p1) + mstore(0x60, p2) + mstore(0x80, 0x80) + writeString(0xa0, p3) + } + _sendLogPayload(0x1c, 0xc4); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + mstore(0xa0, m5) + mstore(0xc0, m6) + } + } + + function log(address p0, uint256 p1, bytes32 p2, address p3) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + bytes32 m5; + bytes32 m6; + assembly { + function writeString(pos, w) { + let length := 0 + for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } + mstore(pos, length) + let shift := sub(256, shl(3, length)) + mstore(add(pos, 0x20), shl(shift, shr(shift, w))) + } + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + m5 := mload(0xa0) + m6 := mload(0xc0) + // Selector of `log(address,uint256,string,address)`. + mstore(0x00, 0x5c430d47) + mstore(0x20, p0) + mstore(0x40, p1) + mstore(0x60, 0x80) + mstore(0x80, p3) + writeString(0xa0, p2) + } + _sendLogPayload(0x1c, 0xc4); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + mstore(0xa0, m5) + mstore(0xc0, m6) + } + } + + function log(address p0, uint256 p1, bytes32 p2, bool p3) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + bytes32 m5; + bytes32 m6; + assembly { + function writeString(pos, w) { + let length := 0 + for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } + mstore(pos, length) + let shift := sub(256, shl(3, length)) + mstore(add(pos, 0x20), shl(shift, shr(shift, w))) + } + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + m5 := mload(0xa0) + m6 := mload(0xc0) + // Selector of `log(address,uint256,string,bool)`. + mstore(0x00, 0xcf18105c) + mstore(0x20, p0) + mstore(0x40, p1) + mstore(0x60, 0x80) + mstore(0x80, p3) + writeString(0xa0, p2) + } + _sendLogPayload(0x1c, 0xc4); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + mstore(0xa0, m5) + mstore(0xc0, m6) + } + } + + function log(address p0, uint256 p1, bytes32 p2, uint256 p3) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + bytes32 m5; + bytes32 m6; + assembly { + function writeString(pos, w) { + let length := 0 + for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } + mstore(pos, length) + let shift := sub(256, shl(3, length)) + mstore(add(pos, 0x20), shl(shift, shr(shift, w))) + } + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + m5 := mload(0xa0) + m6 := mload(0xc0) + // Selector of `log(address,uint256,string,uint256)`. + mstore(0x00, 0xbf01f891) + mstore(0x20, p0) + mstore(0x40, p1) + mstore(0x60, 0x80) + mstore(0x80, p3) + writeString(0xa0, p2) + } + _sendLogPayload(0x1c, 0xc4); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + mstore(0xa0, m5) + mstore(0xc0, m6) + } + } + + function log(address p0, uint256 p1, bytes32 p2, bytes32 p3) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + bytes32 m5; + bytes32 m6; + bytes32 m7; + bytes32 m8; + assembly { + function writeString(pos, w) { + let length := 0 + for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } + mstore(pos, length) + let shift := sub(256, shl(3, length)) + mstore(add(pos, 0x20), shl(shift, shr(shift, w))) + } + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + m5 := mload(0xa0) + m6 := mload(0xc0) + m7 := mload(0xe0) + m8 := mload(0x100) + // Selector of `log(address,uint256,string,string)`. + mstore(0x00, 0x88a8c406) + mstore(0x20, p0) + mstore(0x40, p1) + mstore(0x60, 0x80) + mstore(0x80, 0xc0) + writeString(0xa0, p2) + writeString(0xe0, p3) + } + _sendLogPayload(0x1c, 0x104); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + mstore(0xa0, m5) + mstore(0xc0, m6) + mstore(0xe0, m7) + mstore(0x100, m8) + } + } + + function log(address p0, bytes32 p1, address p2, address p3) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + bytes32 m5; + bytes32 m6; + assembly { + function writeString(pos, w) { + let length := 0 + for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } + mstore(pos, length) + let shift := sub(256, shl(3, length)) + mstore(add(pos, 0x20), shl(shift, shr(shift, w))) + } + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + m5 := mload(0xa0) + m6 := mload(0xc0) + // Selector of `log(address,string,address,address)`. + mstore(0x00, 0x0d36fa20) + mstore(0x20, p0) + mstore(0x40, 0x80) + mstore(0x60, p2) + mstore(0x80, p3) + writeString(0xa0, p1) + } + _sendLogPayload(0x1c, 0xc4); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + mstore(0xa0, m5) + mstore(0xc0, m6) + } + } + + function log(address p0, bytes32 p1, address p2, bool p3) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + bytes32 m5; + bytes32 m6; + assembly { + function writeString(pos, w) { + let length := 0 + for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } + mstore(pos, length) + let shift := sub(256, shl(3, length)) + mstore(add(pos, 0x20), shl(shift, shr(shift, w))) + } + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + m5 := mload(0xa0) + m6 := mload(0xc0) + // Selector of `log(address,string,address,bool)`. + mstore(0x00, 0x0df12b76) + mstore(0x20, p0) + mstore(0x40, 0x80) + mstore(0x60, p2) + mstore(0x80, p3) + writeString(0xa0, p1) + } + _sendLogPayload(0x1c, 0xc4); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + mstore(0xa0, m5) + mstore(0xc0, m6) + } + } + + function log(address p0, bytes32 p1, address p2, uint256 p3) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + bytes32 m5; + bytes32 m6; + assembly { + function writeString(pos, w) { + let length := 0 + for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } + mstore(pos, length) + let shift := sub(256, shl(3, length)) + mstore(add(pos, 0x20), shl(shift, shr(shift, w))) + } + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + m5 := mload(0xa0) + m6 := mload(0xc0) + // Selector of `log(address,string,address,uint256)`. + mstore(0x00, 0x457fe3cf) + mstore(0x20, p0) + mstore(0x40, 0x80) + mstore(0x60, p2) + mstore(0x80, p3) + writeString(0xa0, p1) + } + _sendLogPayload(0x1c, 0xc4); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + mstore(0xa0, m5) + mstore(0xc0, m6) + } + } + + function log(address p0, bytes32 p1, address p2, bytes32 p3) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + bytes32 m5; + bytes32 m6; + bytes32 m7; + bytes32 m8; + assembly { + function writeString(pos, w) { + let length := 0 + for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } + mstore(pos, length) + let shift := sub(256, shl(3, length)) + mstore(add(pos, 0x20), shl(shift, shr(shift, w))) + } + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + m5 := mload(0xa0) + m6 := mload(0xc0) + m7 := mload(0xe0) + m8 := mload(0x100) + // Selector of `log(address,string,address,string)`. + mstore(0x00, 0xf7e36245) + mstore(0x20, p0) + mstore(0x40, 0x80) + mstore(0x60, p2) + mstore(0x80, 0xc0) + writeString(0xa0, p1) + writeString(0xe0, p3) + } + _sendLogPayload(0x1c, 0x104); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + mstore(0xa0, m5) + mstore(0xc0, m6) + mstore(0xe0, m7) + mstore(0x100, m8) + } + } + + function log(address p0, bytes32 p1, bool p2, address p3) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + bytes32 m5; + bytes32 m6; + assembly { + function writeString(pos, w) { + let length := 0 + for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } + mstore(pos, length) + let shift := sub(256, shl(3, length)) + mstore(add(pos, 0x20), shl(shift, shr(shift, w))) + } + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + m5 := mload(0xa0) + m6 := mload(0xc0) + // Selector of `log(address,string,bool,address)`. + mstore(0x00, 0x205871c2) + mstore(0x20, p0) + mstore(0x40, 0x80) + mstore(0x60, p2) + mstore(0x80, p3) + writeString(0xa0, p1) + } + _sendLogPayload(0x1c, 0xc4); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + mstore(0xa0, m5) + mstore(0xc0, m6) + } + } + + function log(address p0, bytes32 p1, bool p2, bool p3) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + bytes32 m5; + bytes32 m6; + assembly { + function writeString(pos, w) { + let length := 0 + for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } + mstore(pos, length) + let shift := sub(256, shl(3, length)) + mstore(add(pos, 0x20), shl(shift, shr(shift, w))) + } + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + m5 := mload(0xa0) + m6 := mload(0xc0) + // Selector of `log(address,string,bool,bool)`. + mstore(0x00, 0x5f1d5c9f) + mstore(0x20, p0) + mstore(0x40, 0x80) + mstore(0x60, p2) + mstore(0x80, p3) + writeString(0xa0, p1) + } + _sendLogPayload(0x1c, 0xc4); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + mstore(0xa0, m5) + mstore(0xc0, m6) + } + } + + function log(address p0, bytes32 p1, bool p2, uint256 p3) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + bytes32 m5; + bytes32 m6; + assembly { + function writeString(pos, w) { + let length := 0 + for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } + mstore(pos, length) + let shift := sub(256, shl(3, length)) + mstore(add(pos, 0x20), shl(shift, shr(shift, w))) + } + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + m5 := mload(0xa0) + m6 := mload(0xc0) + // Selector of `log(address,string,bool,uint256)`. + mstore(0x00, 0x515e38b6) + mstore(0x20, p0) + mstore(0x40, 0x80) + mstore(0x60, p2) + mstore(0x80, p3) + writeString(0xa0, p1) + } + _sendLogPayload(0x1c, 0xc4); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + mstore(0xa0, m5) + mstore(0xc0, m6) + } + } + + function log(address p0, bytes32 p1, bool p2, bytes32 p3) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + bytes32 m5; + bytes32 m6; + bytes32 m7; + bytes32 m8; + assembly { + function writeString(pos, w) { + let length := 0 + for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } + mstore(pos, length) + let shift := sub(256, shl(3, length)) + mstore(add(pos, 0x20), shl(shift, shr(shift, w))) + } + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + m5 := mload(0xa0) + m6 := mload(0xc0) + m7 := mload(0xe0) + m8 := mload(0x100) + // Selector of `log(address,string,bool,string)`. + mstore(0x00, 0xbc0b61fe) + mstore(0x20, p0) + mstore(0x40, 0x80) + mstore(0x60, p2) + mstore(0x80, 0xc0) + writeString(0xa0, p1) + writeString(0xe0, p3) + } + _sendLogPayload(0x1c, 0x104); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + mstore(0xa0, m5) + mstore(0xc0, m6) + mstore(0xe0, m7) + mstore(0x100, m8) + } + } + + function log(address p0, bytes32 p1, uint256 p2, address p3) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + bytes32 m5; + bytes32 m6; + assembly { + function writeString(pos, w) { + let length := 0 + for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } + mstore(pos, length) + let shift := sub(256, shl(3, length)) + mstore(add(pos, 0x20), shl(shift, shr(shift, w))) + } + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + m5 := mload(0xa0) + m6 := mload(0xc0) + // Selector of `log(address,string,uint256,address)`. + mstore(0x00, 0x63183678) + mstore(0x20, p0) + mstore(0x40, 0x80) + mstore(0x60, p2) + mstore(0x80, p3) + writeString(0xa0, p1) + } + _sendLogPayload(0x1c, 0xc4); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + mstore(0xa0, m5) + mstore(0xc0, m6) + } + } + + function log(address p0, bytes32 p1, uint256 p2, bool p3) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + bytes32 m5; + bytes32 m6; + assembly { + function writeString(pos, w) { + let length := 0 + for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } + mstore(pos, length) + let shift := sub(256, shl(3, length)) + mstore(add(pos, 0x20), shl(shift, shr(shift, w))) + } + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + m5 := mload(0xa0) + m6 := mload(0xc0) + // Selector of `log(address,string,uint256,bool)`. + mstore(0x00, 0x0ef7e050) + mstore(0x20, p0) + mstore(0x40, 0x80) + mstore(0x60, p2) + mstore(0x80, p3) + writeString(0xa0, p1) + } + _sendLogPayload(0x1c, 0xc4); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + mstore(0xa0, m5) + mstore(0xc0, m6) + } + } + + function log(address p0, bytes32 p1, uint256 p2, uint256 p3) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + bytes32 m5; + bytes32 m6; + assembly { + function writeString(pos, w) { + let length := 0 + for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } + mstore(pos, length) + let shift := sub(256, shl(3, length)) + mstore(add(pos, 0x20), shl(shift, shr(shift, w))) + } + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + m5 := mload(0xa0) + m6 := mload(0xc0) + // Selector of `log(address,string,uint256,uint256)`. + mstore(0x00, 0x1dc8e1b8) + mstore(0x20, p0) + mstore(0x40, 0x80) + mstore(0x60, p2) + mstore(0x80, p3) + writeString(0xa0, p1) + } + _sendLogPayload(0x1c, 0xc4); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + mstore(0xa0, m5) + mstore(0xc0, m6) + } + } + + function log(address p0, bytes32 p1, uint256 p2, bytes32 p3) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + bytes32 m5; + bytes32 m6; + bytes32 m7; + bytes32 m8; + assembly { + function writeString(pos, w) { + let length := 0 + for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } + mstore(pos, length) + let shift := sub(256, shl(3, length)) + mstore(add(pos, 0x20), shl(shift, shr(shift, w))) + } + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + m5 := mload(0xa0) + m6 := mload(0xc0) + m7 := mload(0xe0) + m8 := mload(0x100) + // Selector of `log(address,string,uint256,string)`. + mstore(0x00, 0x448830a8) + mstore(0x20, p0) + mstore(0x40, 0x80) + mstore(0x60, p2) + mstore(0x80, 0xc0) + writeString(0xa0, p1) + writeString(0xe0, p3) + } + _sendLogPayload(0x1c, 0x104); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + mstore(0xa0, m5) + mstore(0xc0, m6) + mstore(0xe0, m7) + mstore(0x100, m8) + } + } + + function log(address p0, bytes32 p1, bytes32 p2, address p3) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + bytes32 m5; + bytes32 m6; + bytes32 m7; + bytes32 m8; + assembly { + function writeString(pos, w) { + let length := 0 + for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } + mstore(pos, length) + let shift := sub(256, shl(3, length)) + mstore(add(pos, 0x20), shl(shift, shr(shift, w))) + } + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + m5 := mload(0xa0) + m6 := mload(0xc0) + m7 := mload(0xe0) + m8 := mload(0x100) + // Selector of `log(address,string,string,address)`. + mstore(0x00, 0xa04e2f87) + mstore(0x20, p0) + mstore(0x40, 0x80) + mstore(0x60, 0xc0) + mstore(0x80, p3) + writeString(0xa0, p1) + writeString(0xe0, p2) + } + _sendLogPayload(0x1c, 0x104); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + mstore(0xa0, m5) + mstore(0xc0, m6) + mstore(0xe0, m7) + mstore(0x100, m8) + } + } + + function log(address p0, bytes32 p1, bytes32 p2, bool p3) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + bytes32 m5; + bytes32 m6; + bytes32 m7; + bytes32 m8; + assembly { + function writeString(pos, w) { + let length := 0 + for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } + mstore(pos, length) + let shift := sub(256, shl(3, length)) + mstore(add(pos, 0x20), shl(shift, shr(shift, w))) + } + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + m5 := mload(0xa0) + m6 := mload(0xc0) + m7 := mload(0xe0) + m8 := mload(0x100) + // Selector of `log(address,string,string,bool)`. + mstore(0x00, 0x35a5071f) + mstore(0x20, p0) + mstore(0x40, 0x80) + mstore(0x60, 0xc0) + mstore(0x80, p3) + writeString(0xa0, p1) + writeString(0xe0, p2) + } + _sendLogPayload(0x1c, 0x104); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + mstore(0xa0, m5) + mstore(0xc0, m6) + mstore(0xe0, m7) + mstore(0x100, m8) + } + } + + function log(address p0, bytes32 p1, bytes32 p2, uint256 p3) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + bytes32 m5; + bytes32 m6; + bytes32 m7; + bytes32 m8; + assembly { + function writeString(pos, w) { + let length := 0 + for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } + mstore(pos, length) + let shift := sub(256, shl(3, length)) + mstore(add(pos, 0x20), shl(shift, shr(shift, w))) + } + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + m5 := mload(0xa0) + m6 := mload(0xc0) + m7 := mload(0xe0) + m8 := mload(0x100) + // Selector of `log(address,string,string,uint256)`. + mstore(0x00, 0x159f8927) + mstore(0x20, p0) + mstore(0x40, 0x80) + mstore(0x60, 0xc0) + mstore(0x80, p3) + writeString(0xa0, p1) + writeString(0xe0, p2) + } + _sendLogPayload(0x1c, 0x104); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + mstore(0xa0, m5) + mstore(0xc0, m6) + mstore(0xe0, m7) + mstore(0x100, m8) + } + } + + function log(address p0, bytes32 p1, bytes32 p2, bytes32 p3) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + bytes32 m5; + bytes32 m6; + bytes32 m7; + bytes32 m8; + bytes32 m9; + bytes32 m10; + assembly { + function writeString(pos, w) { + let length := 0 + for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } + mstore(pos, length) + let shift := sub(256, shl(3, length)) + mstore(add(pos, 0x20), shl(shift, shr(shift, w))) + } + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + m5 := mload(0xa0) + m6 := mload(0xc0) + m7 := mload(0xe0) + m8 := mload(0x100) + m9 := mload(0x120) + m10 := mload(0x140) + // Selector of `log(address,string,string,string)`. + mstore(0x00, 0x5d02c50b) + mstore(0x20, p0) + mstore(0x40, 0x80) + mstore(0x60, 0xc0) + mstore(0x80, 0x100) + writeString(0xa0, p1) + writeString(0xe0, p2) + writeString(0x120, p3) + } + _sendLogPayload(0x1c, 0x144); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + mstore(0xa0, m5) + mstore(0xc0, m6) + mstore(0xe0, m7) + mstore(0x100, m8) + mstore(0x120, m9) + mstore(0x140, m10) + } + } + + function log(bool p0, address p1, address p2, address p3) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + assembly { + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + // Selector of `log(bool,address,address,address)`. + mstore(0x00, 0x1d14d001) + mstore(0x20, p0) + mstore(0x40, p1) + mstore(0x60, p2) + mstore(0x80, p3) + } + _sendLogPayload(0x1c, 0x84); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + } + } + + function log(bool p0, address p1, address p2, bool p3) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + assembly { + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + // Selector of `log(bool,address,address,bool)`. + mstore(0x00, 0x46600be0) + mstore(0x20, p0) + mstore(0x40, p1) + mstore(0x60, p2) + mstore(0x80, p3) + } + _sendLogPayload(0x1c, 0x84); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + } + } + + function log(bool p0, address p1, address p2, uint256 p3) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + assembly { + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + // Selector of `log(bool,address,address,uint256)`. + mstore(0x00, 0x0c66d1be) + mstore(0x20, p0) + mstore(0x40, p1) + mstore(0x60, p2) + mstore(0x80, p3) + } + _sendLogPayload(0x1c, 0x84); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + } + } + + function log(bool p0, address p1, address p2, bytes32 p3) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + bytes32 m5; + bytes32 m6; + assembly { + function writeString(pos, w) { + let length := 0 + for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } + mstore(pos, length) + let shift := sub(256, shl(3, length)) + mstore(add(pos, 0x20), shl(shift, shr(shift, w))) + } + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + m5 := mload(0xa0) + m6 := mload(0xc0) + // Selector of `log(bool,address,address,string)`. + mstore(0x00, 0xd812a167) + mstore(0x20, p0) + mstore(0x40, p1) + mstore(0x60, p2) + mstore(0x80, 0x80) + writeString(0xa0, p3) + } + _sendLogPayload(0x1c, 0xc4); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + mstore(0xa0, m5) + mstore(0xc0, m6) + } + } + + function log(bool p0, address p1, bool p2, address p3) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + assembly { + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + // Selector of `log(bool,address,bool,address)`. + mstore(0x00, 0x1c41a336) + mstore(0x20, p0) + mstore(0x40, p1) + mstore(0x60, p2) + mstore(0x80, p3) + } + _sendLogPayload(0x1c, 0x84); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + } + } + + function log(bool p0, address p1, bool p2, bool p3) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + assembly { + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + // Selector of `log(bool,address,bool,bool)`. + mstore(0x00, 0x6a9c478b) + mstore(0x20, p0) + mstore(0x40, p1) + mstore(0x60, p2) + mstore(0x80, p3) + } + _sendLogPayload(0x1c, 0x84); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + } + } + + function log(bool p0, address p1, bool p2, uint256 p3) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + assembly { + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + // Selector of `log(bool,address,bool,uint256)`. + mstore(0x00, 0x07831502) + mstore(0x20, p0) + mstore(0x40, p1) + mstore(0x60, p2) + mstore(0x80, p3) + } + _sendLogPayload(0x1c, 0x84); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + } + } + + function log(bool p0, address p1, bool p2, bytes32 p3) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + bytes32 m5; + bytes32 m6; + assembly { + function writeString(pos, w) { + let length := 0 + for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } + mstore(pos, length) + let shift := sub(256, shl(3, length)) + mstore(add(pos, 0x20), shl(shift, shr(shift, w))) + } + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + m5 := mload(0xa0) + m6 := mload(0xc0) + // Selector of `log(bool,address,bool,string)`. + mstore(0x00, 0x4a66cb34) + mstore(0x20, p0) + mstore(0x40, p1) + mstore(0x60, p2) + mstore(0x80, 0x80) + writeString(0xa0, p3) + } + _sendLogPayload(0x1c, 0xc4); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + mstore(0xa0, m5) + mstore(0xc0, m6) + } + } + + function log(bool p0, address p1, uint256 p2, address p3) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + assembly { + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + // Selector of `log(bool,address,uint256,address)`. + mstore(0x00, 0x136b05dd) + mstore(0x20, p0) + mstore(0x40, p1) + mstore(0x60, p2) + mstore(0x80, p3) + } + _sendLogPayload(0x1c, 0x84); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + } + } + + function log(bool p0, address p1, uint256 p2, bool p3) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + assembly { + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + // Selector of `log(bool,address,uint256,bool)`. + mstore(0x00, 0xd6019f1c) + mstore(0x20, p0) + mstore(0x40, p1) + mstore(0x60, p2) + mstore(0x80, p3) + } + _sendLogPayload(0x1c, 0x84); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + } + } + + function log(bool p0, address p1, uint256 p2, uint256 p3) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + assembly { + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + // Selector of `log(bool,address,uint256,uint256)`. + mstore(0x00, 0x7bf181a1) + mstore(0x20, p0) + mstore(0x40, p1) + mstore(0x60, p2) + mstore(0x80, p3) + } + _sendLogPayload(0x1c, 0x84); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + } + } + + function log(bool p0, address p1, uint256 p2, bytes32 p3) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + bytes32 m5; + bytes32 m6; + assembly { + function writeString(pos, w) { + let length := 0 + for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } + mstore(pos, length) + let shift := sub(256, shl(3, length)) + mstore(add(pos, 0x20), shl(shift, shr(shift, w))) + } + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + m5 := mload(0xa0) + m6 := mload(0xc0) + // Selector of `log(bool,address,uint256,string)`. + mstore(0x00, 0x51f09ff8) + mstore(0x20, p0) + mstore(0x40, p1) + mstore(0x60, p2) + mstore(0x80, 0x80) + writeString(0xa0, p3) + } + _sendLogPayload(0x1c, 0xc4); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + mstore(0xa0, m5) + mstore(0xc0, m6) + } + } + + function log(bool p0, address p1, bytes32 p2, address p3) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + bytes32 m5; + bytes32 m6; + assembly { + function writeString(pos, w) { + let length := 0 + for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } + mstore(pos, length) + let shift := sub(256, shl(3, length)) + mstore(add(pos, 0x20), shl(shift, shr(shift, w))) + } + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + m5 := mload(0xa0) + m6 := mload(0xc0) + // Selector of `log(bool,address,string,address)`. + mstore(0x00, 0x6f7c603e) + mstore(0x20, p0) + mstore(0x40, p1) + mstore(0x60, 0x80) + mstore(0x80, p3) + writeString(0xa0, p2) + } + _sendLogPayload(0x1c, 0xc4); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + mstore(0xa0, m5) + mstore(0xc0, m6) + } + } + + function log(bool p0, address p1, bytes32 p2, bool p3) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + bytes32 m5; + bytes32 m6; + assembly { + function writeString(pos, w) { + let length := 0 + for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } + mstore(pos, length) + let shift := sub(256, shl(3, length)) + mstore(add(pos, 0x20), shl(shift, shr(shift, w))) + } + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + m5 := mload(0xa0) + m6 := mload(0xc0) + // Selector of `log(bool,address,string,bool)`. + mstore(0x00, 0xe2bfd60b) + mstore(0x20, p0) + mstore(0x40, p1) + mstore(0x60, 0x80) + mstore(0x80, p3) + writeString(0xa0, p2) + } + _sendLogPayload(0x1c, 0xc4); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + mstore(0xa0, m5) + mstore(0xc0, m6) + } + } + + function log(bool p0, address p1, bytes32 p2, uint256 p3) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + bytes32 m5; + bytes32 m6; + assembly { + function writeString(pos, w) { + let length := 0 + for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } + mstore(pos, length) + let shift := sub(256, shl(3, length)) + mstore(add(pos, 0x20), shl(shift, shr(shift, w))) + } + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + m5 := mload(0xa0) + m6 := mload(0xc0) + // Selector of `log(bool,address,string,uint256)`. + mstore(0x00, 0xc21f64c7) + mstore(0x20, p0) + mstore(0x40, p1) + mstore(0x60, 0x80) + mstore(0x80, p3) + writeString(0xa0, p2) + } + _sendLogPayload(0x1c, 0xc4); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + mstore(0xa0, m5) + mstore(0xc0, m6) + } + } + + function log(bool p0, address p1, bytes32 p2, bytes32 p3) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + bytes32 m5; + bytes32 m6; + bytes32 m7; + bytes32 m8; + assembly { + function writeString(pos, w) { + let length := 0 + for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } + mstore(pos, length) + let shift := sub(256, shl(3, length)) + mstore(add(pos, 0x20), shl(shift, shr(shift, w))) + } + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + m5 := mload(0xa0) + m6 := mload(0xc0) + m7 := mload(0xe0) + m8 := mload(0x100) + // Selector of `log(bool,address,string,string)`. + mstore(0x00, 0xa73c1db6) + mstore(0x20, p0) + mstore(0x40, p1) + mstore(0x60, 0x80) + mstore(0x80, 0xc0) + writeString(0xa0, p2) + writeString(0xe0, p3) + } + _sendLogPayload(0x1c, 0x104); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + mstore(0xa0, m5) + mstore(0xc0, m6) + mstore(0xe0, m7) + mstore(0x100, m8) + } + } + + function log(bool p0, bool p1, address p2, address p3) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + assembly { + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + // Selector of `log(bool,bool,address,address)`. + mstore(0x00, 0xf4880ea4) + mstore(0x20, p0) + mstore(0x40, p1) + mstore(0x60, p2) + mstore(0x80, p3) + } + _sendLogPayload(0x1c, 0x84); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + } + } + + function log(bool p0, bool p1, address p2, bool p3) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + assembly { + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + // Selector of `log(bool,bool,address,bool)`. + mstore(0x00, 0xc0a302d8) + mstore(0x20, p0) + mstore(0x40, p1) + mstore(0x60, p2) + mstore(0x80, p3) + } + _sendLogPayload(0x1c, 0x84); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + } + } + + function log(bool p0, bool p1, address p2, uint256 p3) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + assembly { + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + // Selector of `log(bool,bool,address,uint256)`. + mstore(0x00, 0x4c123d57) + mstore(0x20, p0) + mstore(0x40, p1) + mstore(0x60, p2) + mstore(0x80, p3) + } + _sendLogPayload(0x1c, 0x84); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + } + } + + function log(bool p0, bool p1, address p2, bytes32 p3) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + bytes32 m5; + bytes32 m6; + assembly { + function writeString(pos, w) { + let length := 0 + for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } + mstore(pos, length) + let shift := sub(256, shl(3, length)) + mstore(add(pos, 0x20), shl(shift, shr(shift, w))) + } + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + m5 := mload(0xa0) + m6 := mload(0xc0) + // Selector of `log(bool,bool,address,string)`. + mstore(0x00, 0xa0a47963) + mstore(0x20, p0) + mstore(0x40, p1) + mstore(0x60, p2) + mstore(0x80, 0x80) + writeString(0xa0, p3) + } + _sendLogPayload(0x1c, 0xc4); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + mstore(0xa0, m5) + mstore(0xc0, m6) + } + } + + function log(bool p0, bool p1, bool p2, address p3) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + assembly { + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + // Selector of `log(bool,bool,bool,address)`. + mstore(0x00, 0x8c329b1a) + mstore(0x20, p0) + mstore(0x40, p1) + mstore(0x60, p2) + mstore(0x80, p3) + } + _sendLogPayload(0x1c, 0x84); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + } + } + + function log(bool p0, bool p1, bool p2, bool p3) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + assembly { + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + // Selector of `log(bool,bool,bool,bool)`. + mstore(0x00, 0x3b2a5ce0) + mstore(0x20, p0) + mstore(0x40, p1) + mstore(0x60, p2) + mstore(0x80, p3) + } + _sendLogPayload(0x1c, 0x84); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + } + } + + function log(bool p0, bool p1, bool p2, uint256 p3) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + assembly { + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + // Selector of `log(bool,bool,bool,uint256)`. + mstore(0x00, 0x6d7045c1) + mstore(0x20, p0) + mstore(0x40, p1) + mstore(0x60, p2) + mstore(0x80, p3) + } + _sendLogPayload(0x1c, 0x84); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + } + } + + function log(bool p0, bool p1, bool p2, bytes32 p3) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + bytes32 m5; + bytes32 m6; + assembly { + function writeString(pos, w) { + let length := 0 + for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } + mstore(pos, length) + let shift := sub(256, shl(3, length)) + mstore(add(pos, 0x20), shl(shift, shr(shift, w))) + } + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + m5 := mload(0xa0) + m6 := mload(0xc0) + // Selector of `log(bool,bool,bool,string)`. + mstore(0x00, 0x2ae408d4) + mstore(0x20, p0) + mstore(0x40, p1) + mstore(0x60, p2) + mstore(0x80, 0x80) + writeString(0xa0, p3) + } + _sendLogPayload(0x1c, 0xc4); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + mstore(0xa0, m5) + mstore(0xc0, m6) + } + } + + function log(bool p0, bool p1, uint256 p2, address p3) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + assembly { + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + // Selector of `log(bool,bool,uint256,address)`. + mstore(0x00, 0x54a7a9a0) + mstore(0x20, p0) + mstore(0x40, p1) + mstore(0x60, p2) + mstore(0x80, p3) + } + _sendLogPayload(0x1c, 0x84); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + } + } + + function log(bool p0, bool p1, uint256 p2, bool p3) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + assembly { + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + // Selector of `log(bool,bool,uint256,bool)`. + mstore(0x00, 0x619e4d0e) + mstore(0x20, p0) + mstore(0x40, p1) + mstore(0x60, p2) + mstore(0x80, p3) + } + _sendLogPayload(0x1c, 0x84); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + } + } + + function log(bool p0, bool p1, uint256 p2, uint256 p3) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + assembly { + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + // Selector of `log(bool,bool,uint256,uint256)`. + mstore(0x00, 0x0bb00eab) + mstore(0x20, p0) + mstore(0x40, p1) + mstore(0x60, p2) + mstore(0x80, p3) + } + _sendLogPayload(0x1c, 0x84); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + } + } + + function log(bool p0, bool p1, uint256 p2, bytes32 p3) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + bytes32 m5; + bytes32 m6; + assembly { + function writeString(pos, w) { + let length := 0 + for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } + mstore(pos, length) + let shift := sub(256, shl(3, length)) + mstore(add(pos, 0x20), shl(shift, shr(shift, w))) + } + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + m5 := mload(0xa0) + m6 := mload(0xc0) + // Selector of `log(bool,bool,uint256,string)`. + mstore(0x00, 0x7dd4d0e0) + mstore(0x20, p0) + mstore(0x40, p1) + mstore(0x60, p2) + mstore(0x80, 0x80) + writeString(0xa0, p3) + } + _sendLogPayload(0x1c, 0xc4); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + mstore(0xa0, m5) + mstore(0xc0, m6) + } + } + + function log(bool p0, bool p1, bytes32 p2, address p3) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + bytes32 m5; + bytes32 m6; + assembly { + function writeString(pos, w) { + let length := 0 + for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } + mstore(pos, length) + let shift := sub(256, shl(3, length)) + mstore(add(pos, 0x20), shl(shift, shr(shift, w))) + } + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + m5 := mload(0xa0) + m6 := mload(0xc0) + // Selector of `log(bool,bool,string,address)`. + mstore(0x00, 0xf9ad2b89) + mstore(0x20, p0) + mstore(0x40, p1) + mstore(0x60, 0x80) + mstore(0x80, p3) + writeString(0xa0, p2) + } + _sendLogPayload(0x1c, 0xc4); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + mstore(0xa0, m5) + mstore(0xc0, m6) + } + } + + function log(bool p0, bool p1, bytes32 p2, bool p3) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + bytes32 m5; + bytes32 m6; + assembly { + function writeString(pos, w) { + let length := 0 + for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } + mstore(pos, length) + let shift := sub(256, shl(3, length)) + mstore(add(pos, 0x20), shl(shift, shr(shift, w))) + } + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + m5 := mload(0xa0) + m6 := mload(0xc0) + // Selector of `log(bool,bool,string,bool)`. + mstore(0x00, 0xb857163a) + mstore(0x20, p0) + mstore(0x40, p1) + mstore(0x60, 0x80) + mstore(0x80, p3) + writeString(0xa0, p2) + } + _sendLogPayload(0x1c, 0xc4); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + mstore(0xa0, m5) + mstore(0xc0, m6) + } + } + + function log(bool p0, bool p1, bytes32 p2, uint256 p3) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + bytes32 m5; + bytes32 m6; + assembly { + function writeString(pos, w) { + let length := 0 + for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } + mstore(pos, length) + let shift := sub(256, shl(3, length)) + mstore(add(pos, 0x20), shl(shift, shr(shift, w))) + } + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + m5 := mload(0xa0) + m6 := mload(0xc0) + // Selector of `log(bool,bool,string,uint256)`. + mstore(0x00, 0xe3a9ca2f) + mstore(0x20, p0) + mstore(0x40, p1) + mstore(0x60, 0x80) + mstore(0x80, p3) + writeString(0xa0, p2) + } + _sendLogPayload(0x1c, 0xc4); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + mstore(0xa0, m5) + mstore(0xc0, m6) + } + } + + function log(bool p0, bool p1, bytes32 p2, bytes32 p3) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + bytes32 m5; + bytes32 m6; + bytes32 m7; + bytes32 m8; + assembly { + function writeString(pos, w) { + let length := 0 + for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } + mstore(pos, length) + let shift := sub(256, shl(3, length)) + mstore(add(pos, 0x20), shl(shift, shr(shift, w))) + } + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + m5 := mload(0xa0) + m6 := mload(0xc0) + m7 := mload(0xe0) + m8 := mload(0x100) + // Selector of `log(bool,bool,string,string)`. + mstore(0x00, 0x6d1e8751) + mstore(0x20, p0) + mstore(0x40, p1) + mstore(0x60, 0x80) + mstore(0x80, 0xc0) + writeString(0xa0, p2) + writeString(0xe0, p3) + } + _sendLogPayload(0x1c, 0x104); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + mstore(0xa0, m5) + mstore(0xc0, m6) + mstore(0xe0, m7) + mstore(0x100, m8) + } + } + + function log(bool p0, uint256 p1, address p2, address p3) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + assembly { + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + // Selector of `log(bool,uint256,address,address)`. + mstore(0x00, 0x26f560a8) + mstore(0x20, p0) + mstore(0x40, p1) + mstore(0x60, p2) + mstore(0x80, p3) + } + _sendLogPayload(0x1c, 0x84); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + } + } + + function log(bool p0, uint256 p1, address p2, bool p3) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + assembly { + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + // Selector of `log(bool,uint256,address,bool)`. + mstore(0x00, 0xb4c314ff) + mstore(0x20, p0) + mstore(0x40, p1) + mstore(0x60, p2) + mstore(0x80, p3) + } + _sendLogPayload(0x1c, 0x84); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + } + } + + function log(bool p0, uint256 p1, address p2, uint256 p3) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + assembly { + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + // Selector of `log(bool,uint256,address,uint256)`. + mstore(0x00, 0x1537dc87) + mstore(0x20, p0) + mstore(0x40, p1) + mstore(0x60, p2) + mstore(0x80, p3) + } + _sendLogPayload(0x1c, 0x84); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + } + } + + function log(bool p0, uint256 p1, address p2, bytes32 p3) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + bytes32 m5; + bytes32 m6; + assembly { + function writeString(pos, w) { + let length := 0 + for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } + mstore(pos, length) + let shift := sub(256, shl(3, length)) + mstore(add(pos, 0x20), shl(shift, shr(shift, w))) + } + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + m5 := mload(0xa0) + m6 := mload(0xc0) + // Selector of `log(bool,uint256,address,string)`. + mstore(0x00, 0x1bb3b09a) + mstore(0x20, p0) + mstore(0x40, p1) + mstore(0x60, p2) + mstore(0x80, 0x80) + writeString(0xa0, p3) + } + _sendLogPayload(0x1c, 0xc4); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + mstore(0xa0, m5) + mstore(0xc0, m6) + } + } + + function log(bool p0, uint256 p1, bool p2, address p3) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + assembly { + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + // Selector of `log(bool,uint256,bool,address)`. + mstore(0x00, 0x9acd3616) + mstore(0x20, p0) + mstore(0x40, p1) + mstore(0x60, p2) + mstore(0x80, p3) + } + _sendLogPayload(0x1c, 0x84); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + } + } + + function log(bool p0, uint256 p1, bool p2, bool p3) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + assembly { + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + // Selector of `log(bool,uint256,bool,bool)`. + mstore(0x00, 0xceb5f4d7) + mstore(0x20, p0) + mstore(0x40, p1) + mstore(0x60, p2) + mstore(0x80, p3) + } + _sendLogPayload(0x1c, 0x84); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + } + } + + function log(bool p0, uint256 p1, bool p2, uint256 p3) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + assembly { + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + // Selector of `log(bool,uint256,bool,uint256)`. + mstore(0x00, 0x7f9bbca2) + mstore(0x20, p0) + mstore(0x40, p1) + mstore(0x60, p2) + mstore(0x80, p3) + } + _sendLogPayload(0x1c, 0x84); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + } + } + + function log(bool p0, uint256 p1, bool p2, bytes32 p3) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + bytes32 m5; + bytes32 m6; + assembly { + function writeString(pos, w) { + let length := 0 + for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } + mstore(pos, length) + let shift := sub(256, shl(3, length)) + mstore(add(pos, 0x20), shl(shift, shr(shift, w))) + } + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + m5 := mload(0xa0) + m6 := mload(0xc0) + // Selector of `log(bool,uint256,bool,string)`. + mstore(0x00, 0x9143dbb1) + mstore(0x20, p0) + mstore(0x40, p1) + mstore(0x60, p2) + mstore(0x80, 0x80) + writeString(0xa0, p3) + } + _sendLogPayload(0x1c, 0xc4); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + mstore(0xa0, m5) + mstore(0xc0, m6) + } + } + + function log(bool p0, uint256 p1, uint256 p2, address p3) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + assembly { + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + // Selector of `log(bool,uint256,uint256,address)`. + mstore(0x00, 0x00dd87b9) + mstore(0x20, p0) + mstore(0x40, p1) + mstore(0x60, p2) + mstore(0x80, p3) + } + _sendLogPayload(0x1c, 0x84); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + } + } + + function log(bool p0, uint256 p1, uint256 p2, bool p3) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + assembly { + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + // Selector of `log(bool,uint256,uint256,bool)`. + mstore(0x00, 0xbe984353) + mstore(0x20, p0) + mstore(0x40, p1) + mstore(0x60, p2) + mstore(0x80, p3) + } + _sendLogPayload(0x1c, 0x84); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + } + } + + function log(bool p0, uint256 p1, uint256 p2, uint256 p3) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + assembly { + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + // Selector of `log(bool,uint256,uint256,uint256)`. + mstore(0x00, 0x374bb4b2) + mstore(0x20, p0) + mstore(0x40, p1) + mstore(0x60, p2) + mstore(0x80, p3) + } + _sendLogPayload(0x1c, 0x84); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + } + } + + function log(bool p0, uint256 p1, uint256 p2, bytes32 p3) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + bytes32 m5; + bytes32 m6; + assembly { + function writeString(pos, w) { + let length := 0 + for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } + mstore(pos, length) + let shift := sub(256, shl(3, length)) + mstore(add(pos, 0x20), shl(shift, shr(shift, w))) + } + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + m5 := mload(0xa0) + m6 := mload(0xc0) + // Selector of `log(bool,uint256,uint256,string)`. + mstore(0x00, 0x8e69fb5d) + mstore(0x20, p0) + mstore(0x40, p1) + mstore(0x60, p2) + mstore(0x80, 0x80) + writeString(0xa0, p3) + } + _sendLogPayload(0x1c, 0xc4); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + mstore(0xa0, m5) + mstore(0xc0, m6) + } + } + + function log(bool p0, uint256 p1, bytes32 p2, address p3) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + bytes32 m5; + bytes32 m6; + assembly { + function writeString(pos, w) { + let length := 0 + for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } + mstore(pos, length) + let shift := sub(256, shl(3, length)) + mstore(add(pos, 0x20), shl(shift, shr(shift, w))) + } + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + m5 := mload(0xa0) + m6 := mload(0xc0) + // Selector of `log(bool,uint256,string,address)`. + mstore(0x00, 0xfedd1fff) + mstore(0x20, p0) + mstore(0x40, p1) + mstore(0x60, 0x80) + mstore(0x80, p3) + writeString(0xa0, p2) + } + _sendLogPayload(0x1c, 0xc4); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + mstore(0xa0, m5) + mstore(0xc0, m6) + } + } + + function log(bool p0, uint256 p1, bytes32 p2, bool p3) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + bytes32 m5; + bytes32 m6; + assembly { + function writeString(pos, w) { + let length := 0 + for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } + mstore(pos, length) + let shift := sub(256, shl(3, length)) + mstore(add(pos, 0x20), shl(shift, shr(shift, w))) + } + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + m5 := mload(0xa0) + m6 := mload(0xc0) + // Selector of `log(bool,uint256,string,bool)`. + mstore(0x00, 0xe5e70b2b) + mstore(0x20, p0) + mstore(0x40, p1) + mstore(0x60, 0x80) + mstore(0x80, p3) + writeString(0xa0, p2) + } + _sendLogPayload(0x1c, 0xc4); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + mstore(0xa0, m5) + mstore(0xc0, m6) + } + } + + function log(bool p0, uint256 p1, bytes32 p2, uint256 p3) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + bytes32 m5; + bytes32 m6; + assembly { + function writeString(pos, w) { + let length := 0 + for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } + mstore(pos, length) + let shift := sub(256, shl(3, length)) + mstore(add(pos, 0x20), shl(shift, shr(shift, w))) + } + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + m5 := mload(0xa0) + m6 := mload(0xc0) + // Selector of `log(bool,uint256,string,uint256)`. + mstore(0x00, 0x6a1199e2) + mstore(0x20, p0) + mstore(0x40, p1) + mstore(0x60, 0x80) + mstore(0x80, p3) + writeString(0xa0, p2) + } + _sendLogPayload(0x1c, 0xc4); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + mstore(0xa0, m5) + mstore(0xc0, m6) + } + } + + function log(bool p0, uint256 p1, bytes32 p2, bytes32 p3) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + bytes32 m5; + bytes32 m6; + bytes32 m7; + bytes32 m8; + assembly { + function writeString(pos, w) { + let length := 0 + for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } + mstore(pos, length) + let shift := sub(256, shl(3, length)) + mstore(add(pos, 0x20), shl(shift, shr(shift, w))) + } + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + m5 := mload(0xa0) + m6 := mload(0xc0) + m7 := mload(0xe0) + m8 := mload(0x100) + // Selector of `log(bool,uint256,string,string)`. + mstore(0x00, 0xf5bc2249) + mstore(0x20, p0) + mstore(0x40, p1) + mstore(0x60, 0x80) + mstore(0x80, 0xc0) + writeString(0xa0, p2) + writeString(0xe0, p3) + } + _sendLogPayload(0x1c, 0x104); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + mstore(0xa0, m5) + mstore(0xc0, m6) + mstore(0xe0, m7) + mstore(0x100, m8) + } + } + + function log(bool p0, bytes32 p1, address p2, address p3) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + bytes32 m5; + bytes32 m6; + assembly { + function writeString(pos, w) { + let length := 0 + for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } + mstore(pos, length) + let shift := sub(256, shl(3, length)) + mstore(add(pos, 0x20), shl(shift, shr(shift, w))) + } + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + m5 := mload(0xa0) + m6 := mload(0xc0) + // Selector of `log(bool,string,address,address)`. + mstore(0x00, 0x2b2b18dc) + mstore(0x20, p0) + mstore(0x40, 0x80) + mstore(0x60, p2) + mstore(0x80, p3) + writeString(0xa0, p1) + } + _sendLogPayload(0x1c, 0xc4); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + mstore(0xa0, m5) + mstore(0xc0, m6) + } + } + + function log(bool p0, bytes32 p1, address p2, bool p3) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + bytes32 m5; + bytes32 m6; + assembly { + function writeString(pos, w) { + let length := 0 + for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } + mstore(pos, length) + let shift := sub(256, shl(3, length)) + mstore(add(pos, 0x20), shl(shift, shr(shift, w))) + } + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + m5 := mload(0xa0) + m6 := mload(0xc0) + // Selector of `log(bool,string,address,bool)`. + mstore(0x00, 0x6dd434ca) + mstore(0x20, p0) + mstore(0x40, 0x80) + mstore(0x60, p2) + mstore(0x80, p3) + writeString(0xa0, p1) + } + _sendLogPayload(0x1c, 0xc4); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + mstore(0xa0, m5) + mstore(0xc0, m6) + } + } + + function log(bool p0, bytes32 p1, address p2, uint256 p3) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + bytes32 m5; + bytes32 m6; + assembly { + function writeString(pos, w) { + let length := 0 + for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } + mstore(pos, length) + let shift := sub(256, shl(3, length)) + mstore(add(pos, 0x20), shl(shift, shr(shift, w))) + } + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + m5 := mload(0xa0) + m6 := mload(0xc0) + // Selector of `log(bool,string,address,uint256)`. + mstore(0x00, 0xa5cada94) + mstore(0x20, p0) + mstore(0x40, 0x80) + mstore(0x60, p2) + mstore(0x80, p3) + writeString(0xa0, p1) + } + _sendLogPayload(0x1c, 0xc4); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + mstore(0xa0, m5) + mstore(0xc0, m6) + } + } + + function log(bool p0, bytes32 p1, address p2, bytes32 p3) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + bytes32 m5; + bytes32 m6; + bytes32 m7; + bytes32 m8; + assembly { + function writeString(pos, w) { + let length := 0 + for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } + mstore(pos, length) + let shift := sub(256, shl(3, length)) + mstore(add(pos, 0x20), shl(shift, shr(shift, w))) + } + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + m5 := mload(0xa0) + m6 := mload(0xc0) + m7 := mload(0xe0) + m8 := mload(0x100) + // Selector of `log(bool,string,address,string)`. + mstore(0x00, 0x12d6c788) + mstore(0x20, p0) + mstore(0x40, 0x80) + mstore(0x60, p2) + mstore(0x80, 0xc0) + writeString(0xa0, p1) + writeString(0xe0, p3) + } + _sendLogPayload(0x1c, 0x104); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + mstore(0xa0, m5) + mstore(0xc0, m6) + mstore(0xe0, m7) + mstore(0x100, m8) + } + } + + function log(bool p0, bytes32 p1, bool p2, address p3) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + bytes32 m5; + bytes32 m6; + assembly { + function writeString(pos, w) { + let length := 0 + for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } + mstore(pos, length) + let shift := sub(256, shl(3, length)) + mstore(add(pos, 0x20), shl(shift, shr(shift, w))) + } + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + m5 := mload(0xa0) + m6 := mload(0xc0) + // Selector of `log(bool,string,bool,address)`. + mstore(0x00, 0x538e06ab) + mstore(0x20, p0) + mstore(0x40, 0x80) + mstore(0x60, p2) + mstore(0x80, p3) + writeString(0xa0, p1) + } + _sendLogPayload(0x1c, 0xc4); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + mstore(0xa0, m5) + mstore(0xc0, m6) + } + } + + function log(bool p0, bytes32 p1, bool p2, bool p3) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + bytes32 m5; + bytes32 m6; + assembly { + function writeString(pos, w) { + let length := 0 + for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } + mstore(pos, length) + let shift := sub(256, shl(3, length)) + mstore(add(pos, 0x20), shl(shift, shr(shift, w))) + } + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + m5 := mload(0xa0) + m6 := mload(0xc0) + // Selector of `log(bool,string,bool,bool)`. + mstore(0x00, 0xdc5e935b) + mstore(0x20, p0) + mstore(0x40, 0x80) + mstore(0x60, p2) + mstore(0x80, p3) + writeString(0xa0, p1) + } + _sendLogPayload(0x1c, 0xc4); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + mstore(0xa0, m5) + mstore(0xc0, m6) + } + } + + function log(bool p0, bytes32 p1, bool p2, uint256 p3) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + bytes32 m5; + bytes32 m6; + assembly { + function writeString(pos, w) { + let length := 0 + for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } + mstore(pos, length) + let shift := sub(256, shl(3, length)) + mstore(add(pos, 0x20), shl(shift, shr(shift, w))) + } + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + m5 := mload(0xa0) + m6 := mload(0xc0) + // Selector of `log(bool,string,bool,uint256)`. + mstore(0x00, 0x1606a393) + mstore(0x20, p0) + mstore(0x40, 0x80) + mstore(0x60, p2) + mstore(0x80, p3) + writeString(0xa0, p1) + } + _sendLogPayload(0x1c, 0xc4); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + mstore(0xa0, m5) + mstore(0xc0, m6) + } + } + + function log(bool p0, bytes32 p1, bool p2, bytes32 p3) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + bytes32 m5; + bytes32 m6; + bytes32 m7; + bytes32 m8; + assembly { + function writeString(pos, w) { + let length := 0 + for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } + mstore(pos, length) + let shift := sub(256, shl(3, length)) + mstore(add(pos, 0x20), shl(shift, shr(shift, w))) + } + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + m5 := mload(0xa0) + m6 := mload(0xc0) + m7 := mload(0xe0) + m8 := mload(0x100) + // Selector of `log(bool,string,bool,string)`. + mstore(0x00, 0x483d0416) + mstore(0x20, p0) + mstore(0x40, 0x80) + mstore(0x60, p2) + mstore(0x80, 0xc0) + writeString(0xa0, p1) + writeString(0xe0, p3) + } + _sendLogPayload(0x1c, 0x104); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + mstore(0xa0, m5) + mstore(0xc0, m6) + mstore(0xe0, m7) + mstore(0x100, m8) + } + } + + function log(bool p0, bytes32 p1, uint256 p2, address p3) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + bytes32 m5; + bytes32 m6; + assembly { + function writeString(pos, w) { + let length := 0 + for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } + mstore(pos, length) + let shift := sub(256, shl(3, length)) + mstore(add(pos, 0x20), shl(shift, shr(shift, w))) + } + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + m5 := mload(0xa0) + m6 := mload(0xc0) + // Selector of `log(bool,string,uint256,address)`. + mstore(0x00, 0x1596a1ce) + mstore(0x20, p0) + mstore(0x40, 0x80) + mstore(0x60, p2) + mstore(0x80, p3) + writeString(0xa0, p1) + } + _sendLogPayload(0x1c, 0xc4); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + mstore(0xa0, m5) + mstore(0xc0, m6) + } + } + + function log(bool p0, bytes32 p1, uint256 p2, bool p3) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + bytes32 m5; + bytes32 m6; + assembly { + function writeString(pos, w) { + let length := 0 + for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } + mstore(pos, length) + let shift := sub(256, shl(3, length)) + mstore(add(pos, 0x20), shl(shift, shr(shift, w))) + } + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + m5 := mload(0xa0) + m6 := mload(0xc0) + // Selector of `log(bool,string,uint256,bool)`. + mstore(0x00, 0x6b0e5d53) + mstore(0x20, p0) + mstore(0x40, 0x80) + mstore(0x60, p2) + mstore(0x80, p3) + writeString(0xa0, p1) + } + _sendLogPayload(0x1c, 0xc4); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + mstore(0xa0, m5) + mstore(0xc0, m6) + } + } + + function log(bool p0, bytes32 p1, uint256 p2, uint256 p3) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + bytes32 m5; + bytes32 m6; + assembly { + function writeString(pos, w) { + let length := 0 + for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } + mstore(pos, length) + let shift := sub(256, shl(3, length)) + mstore(add(pos, 0x20), shl(shift, shr(shift, w))) + } + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + m5 := mload(0xa0) + m6 := mload(0xc0) + // Selector of `log(bool,string,uint256,uint256)`. + mstore(0x00, 0x28863fcb) + mstore(0x20, p0) + mstore(0x40, 0x80) + mstore(0x60, p2) + mstore(0x80, p3) + writeString(0xa0, p1) + } + _sendLogPayload(0x1c, 0xc4); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + mstore(0xa0, m5) + mstore(0xc0, m6) + } + } + + function log(bool p0, bytes32 p1, uint256 p2, bytes32 p3) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + bytes32 m5; + bytes32 m6; + bytes32 m7; + bytes32 m8; + assembly { + function writeString(pos, w) { + let length := 0 + for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } + mstore(pos, length) + let shift := sub(256, shl(3, length)) + mstore(add(pos, 0x20), shl(shift, shr(shift, w))) + } + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + m5 := mload(0xa0) + m6 := mload(0xc0) + m7 := mload(0xe0) + m8 := mload(0x100) + // Selector of `log(bool,string,uint256,string)`. + mstore(0x00, 0x1ad96de6) + mstore(0x20, p0) + mstore(0x40, 0x80) + mstore(0x60, p2) + mstore(0x80, 0xc0) + writeString(0xa0, p1) + writeString(0xe0, p3) + } + _sendLogPayload(0x1c, 0x104); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + mstore(0xa0, m5) + mstore(0xc0, m6) + mstore(0xe0, m7) + mstore(0x100, m8) + } + } + + function log(bool p0, bytes32 p1, bytes32 p2, address p3) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + bytes32 m5; + bytes32 m6; + bytes32 m7; + bytes32 m8; + assembly { + function writeString(pos, w) { + let length := 0 + for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } + mstore(pos, length) + let shift := sub(256, shl(3, length)) + mstore(add(pos, 0x20), shl(shift, shr(shift, w))) + } + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + m5 := mload(0xa0) + m6 := mload(0xc0) + m7 := mload(0xe0) + m8 := mload(0x100) + // Selector of `log(bool,string,string,address)`. + mstore(0x00, 0x97d394d8) + mstore(0x20, p0) + mstore(0x40, 0x80) + mstore(0x60, 0xc0) + mstore(0x80, p3) + writeString(0xa0, p1) + writeString(0xe0, p2) + } + _sendLogPayload(0x1c, 0x104); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + mstore(0xa0, m5) + mstore(0xc0, m6) + mstore(0xe0, m7) + mstore(0x100, m8) + } + } + + function log(bool p0, bytes32 p1, bytes32 p2, bool p3) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + bytes32 m5; + bytes32 m6; + bytes32 m7; + bytes32 m8; + assembly { + function writeString(pos, w) { + let length := 0 + for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } + mstore(pos, length) + let shift := sub(256, shl(3, length)) + mstore(add(pos, 0x20), shl(shift, shr(shift, w))) + } + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + m5 := mload(0xa0) + m6 := mload(0xc0) + m7 := mload(0xe0) + m8 := mload(0x100) + // Selector of `log(bool,string,string,bool)`. + mstore(0x00, 0x1e4b87e5) + mstore(0x20, p0) + mstore(0x40, 0x80) + mstore(0x60, 0xc0) + mstore(0x80, p3) + writeString(0xa0, p1) + writeString(0xe0, p2) + } + _sendLogPayload(0x1c, 0x104); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + mstore(0xa0, m5) + mstore(0xc0, m6) + mstore(0xe0, m7) + mstore(0x100, m8) + } + } + + function log(bool p0, bytes32 p1, bytes32 p2, uint256 p3) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + bytes32 m5; + bytes32 m6; + bytes32 m7; + bytes32 m8; + assembly { + function writeString(pos, w) { + let length := 0 + for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } + mstore(pos, length) + let shift := sub(256, shl(3, length)) + mstore(add(pos, 0x20), shl(shift, shr(shift, w))) + } + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + m5 := mload(0xa0) + m6 := mload(0xc0) + m7 := mload(0xe0) + m8 := mload(0x100) + // Selector of `log(bool,string,string,uint256)`. + mstore(0x00, 0x7be0c3eb) + mstore(0x20, p0) + mstore(0x40, 0x80) + mstore(0x60, 0xc0) + mstore(0x80, p3) + writeString(0xa0, p1) + writeString(0xe0, p2) + } + _sendLogPayload(0x1c, 0x104); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + mstore(0xa0, m5) + mstore(0xc0, m6) + mstore(0xe0, m7) + mstore(0x100, m8) + } + } + + function log(bool p0, bytes32 p1, bytes32 p2, bytes32 p3) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + bytes32 m5; + bytes32 m6; + bytes32 m7; + bytes32 m8; + bytes32 m9; + bytes32 m10; + assembly { + function writeString(pos, w) { + let length := 0 + for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } + mstore(pos, length) + let shift := sub(256, shl(3, length)) + mstore(add(pos, 0x20), shl(shift, shr(shift, w))) + } + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + m5 := mload(0xa0) + m6 := mload(0xc0) + m7 := mload(0xe0) + m8 := mload(0x100) + m9 := mload(0x120) + m10 := mload(0x140) + // Selector of `log(bool,string,string,string)`. + mstore(0x00, 0x1762e32a) + mstore(0x20, p0) + mstore(0x40, 0x80) + mstore(0x60, 0xc0) + mstore(0x80, 0x100) + writeString(0xa0, p1) + writeString(0xe0, p2) + writeString(0x120, p3) + } + _sendLogPayload(0x1c, 0x144); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + mstore(0xa0, m5) + mstore(0xc0, m6) + mstore(0xe0, m7) + mstore(0x100, m8) + mstore(0x120, m9) + mstore(0x140, m10) + } + } + + function log(uint256 p0, address p1, address p2, address p3) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + assembly { + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + // Selector of `log(uint256,address,address,address)`. + mstore(0x00, 0x2488b414) + mstore(0x20, p0) + mstore(0x40, p1) + mstore(0x60, p2) + mstore(0x80, p3) + } + _sendLogPayload(0x1c, 0x84); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + } + } + + function log(uint256 p0, address p1, address p2, bool p3) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + assembly { + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + // Selector of `log(uint256,address,address,bool)`. + mstore(0x00, 0x091ffaf5) + mstore(0x20, p0) + mstore(0x40, p1) + mstore(0x60, p2) + mstore(0x80, p3) + } + _sendLogPayload(0x1c, 0x84); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + } + } + + function log(uint256 p0, address p1, address p2, uint256 p3) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + assembly { + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + // Selector of `log(uint256,address,address,uint256)`. + mstore(0x00, 0x736efbb6) + mstore(0x20, p0) + mstore(0x40, p1) + mstore(0x60, p2) + mstore(0x80, p3) + } + _sendLogPayload(0x1c, 0x84); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + } + } + + function log(uint256 p0, address p1, address p2, bytes32 p3) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + bytes32 m5; + bytes32 m6; + assembly { + function writeString(pos, w) { + let length := 0 + for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } + mstore(pos, length) + let shift := sub(256, shl(3, length)) + mstore(add(pos, 0x20), shl(shift, shr(shift, w))) + } + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + m5 := mload(0xa0) + m6 := mload(0xc0) + // Selector of `log(uint256,address,address,string)`. + mstore(0x00, 0x031c6f73) + mstore(0x20, p0) + mstore(0x40, p1) + mstore(0x60, p2) + mstore(0x80, 0x80) + writeString(0xa0, p3) + } + _sendLogPayload(0x1c, 0xc4); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + mstore(0xa0, m5) + mstore(0xc0, m6) + } + } + + function log(uint256 p0, address p1, bool p2, address p3) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + assembly { + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + // Selector of `log(uint256,address,bool,address)`. + mstore(0x00, 0xef72c513) + mstore(0x20, p0) + mstore(0x40, p1) + mstore(0x60, p2) + mstore(0x80, p3) + } + _sendLogPayload(0x1c, 0x84); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + } + } + + function log(uint256 p0, address p1, bool p2, bool p3) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + assembly { + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + // Selector of `log(uint256,address,bool,bool)`. + mstore(0x00, 0xe351140f) + mstore(0x20, p0) + mstore(0x40, p1) + mstore(0x60, p2) + mstore(0x80, p3) + } + _sendLogPayload(0x1c, 0x84); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + } + } + + function log(uint256 p0, address p1, bool p2, uint256 p3) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + assembly { + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + // Selector of `log(uint256,address,bool,uint256)`. + mstore(0x00, 0x5abd992a) + mstore(0x20, p0) + mstore(0x40, p1) + mstore(0x60, p2) + mstore(0x80, p3) + } + _sendLogPayload(0x1c, 0x84); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + } + } + + function log(uint256 p0, address p1, bool p2, bytes32 p3) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + bytes32 m5; + bytes32 m6; + assembly { + function writeString(pos, w) { + let length := 0 + for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } + mstore(pos, length) + let shift := sub(256, shl(3, length)) + mstore(add(pos, 0x20), shl(shift, shr(shift, w))) + } + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + m5 := mload(0xa0) + m6 := mload(0xc0) + // Selector of `log(uint256,address,bool,string)`. + mstore(0x00, 0x90fb06aa) + mstore(0x20, p0) + mstore(0x40, p1) + mstore(0x60, p2) + mstore(0x80, 0x80) + writeString(0xa0, p3) + } + _sendLogPayload(0x1c, 0xc4); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + mstore(0xa0, m5) + mstore(0xc0, m6) + } + } + + function log(uint256 p0, address p1, uint256 p2, address p3) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + assembly { + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + // Selector of `log(uint256,address,uint256,address)`. + mstore(0x00, 0x15c127b5) + mstore(0x20, p0) + mstore(0x40, p1) + mstore(0x60, p2) + mstore(0x80, p3) + } + _sendLogPayload(0x1c, 0x84); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + } + } + + function log(uint256 p0, address p1, uint256 p2, bool p3) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + assembly { + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + // Selector of `log(uint256,address,uint256,bool)`. + mstore(0x00, 0x5f743a7c) + mstore(0x20, p0) + mstore(0x40, p1) + mstore(0x60, p2) + mstore(0x80, p3) + } + _sendLogPayload(0x1c, 0x84); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + } + } + + function log(uint256 p0, address p1, uint256 p2, uint256 p3) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + assembly { + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + // Selector of `log(uint256,address,uint256,uint256)`. + mstore(0x00, 0x0c9cd9c1) + mstore(0x20, p0) + mstore(0x40, p1) + mstore(0x60, p2) + mstore(0x80, p3) + } + _sendLogPayload(0x1c, 0x84); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + } + } + + function log(uint256 p0, address p1, uint256 p2, bytes32 p3) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + bytes32 m5; + bytes32 m6; + assembly { + function writeString(pos, w) { + let length := 0 + for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } + mstore(pos, length) + let shift := sub(256, shl(3, length)) + mstore(add(pos, 0x20), shl(shift, shr(shift, w))) + } + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + m5 := mload(0xa0) + m6 := mload(0xc0) + // Selector of `log(uint256,address,uint256,string)`. + mstore(0x00, 0xddb06521) + mstore(0x20, p0) + mstore(0x40, p1) + mstore(0x60, p2) + mstore(0x80, 0x80) + writeString(0xa0, p3) + } + _sendLogPayload(0x1c, 0xc4); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + mstore(0xa0, m5) + mstore(0xc0, m6) + } + } + + function log(uint256 p0, address p1, bytes32 p2, address p3) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + bytes32 m5; + bytes32 m6; + assembly { + function writeString(pos, w) { + let length := 0 + for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } + mstore(pos, length) + let shift := sub(256, shl(3, length)) + mstore(add(pos, 0x20), shl(shift, shr(shift, w))) + } + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + m5 := mload(0xa0) + m6 := mload(0xc0) + // Selector of `log(uint256,address,string,address)`. + mstore(0x00, 0x9cba8fff) + mstore(0x20, p0) + mstore(0x40, p1) + mstore(0x60, 0x80) + mstore(0x80, p3) + writeString(0xa0, p2) + } + _sendLogPayload(0x1c, 0xc4); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + mstore(0xa0, m5) + mstore(0xc0, m6) + } + } + + function log(uint256 p0, address p1, bytes32 p2, bool p3) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + bytes32 m5; + bytes32 m6; + assembly { + function writeString(pos, w) { + let length := 0 + for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } + mstore(pos, length) + let shift := sub(256, shl(3, length)) + mstore(add(pos, 0x20), shl(shift, shr(shift, w))) + } + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + m5 := mload(0xa0) + m6 := mload(0xc0) + // Selector of `log(uint256,address,string,bool)`. + mstore(0x00, 0xcc32ab07) + mstore(0x20, p0) + mstore(0x40, p1) + mstore(0x60, 0x80) + mstore(0x80, p3) + writeString(0xa0, p2) + } + _sendLogPayload(0x1c, 0xc4); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + mstore(0xa0, m5) + mstore(0xc0, m6) + } + } + + function log(uint256 p0, address p1, bytes32 p2, uint256 p3) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + bytes32 m5; + bytes32 m6; + assembly { + function writeString(pos, w) { + let length := 0 + for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } + mstore(pos, length) + let shift := sub(256, shl(3, length)) + mstore(add(pos, 0x20), shl(shift, shr(shift, w))) + } + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + m5 := mload(0xa0) + m6 := mload(0xc0) + // Selector of `log(uint256,address,string,uint256)`. + mstore(0x00, 0x46826b5d) + mstore(0x20, p0) + mstore(0x40, p1) + mstore(0x60, 0x80) + mstore(0x80, p3) + writeString(0xa0, p2) + } + _sendLogPayload(0x1c, 0xc4); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + mstore(0xa0, m5) + mstore(0xc0, m6) + } + } + + function log(uint256 p0, address p1, bytes32 p2, bytes32 p3) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + bytes32 m5; + bytes32 m6; + bytes32 m7; + bytes32 m8; + assembly { + function writeString(pos, w) { + let length := 0 + for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } + mstore(pos, length) + let shift := sub(256, shl(3, length)) + mstore(add(pos, 0x20), shl(shift, shr(shift, w))) + } + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + m5 := mload(0xa0) + m6 := mload(0xc0) + m7 := mload(0xe0) + m8 := mload(0x100) + // Selector of `log(uint256,address,string,string)`. + mstore(0x00, 0x3e128ca3) + mstore(0x20, p0) + mstore(0x40, p1) + mstore(0x60, 0x80) + mstore(0x80, 0xc0) + writeString(0xa0, p2) + writeString(0xe0, p3) + } + _sendLogPayload(0x1c, 0x104); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + mstore(0xa0, m5) + mstore(0xc0, m6) + mstore(0xe0, m7) + mstore(0x100, m8) + } + } + + function log(uint256 p0, bool p1, address p2, address p3) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + assembly { + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + // Selector of `log(uint256,bool,address,address)`. + mstore(0x00, 0xa1ef4cbb) + mstore(0x20, p0) + mstore(0x40, p1) + mstore(0x60, p2) + mstore(0x80, p3) + } + _sendLogPayload(0x1c, 0x84); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + } + } + + function log(uint256 p0, bool p1, address p2, bool p3) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + assembly { + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + // Selector of `log(uint256,bool,address,bool)`. + mstore(0x00, 0x454d54a5) + mstore(0x20, p0) + mstore(0x40, p1) + mstore(0x60, p2) + mstore(0x80, p3) + } + _sendLogPayload(0x1c, 0x84); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + } + } + + function log(uint256 p0, bool p1, address p2, uint256 p3) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + assembly { + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + // Selector of `log(uint256,bool,address,uint256)`. + mstore(0x00, 0x078287f5) + mstore(0x20, p0) + mstore(0x40, p1) + mstore(0x60, p2) + mstore(0x80, p3) + } + _sendLogPayload(0x1c, 0x84); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + } + } + + function log(uint256 p0, bool p1, address p2, bytes32 p3) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + bytes32 m5; + bytes32 m6; + assembly { + function writeString(pos, w) { + let length := 0 + for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } + mstore(pos, length) + let shift := sub(256, shl(3, length)) + mstore(add(pos, 0x20), shl(shift, shr(shift, w))) + } + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + m5 := mload(0xa0) + m6 := mload(0xc0) + // Selector of `log(uint256,bool,address,string)`. + mstore(0x00, 0xade052c7) + mstore(0x20, p0) + mstore(0x40, p1) + mstore(0x60, p2) + mstore(0x80, 0x80) + writeString(0xa0, p3) + } + _sendLogPayload(0x1c, 0xc4); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + mstore(0xa0, m5) + mstore(0xc0, m6) + } + } + + function log(uint256 p0, bool p1, bool p2, address p3) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + assembly { + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + // Selector of `log(uint256,bool,bool,address)`. + mstore(0x00, 0x69640b59) + mstore(0x20, p0) + mstore(0x40, p1) + mstore(0x60, p2) + mstore(0x80, p3) + } + _sendLogPayload(0x1c, 0x84); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + } + } + + function log(uint256 p0, bool p1, bool p2, bool p3) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + assembly { + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + // Selector of `log(uint256,bool,bool,bool)`. + mstore(0x00, 0xb6f577a1) + mstore(0x20, p0) + mstore(0x40, p1) + mstore(0x60, p2) + mstore(0x80, p3) + } + _sendLogPayload(0x1c, 0x84); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + } + } + + function log(uint256 p0, bool p1, bool p2, uint256 p3) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + assembly { + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + // Selector of `log(uint256,bool,bool,uint256)`. + mstore(0x00, 0x7464ce23) + mstore(0x20, p0) + mstore(0x40, p1) + mstore(0x60, p2) + mstore(0x80, p3) + } + _sendLogPayload(0x1c, 0x84); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + } + } + + function log(uint256 p0, bool p1, bool p2, bytes32 p3) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + bytes32 m5; + bytes32 m6; + assembly { + function writeString(pos, w) { + let length := 0 + for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } + mstore(pos, length) + let shift := sub(256, shl(3, length)) + mstore(add(pos, 0x20), shl(shift, shr(shift, w))) + } + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + m5 := mload(0xa0) + m6 := mload(0xc0) + // Selector of `log(uint256,bool,bool,string)`. + mstore(0x00, 0xdddb9561) + mstore(0x20, p0) + mstore(0x40, p1) + mstore(0x60, p2) + mstore(0x80, 0x80) + writeString(0xa0, p3) + } + _sendLogPayload(0x1c, 0xc4); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + mstore(0xa0, m5) + mstore(0xc0, m6) + } + } + + function log(uint256 p0, bool p1, uint256 p2, address p3) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + assembly { + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + // Selector of `log(uint256,bool,uint256,address)`. + mstore(0x00, 0x88cb6041) + mstore(0x20, p0) + mstore(0x40, p1) + mstore(0x60, p2) + mstore(0x80, p3) + } + _sendLogPayload(0x1c, 0x84); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + } + } + + function log(uint256 p0, bool p1, uint256 p2, bool p3) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + assembly { + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + // Selector of `log(uint256,bool,uint256,bool)`. + mstore(0x00, 0x91a02e2a) + mstore(0x20, p0) + mstore(0x40, p1) + mstore(0x60, p2) + mstore(0x80, p3) + } + _sendLogPayload(0x1c, 0x84); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + } + } + + function log(uint256 p0, bool p1, uint256 p2, uint256 p3) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + assembly { + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + // Selector of `log(uint256,bool,uint256,uint256)`. + mstore(0x00, 0xc6acc7a8) + mstore(0x20, p0) + mstore(0x40, p1) + mstore(0x60, p2) + mstore(0x80, p3) + } + _sendLogPayload(0x1c, 0x84); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + } + } + + function log(uint256 p0, bool p1, uint256 p2, bytes32 p3) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + bytes32 m5; + bytes32 m6; + assembly { + function writeString(pos, w) { + let length := 0 + for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } + mstore(pos, length) + let shift := sub(256, shl(3, length)) + mstore(add(pos, 0x20), shl(shift, shr(shift, w))) + } + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + m5 := mload(0xa0) + m6 := mload(0xc0) + // Selector of `log(uint256,bool,uint256,string)`. + mstore(0x00, 0xde03e774) + mstore(0x20, p0) + mstore(0x40, p1) + mstore(0x60, p2) + mstore(0x80, 0x80) + writeString(0xa0, p3) + } + _sendLogPayload(0x1c, 0xc4); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + mstore(0xa0, m5) + mstore(0xc0, m6) + } + } + + function log(uint256 p0, bool p1, bytes32 p2, address p3) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + bytes32 m5; + bytes32 m6; + assembly { + function writeString(pos, w) { + let length := 0 + for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } + mstore(pos, length) + let shift := sub(256, shl(3, length)) + mstore(add(pos, 0x20), shl(shift, shr(shift, w))) + } + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + m5 := mload(0xa0) + m6 := mload(0xc0) + // Selector of `log(uint256,bool,string,address)`. + mstore(0x00, 0xef529018) + mstore(0x20, p0) + mstore(0x40, p1) + mstore(0x60, 0x80) + mstore(0x80, p3) + writeString(0xa0, p2) + } + _sendLogPayload(0x1c, 0xc4); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + mstore(0xa0, m5) + mstore(0xc0, m6) + } + } + + function log(uint256 p0, bool p1, bytes32 p2, bool p3) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + bytes32 m5; + bytes32 m6; + assembly { + function writeString(pos, w) { + let length := 0 + for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } + mstore(pos, length) + let shift := sub(256, shl(3, length)) + mstore(add(pos, 0x20), shl(shift, shr(shift, w))) + } + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + m5 := mload(0xa0) + m6 := mload(0xc0) + // Selector of `log(uint256,bool,string,bool)`. + mstore(0x00, 0xeb928d7f) + mstore(0x20, p0) + mstore(0x40, p1) + mstore(0x60, 0x80) + mstore(0x80, p3) + writeString(0xa0, p2) + } + _sendLogPayload(0x1c, 0xc4); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + mstore(0xa0, m5) + mstore(0xc0, m6) + } + } + + function log(uint256 p0, bool p1, bytes32 p2, uint256 p3) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + bytes32 m5; + bytes32 m6; + assembly { + function writeString(pos, w) { + let length := 0 + for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } + mstore(pos, length) + let shift := sub(256, shl(3, length)) + mstore(add(pos, 0x20), shl(shift, shr(shift, w))) + } + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + m5 := mload(0xa0) + m6 := mload(0xc0) + // Selector of `log(uint256,bool,string,uint256)`. + mstore(0x00, 0x2c1d0746) + mstore(0x20, p0) + mstore(0x40, p1) + mstore(0x60, 0x80) + mstore(0x80, p3) + writeString(0xa0, p2) + } + _sendLogPayload(0x1c, 0xc4); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + mstore(0xa0, m5) + mstore(0xc0, m6) + } + } + + function log(uint256 p0, bool p1, bytes32 p2, bytes32 p3) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + bytes32 m5; + bytes32 m6; + bytes32 m7; + bytes32 m8; + assembly { + function writeString(pos, w) { + let length := 0 + for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } + mstore(pos, length) + let shift := sub(256, shl(3, length)) + mstore(add(pos, 0x20), shl(shift, shr(shift, w))) + } + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + m5 := mload(0xa0) + m6 := mload(0xc0) + m7 := mload(0xe0) + m8 := mload(0x100) + // Selector of `log(uint256,bool,string,string)`. + mstore(0x00, 0x68c8b8bd) + mstore(0x20, p0) + mstore(0x40, p1) + mstore(0x60, 0x80) + mstore(0x80, 0xc0) + writeString(0xa0, p2) + writeString(0xe0, p3) + } + _sendLogPayload(0x1c, 0x104); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + mstore(0xa0, m5) + mstore(0xc0, m6) + mstore(0xe0, m7) + mstore(0x100, m8) + } + } + + function log(uint256 p0, uint256 p1, address p2, address p3) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + assembly { + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + // Selector of `log(uint256,uint256,address,address)`. + mstore(0x00, 0x56a5d1b1) + mstore(0x20, p0) + mstore(0x40, p1) + mstore(0x60, p2) + mstore(0x80, p3) + } + _sendLogPayload(0x1c, 0x84); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + } + } + + function log(uint256 p0, uint256 p1, address p2, bool p3) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + assembly { + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + // Selector of `log(uint256,uint256,address,bool)`. + mstore(0x00, 0x15cac476) + mstore(0x20, p0) + mstore(0x40, p1) + mstore(0x60, p2) + mstore(0x80, p3) + } + _sendLogPayload(0x1c, 0x84); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + } + } + + function log(uint256 p0, uint256 p1, address p2, uint256 p3) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + assembly { + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + // Selector of `log(uint256,uint256,address,uint256)`. + mstore(0x00, 0x88f6e4b2) + mstore(0x20, p0) + mstore(0x40, p1) + mstore(0x60, p2) + mstore(0x80, p3) + } + _sendLogPayload(0x1c, 0x84); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + } + } + + function log(uint256 p0, uint256 p1, address p2, bytes32 p3) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + bytes32 m5; + bytes32 m6; + assembly { + function writeString(pos, w) { + let length := 0 + for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } + mstore(pos, length) + let shift := sub(256, shl(3, length)) + mstore(add(pos, 0x20), shl(shift, shr(shift, w))) + } + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + m5 := mload(0xa0) + m6 := mload(0xc0) + // Selector of `log(uint256,uint256,address,string)`. + mstore(0x00, 0x6cde40b8) + mstore(0x20, p0) + mstore(0x40, p1) + mstore(0x60, p2) + mstore(0x80, 0x80) + writeString(0xa0, p3) + } + _sendLogPayload(0x1c, 0xc4); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + mstore(0xa0, m5) + mstore(0xc0, m6) + } + } + + function log(uint256 p0, uint256 p1, bool p2, address p3) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + assembly { + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + // Selector of `log(uint256,uint256,bool,address)`. + mstore(0x00, 0x9a816a83) + mstore(0x20, p0) + mstore(0x40, p1) + mstore(0x60, p2) + mstore(0x80, p3) + } + _sendLogPayload(0x1c, 0x84); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + } + } + + function log(uint256 p0, uint256 p1, bool p2, bool p3) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + assembly { + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + // Selector of `log(uint256,uint256,bool,bool)`. + mstore(0x00, 0xab085ae6) + mstore(0x20, p0) + mstore(0x40, p1) + mstore(0x60, p2) + mstore(0x80, p3) + } + _sendLogPayload(0x1c, 0x84); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + } + } + + function log(uint256 p0, uint256 p1, bool p2, uint256 p3) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + assembly { + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + // Selector of `log(uint256,uint256,bool,uint256)`. + mstore(0x00, 0xeb7f6fd2) + mstore(0x20, p0) + mstore(0x40, p1) + mstore(0x60, p2) + mstore(0x80, p3) + } + _sendLogPayload(0x1c, 0x84); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + } + } + + function log(uint256 p0, uint256 p1, bool p2, bytes32 p3) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + bytes32 m5; + bytes32 m6; + assembly { + function writeString(pos, w) { + let length := 0 + for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } + mstore(pos, length) + let shift := sub(256, shl(3, length)) + mstore(add(pos, 0x20), shl(shift, shr(shift, w))) + } + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + m5 := mload(0xa0) + m6 := mload(0xc0) + // Selector of `log(uint256,uint256,bool,string)`. + mstore(0x00, 0xa5b4fc99) + mstore(0x20, p0) + mstore(0x40, p1) + mstore(0x60, p2) + mstore(0x80, 0x80) + writeString(0xa0, p3) + } + _sendLogPayload(0x1c, 0xc4); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + mstore(0xa0, m5) + mstore(0xc0, m6) + } + } + + function log(uint256 p0, uint256 p1, uint256 p2, address p3) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + assembly { + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + // Selector of `log(uint256,uint256,uint256,address)`. + mstore(0x00, 0xfa8185af) + mstore(0x20, p0) + mstore(0x40, p1) + mstore(0x60, p2) + mstore(0x80, p3) + } + _sendLogPayload(0x1c, 0x84); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + } + } + + function log(uint256 p0, uint256 p1, uint256 p2, bool p3) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + assembly { + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + // Selector of `log(uint256,uint256,uint256,bool)`. + mstore(0x00, 0xc598d185) + mstore(0x20, p0) + mstore(0x40, p1) + mstore(0x60, p2) + mstore(0x80, p3) + } + _sendLogPayload(0x1c, 0x84); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + } + } + + function log(uint256 p0, uint256 p1, uint256 p2, uint256 p3) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + assembly { + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + // Selector of `log(uint256,uint256,uint256,uint256)`. + mstore(0x00, 0x193fb800) + mstore(0x20, p0) + mstore(0x40, p1) + mstore(0x60, p2) + mstore(0x80, p3) + } + _sendLogPayload(0x1c, 0x84); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + } + } + + function log(uint256 p0, uint256 p1, uint256 p2, bytes32 p3) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + bytes32 m5; + bytes32 m6; + assembly { + function writeString(pos, w) { + let length := 0 + for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } + mstore(pos, length) + let shift := sub(256, shl(3, length)) + mstore(add(pos, 0x20), shl(shift, shr(shift, w))) + } + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + m5 := mload(0xa0) + m6 := mload(0xc0) + // Selector of `log(uint256,uint256,uint256,string)`. + mstore(0x00, 0x59cfcbe3) + mstore(0x20, p0) + mstore(0x40, p1) + mstore(0x60, p2) + mstore(0x80, 0x80) + writeString(0xa0, p3) + } + _sendLogPayload(0x1c, 0xc4); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + mstore(0xa0, m5) + mstore(0xc0, m6) + } + } + + function log(uint256 p0, uint256 p1, bytes32 p2, address p3) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + bytes32 m5; + bytes32 m6; + assembly { + function writeString(pos, w) { + let length := 0 + for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } + mstore(pos, length) + let shift := sub(256, shl(3, length)) + mstore(add(pos, 0x20), shl(shift, shr(shift, w))) + } + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + m5 := mload(0xa0) + m6 := mload(0xc0) + // Selector of `log(uint256,uint256,string,address)`. + mstore(0x00, 0x42d21db7) + mstore(0x20, p0) + mstore(0x40, p1) + mstore(0x60, 0x80) + mstore(0x80, p3) + writeString(0xa0, p2) + } + _sendLogPayload(0x1c, 0xc4); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + mstore(0xa0, m5) + mstore(0xc0, m6) + } + } + + function log(uint256 p0, uint256 p1, bytes32 p2, bool p3) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + bytes32 m5; + bytes32 m6; + assembly { + function writeString(pos, w) { + let length := 0 + for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } + mstore(pos, length) + let shift := sub(256, shl(3, length)) + mstore(add(pos, 0x20), shl(shift, shr(shift, w))) + } + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + m5 := mload(0xa0) + m6 := mload(0xc0) + // Selector of `log(uint256,uint256,string,bool)`. + mstore(0x00, 0x7af6ab25) + mstore(0x20, p0) + mstore(0x40, p1) + mstore(0x60, 0x80) + mstore(0x80, p3) + writeString(0xa0, p2) + } + _sendLogPayload(0x1c, 0xc4); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + mstore(0xa0, m5) + mstore(0xc0, m6) + } + } + + function log(uint256 p0, uint256 p1, bytes32 p2, uint256 p3) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + bytes32 m5; + bytes32 m6; + assembly { + function writeString(pos, w) { + let length := 0 + for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } + mstore(pos, length) + let shift := sub(256, shl(3, length)) + mstore(add(pos, 0x20), shl(shift, shr(shift, w))) + } + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + m5 := mload(0xa0) + m6 := mload(0xc0) + // Selector of `log(uint256,uint256,string,uint256)`. + mstore(0x00, 0x5da297eb) + mstore(0x20, p0) + mstore(0x40, p1) + mstore(0x60, 0x80) + mstore(0x80, p3) + writeString(0xa0, p2) + } + _sendLogPayload(0x1c, 0xc4); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + mstore(0xa0, m5) + mstore(0xc0, m6) + } + } + + function log(uint256 p0, uint256 p1, bytes32 p2, bytes32 p3) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + bytes32 m5; + bytes32 m6; + bytes32 m7; + bytes32 m8; + assembly { + function writeString(pos, w) { + let length := 0 + for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } + mstore(pos, length) + let shift := sub(256, shl(3, length)) + mstore(add(pos, 0x20), shl(shift, shr(shift, w))) + } + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + m5 := mload(0xa0) + m6 := mload(0xc0) + m7 := mload(0xe0) + m8 := mload(0x100) + // Selector of `log(uint256,uint256,string,string)`. + mstore(0x00, 0x27d8afd2) + mstore(0x20, p0) + mstore(0x40, p1) + mstore(0x60, 0x80) + mstore(0x80, 0xc0) + writeString(0xa0, p2) + writeString(0xe0, p3) + } + _sendLogPayload(0x1c, 0x104); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + mstore(0xa0, m5) + mstore(0xc0, m6) + mstore(0xe0, m7) + mstore(0x100, m8) + } + } + + function log(uint256 p0, bytes32 p1, address p2, address p3) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + bytes32 m5; + bytes32 m6; + assembly { + function writeString(pos, w) { + let length := 0 + for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } + mstore(pos, length) + let shift := sub(256, shl(3, length)) + mstore(add(pos, 0x20), shl(shift, shr(shift, w))) + } + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + m5 := mload(0xa0) + m6 := mload(0xc0) + // Selector of `log(uint256,string,address,address)`. + mstore(0x00, 0x6168ed61) + mstore(0x20, p0) + mstore(0x40, 0x80) + mstore(0x60, p2) + mstore(0x80, p3) + writeString(0xa0, p1) + } + _sendLogPayload(0x1c, 0xc4); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + mstore(0xa0, m5) + mstore(0xc0, m6) + } + } + + function log(uint256 p0, bytes32 p1, address p2, bool p3) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + bytes32 m5; + bytes32 m6; + assembly { + function writeString(pos, w) { + let length := 0 + for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } + mstore(pos, length) + let shift := sub(256, shl(3, length)) + mstore(add(pos, 0x20), shl(shift, shr(shift, w))) + } + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + m5 := mload(0xa0) + m6 := mload(0xc0) + // Selector of `log(uint256,string,address,bool)`. + mstore(0x00, 0x90c30a56) + mstore(0x20, p0) + mstore(0x40, 0x80) + mstore(0x60, p2) + mstore(0x80, p3) + writeString(0xa0, p1) + } + _sendLogPayload(0x1c, 0xc4); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + mstore(0xa0, m5) + mstore(0xc0, m6) + } + } + + function log(uint256 p0, bytes32 p1, address p2, uint256 p3) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + bytes32 m5; + bytes32 m6; + assembly { + function writeString(pos, w) { + let length := 0 + for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } + mstore(pos, length) + let shift := sub(256, shl(3, length)) + mstore(add(pos, 0x20), shl(shift, shr(shift, w))) + } + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + m5 := mload(0xa0) + m6 := mload(0xc0) + // Selector of `log(uint256,string,address,uint256)`. + mstore(0x00, 0xe8d3018d) + mstore(0x20, p0) + mstore(0x40, 0x80) + mstore(0x60, p2) + mstore(0x80, p3) + writeString(0xa0, p1) + } + _sendLogPayload(0x1c, 0xc4); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + mstore(0xa0, m5) + mstore(0xc0, m6) + } + } + + function log(uint256 p0, bytes32 p1, address p2, bytes32 p3) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + bytes32 m5; + bytes32 m6; + bytes32 m7; + bytes32 m8; + assembly { + function writeString(pos, w) { + let length := 0 + for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } + mstore(pos, length) + let shift := sub(256, shl(3, length)) + mstore(add(pos, 0x20), shl(shift, shr(shift, w))) + } + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + m5 := mload(0xa0) + m6 := mload(0xc0) + m7 := mload(0xe0) + m8 := mload(0x100) + // Selector of `log(uint256,string,address,string)`. + mstore(0x00, 0x9c3adfa1) + mstore(0x20, p0) + mstore(0x40, 0x80) + mstore(0x60, p2) + mstore(0x80, 0xc0) + writeString(0xa0, p1) + writeString(0xe0, p3) + } + _sendLogPayload(0x1c, 0x104); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + mstore(0xa0, m5) + mstore(0xc0, m6) + mstore(0xe0, m7) + mstore(0x100, m8) + } + } + + function log(uint256 p0, bytes32 p1, bool p2, address p3) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + bytes32 m5; + bytes32 m6; + assembly { + function writeString(pos, w) { + let length := 0 + for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } + mstore(pos, length) + let shift := sub(256, shl(3, length)) + mstore(add(pos, 0x20), shl(shift, shr(shift, w))) + } + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + m5 := mload(0xa0) + m6 := mload(0xc0) + // Selector of `log(uint256,string,bool,address)`. + mstore(0x00, 0xae2ec581) + mstore(0x20, p0) + mstore(0x40, 0x80) + mstore(0x60, p2) + mstore(0x80, p3) + writeString(0xa0, p1) + } + _sendLogPayload(0x1c, 0xc4); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + mstore(0xa0, m5) + mstore(0xc0, m6) + } + } + + function log(uint256 p0, bytes32 p1, bool p2, bool p3) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + bytes32 m5; + bytes32 m6; + assembly { + function writeString(pos, w) { + let length := 0 + for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } + mstore(pos, length) + let shift := sub(256, shl(3, length)) + mstore(add(pos, 0x20), shl(shift, shr(shift, w))) + } + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + m5 := mload(0xa0) + m6 := mload(0xc0) + // Selector of `log(uint256,string,bool,bool)`. + mstore(0x00, 0xba535d9c) + mstore(0x20, p0) + mstore(0x40, 0x80) + mstore(0x60, p2) + mstore(0x80, p3) + writeString(0xa0, p1) + } + _sendLogPayload(0x1c, 0xc4); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + mstore(0xa0, m5) + mstore(0xc0, m6) + } + } + + function log(uint256 p0, bytes32 p1, bool p2, uint256 p3) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + bytes32 m5; + bytes32 m6; + assembly { + function writeString(pos, w) { + let length := 0 + for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } + mstore(pos, length) + let shift := sub(256, shl(3, length)) + mstore(add(pos, 0x20), shl(shift, shr(shift, w))) + } + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + m5 := mload(0xa0) + m6 := mload(0xc0) + // Selector of `log(uint256,string,bool,uint256)`. + mstore(0x00, 0xcf009880) + mstore(0x20, p0) + mstore(0x40, 0x80) + mstore(0x60, p2) + mstore(0x80, p3) + writeString(0xa0, p1) + } + _sendLogPayload(0x1c, 0xc4); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + mstore(0xa0, m5) + mstore(0xc0, m6) + } + } + + function log(uint256 p0, bytes32 p1, bool p2, bytes32 p3) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + bytes32 m5; + bytes32 m6; + bytes32 m7; + bytes32 m8; + assembly { + function writeString(pos, w) { + let length := 0 + for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } + mstore(pos, length) + let shift := sub(256, shl(3, length)) + mstore(add(pos, 0x20), shl(shift, shr(shift, w))) + } + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + m5 := mload(0xa0) + m6 := mload(0xc0) + m7 := mload(0xe0) + m8 := mload(0x100) + // Selector of `log(uint256,string,bool,string)`. + mstore(0x00, 0xd2d423cd) + mstore(0x20, p0) + mstore(0x40, 0x80) + mstore(0x60, p2) + mstore(0x80, 0xc0) + writeString(0xa0, p1) + writeString(0xe0, p3) + } + _sendLogPayload(0x1c, 0x104); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + mstore(0xa0, m5) + mstore(0xc0, m6) + mstore(0xe0, m7) + mstore(0x100, m8) + } + } + + function log(uint256 p0, bytes32 p1, uint256 p2, address p3) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + bytes32 m5; + bytes32 m6; + assembly { + function writeString(pos, w) { + let length := 0 + for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } + mstore(pos, length) + let shift := sub(256, shl(3, length)) + mstore(add(pos, 0x20), shl(shift, shr(shift, w))) + } + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + m5 := mload(0xa0) + m6 := mload(0xc0) + // Selector of `log(uint256,string,uint256,address)`. + mstore(0x00, 0x3b2279b4) + mstore(0x20, p0) + mstore(0x40, 0x80) + mstore(0x60, p2) + mstore(0x80, p3) + writeString(0xa0, p1) + } + _sendLogPayload(0x1c, 0xc4); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + mstore(0xa0, m5) + mstore(0xc0, m6) + } + } + + function log(uint256 p0, bytes32 p1, uint256 p2, bool p3) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + bytes32 m5; + bytes32 m6; + assembly { + function writeString(pos, w) { + let length := 0 + for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } + mstore(pos, length) + let shift := sub(256, shl(3, length)) + mstore(add(pos, 0x20), shl(shift, shr(shift, w))) + } + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + m5 := mload(0xa0) + m6 := mload(0xc0) + // Selector of `log(uint256,string,uint256,bool)`. + mstore(0x00, 0x691a8f74) + mstore(0x20, p0) + mstore(0x40, 0x80) + mstore(0x60, p2) + mstore(0x80, p3) + writeString(0xa0, p1) + } + _sendLogPayload(0x1c, 0xc4); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + mstore(0xa0, m5) + mstore(0xc0, m6) + } + } + + function log(uint256 p0, bytes32 p1, uint256 p2, uint256 p3) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + bytes32 m5; + bytes32 m6; + assembly { + function writeString(pos, w) { + let length := 0 + for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } + mstore(pos, length) + let shift := sub(256, shl(3, length)) + mstore(add(pos, 0x20), shl(shift, shr(shift, w))) + } + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + m5 := mload(0xa0) + m6 := mload(0xc0) + // Selector of `log(uint256,string,uint256,uint256)`. + mstore(0x00, 0x82c25b74) + mstore(0x20, p0) + mstore(0x40, 0x80) + mstore(0x60, p2) + mstore(0x80, p3) + writeString(0xa0, p1) + } + _sendLogPayload(0x1c, 0xc4); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + mstore(0xa0, m5) + mstore(0xc0, m6) + } + } + + function log(uint256 p0, bytes32 p1, uint256 p2, bytes32 p3) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + bytes32 m5; + bytes32 m6; + bytes32 m7; + bytes32 m8; + assembly { + function writeString(pos, w) { + let length := 0 + for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } + mstore(pos, length) + let shift := sub(256, shl(3, length)) + mstore(add(pos, 0x20), shl(shift, shr(shift, w))) + } + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + m5 := mload(0xa0) + m6 := mload(0xc0) + m7 := mload(0xe0) + m8 := mload(0x100) + // Selector of `log(uint256,string,uint256,string)`. + mstore(0x00, 0xb7b914ca) + mstore(0x20, p0) + mstore(0x40, 0x80) + mstore(0x60, p2) + mstore(0x80, 0xc0) + writeString(0xa0, p1) + writeString(0xe0, p3) + } + _sendLogPayload(0x1c, 0x104); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + mstore(0xa0, m5) + mstore(0xc0, m6) + mstore(0xe0, m7) + mstore(0x100, m8) + } + } + + function log(uint256 p0, bytes32 p1, bytes32 p2, address p3) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + bytes32 m5; + bytes32 m6; + bytes32 m7; + bytes32 m8; + assembly { + function writeString(pos, w) { + let length := 0 + for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } + mstore(pos, length) + let shift := sub(256, shl(3, length)) + mstore(add(pos, 0x20), shl(shift, shr(shift, w))) + } + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + m5 := mload(0xa0) + m6 := mload(0xc0) + m7 := mload(0xe0) + m8 := mload(0x100) + // Selector of `log(uint256,string,string,address)`. + mstore(0x00, 0xd583c602) + mstore(0x20, p0) + mstore(0x40, 0x80) + mstore(0x60, 0xc0) + mstore(0x80, p3) + writeString(0xa0, p1) + writeString(0xe0, p2) + } + _sendLogPayload(0x1c, 0x104); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + mstore(0xa0, m5) + mstore(0xc0, m6) + mstore(0xe0, m7) + mstore(0x100, m8) + } + } + + function log(uint256 p0, bytes32 p1, bytes32 p2, bool p3) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + bytes32 m5; + bytes32 m6; + bytes32 m7; + bytes32 m8; + assembly { + function writeString(pos, w) { + let length := 0 + for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } + mstore(pos, length) + let shift := sub(256, shl(3, length)) + mstore(add(pos, 0x20), shl(shift, shr(shift, w))) + } + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + m5 := mload(0xa0) + m6 := mload(0xc0) + m7 := mload(0xe0) + m8 := mload(0x100) + // Selector of `log(uint256,string,string,bool)`. + mstore(0x00, 0xb3a6b6bd) + mstore(0x20, p0) + mstore(0x40, 0x80) + mstore(0x60, 0xc0) + mstore(0x80, p3) + writeString(0xa0, p1) + writeString(0xe0, p2) + } + _sendLogPayload(0x1c, 0x104); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + mstore(0xa0, m5) + mstore(0xc0, m6) + mstore(0xe0, m7) + mstore(0x100, m8) + } + } + + function log(uint256 p0, bytes32 p1, bytes32 p2, uint256 p3) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + bytes32 m5; + bytes32 m6; + bytes32 m7; + bytes32 m8; + assembly { + function writeString(pos, w) { + let length := 0 + for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } + mstore(pos, length) + let shift := sub(256, shl(3, length)) + mstore(add(pos, 0x20), shl(shift, shr(shift, w))) + } + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + m5 := mload(0xa0) + m6 := mload(0xc0) + m7 := mload(0xe0) + m8 := mload(0x100) + // Selector of `log(uint256,string,string,uint256)`. + mstore(0x00, 0xb028c9bd) + mstore(0x20, p0) + mstore(0x40, 0x80) + mstore(0x60, 0xc0) + mstore(0x80, p3) + writeString(0xa0, p1) + writeString(0xe0, p2) + } + _sendLogPayload(0x1c, 0x104); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + mstore(0xa0, m5) + mstore(0xc0, m6) + mstore(0xe0, m7) + mstore(0x100, m8) + } + } + + function log(uint256 p0, bytes32 p1, bytes32 p2, bytes32 p3) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + bytes32 m5; + bytes32 m6; + bytes32 m7; + bytes32 m8; + bytes32 m9; + bytes32 m10; + assembly { + function writeString(pos, w) { + let length := 0 + for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } + mstore(pos, length) + let shift := sub(256, shl(3, length)) + mstore(add(pos, 0x20), shl(shift, shr(shift, w))) + } + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + m5 := mload(0xa0) + m6 := mload(0xc0) + m7 := mload(0xe0) + m8 := mload(0x100) + m9 := mload(0x120) + m10 := mload(0x140) + // Selector of `log(uint256,string,string,string)`. + mstore(0x00, 0x21ad0683) + mstore(0x20, p0) + mstore(0x40, 0x80) + mstore(0x60, 0xc0) + mstore(0x80, 0x100) + writeString(0xa0, p1) + writeString(0xe0, p2) + writeString(0x120, p3) + } + _sendLogPayload(0x1c, 0x144); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + mstore(0xa0, m5) + mstore(0xc0, m6) + mstore(0xe0, m7) + mstore(0x100, m8) + mstore(0x120, m9) + mstore(0x140, m10) + } + } + + function log(bytes32 p0, address p1, address p2, address p3) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + bytes32 m5; + bytes32 m6; + assembly { + function writeString(pos, w) { + let length := 0 + for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } + mstore(pos, length) + let shift := sub(256, shl(3, length)) + mstore(add(pos, 0x20), shl(shift, shr(shift, w))) + } + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + m5 := mload(0xa0) + m6 := mload(0xc0) + // Selector of `log(string,address,address,address)`. + mstore(0x00, 0xed8f28f6) + mstore(0x20, 0x80) + mstore(0x40, p1) + mstore(0x60, p2) + mstore(0x80, p3) + writeString(0xa0, p0) + } + _sendLogPayload(0x1c, 0xc4); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + mstore(0xa0, m5) + mstore(0xc0, m6) + } + } + + function log(bytes32 p0, address p1, address p2, bool p3) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + bytes32 m5; + bytes32 m6; + assembly { + function writeString(pos, w) { + let length := 0 + for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } + mstore(pos, length) + let shift := sub(256, shl(3, length)) + mstore(add(pos, 0x20), shl(shift, shr(shift, w))) + } + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + m5 := mload(0xa0) + m6 := mload(0xc0) + // Selector of `log(string,address,address,bool)`. + mstore(0x00, 0xb59dbd60) + mstore(0x20, 0x80) + mstore(0x40, p1) + mstore(0x60, p2) + mstore(0x80, p3) + writeString(0xa0, p0) + } + _sendLogPayload(0x1c, 0xc4); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + mstore(0xa0, m5) + mstore(0xc0, m6) + } + } + + function log(bytes32 p0, address p1, address p2, uint256 p3) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + bytes32 m5; + bytes32 m6; + assembly { + function writeString(pos, w) { + let length := 0 + for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } + mstore(pos, length) + let shift := sub(256, shl(3, length)) + mstore(add(pos, 0x20), shl(shift, shr(shift, w))) + } + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + m5 := mload(0xa0) + m6 := mload(0xc0) + // Selector of `log(string,address,address,uint256)`. + mstore(0x00, 0x8ef3f399) + mstore(0x20, 0x80) + mstore(0x40, p1) + mstore(0x60, p2) + mstore(0x80, p3) + writeString(0xa0, p0) + } + _sendLogPayload(0x1c, 0xc4); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + mstore(0xa0, m5) + mstore(0xc0, m6) + } + } + + function log(bytes32 p0, address p1, address p2, bytes32 p3) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + bytes32 m5; + bytes32 m6; + bytes32 m7; + bytes32 m8; + assembly { + function writeString(pos, w) { + let length := 0 + for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } + mstore(pos, length) + let shift := sub(256, shl(3, length)) + mstore(add(pos, 0x20), shl(shift, shr(shift, w))) + } + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + m5 := mload(0xa0) + m6 := mload(0xc0) + m7 := mload(0xe0) + m8 := mload(0x100) + // Selector of `log(string,address,address,string)`. + mstore(0x00, 0x800a1c67) + mstore(0x20, 0x80) + mstore(0x40, p1) + mstore(0x60, p2) + mstore(0x80, 0xc0) + writeString(0xa0, p0) + writeString(0xe0, p3) + } + _sendLogPayload(0x1c, 0x104); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + mstore(0xa0, m5) + mstore(0xc0, m6) + mstore(0xe0, m7) + mstore(0x100, m8) + } + } + + function log(bytes32 p0, address p1, bool p2, address p3) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + bytes32 m5; + bytes32 m6; + assembly { + function writeString(pos, w) { + let length := 0 + for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } + mstore(pos, length) + let shift := sub(256, shl(3, length)) + mstore(add(pos, 0x20), shl(shift, shr(shift, w))) + } + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + m5 := mload(0xa0) + m6 := mload(0xc0) + // Selector of `log(string,address,bool,address)`. + mstore(0x00, 0x223603bd) + mstore(0x20, 0x80) + mstore(0x40, p1) + mstore(0x60, p2) + mstore(0x80, p3) + writeString(0xa0, p0) + } + _sendLogPayload(0x1c, 0xc4); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + mstore(0xa0, m5) + mstore(0xc0, m6) + } + } + + function log(bytes32 p0, address p1, bool p2, bool p3) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + bytes32 m5; + bytes32 m6; + assembly { + function writeString(pos, w) { + let length := 0 + for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } + mstore(pos, length) + let shift := sub(256, shl(3, length)) + mstore(add(pos, 0x20), shl(shift, shr(shift, w))) + } + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + m5 := mload(0xa0) + m6 := mload(0xc0) + // Selector of `log(string,address,bool,bool)`. + mstore(0x00, 0x79884c2b) + mstore(0x20, 0x80) + mstore(0x40, p1) + mstore(0x60, p2) + mstore(0x80, p3) + writeString(0xa0, p0) + } + _sendLogPayload(0x1c, 0xc4); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + mstore(0xa0, m5) + mstore(0xc0, m6) + } + } + + function log(bytes32 p0, address p1, bool p2, uint256 p3) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + bytes32 m5; + bytes32 m6; + assembly { + function writeString(pos, w) { + let length := 0 + for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } + mstore(pos, length) + let shift := sub(256, shl(3, length)) + mstore(add(pos, 0x20), shl(shift, shr(shift, w))) + } + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + m5 := mload(0xa0) + m6 := mload(0xc0) + // Selector of `log(string,address,bool,uint256)`. + mstore(0x00, 0x3e9f866a) + mstore(0x20, 0x80) + mstore(0x40, p1) + mstore(0x60, p2) + mstore(0x80, p3) + writeString(0xa0, p0) + } + _sendLogPayload(0x1c, 0xc4); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + mstore(0xa0, m5) + mstore(0xc0, m6) + } + } + + function log(bytes32 p0, address p1, bool p2, bytes32 p3) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + bytes32 m5; + bytes32 m6; + bytes32 m7; + bytes32 m8; + assembly { + function writeString(pos, w) { + let length := 0 + for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } + mstore(pos, length) + let shift := sub(256, shl(3, length)) + mstore(add(pos, 0x20), shl(shift, shr(shift, w))) + } + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + m5 := mload(0xa0) + m6 := mload(0xc0) + m7 := mload(0xe0) + m8 := mload(0x100) + // Selector of `log(string,address,bool,string)`. + mstore(0x00, 0x0454c079) + mstore(0x20, 0x80) + mstore(0x40, p1) + mstore(0x60, p2) + mstore(0x80, 0xc0) + writeString(0xa0, p0) + writeString(0xe0, p3) + } + _sendLogPayload(0x1c, 0x104); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + mstore(0xa0, m5) + mstore(0xc0, m6) + mstore(0xe0, m7) + mstore(0x100, m8) + } + } + + function log(bytes32 p0, address p1, uint256 p2, address p3) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + bytes32 m5; + bytes32 m6; + assembly { + function writeString(pos, w) { + let length := 0 + for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } + mstore(pos, length) + let shift := sub(256, shl(3, length)) + mstore(add(pos, 0x20), shl(shift, shr(shift, w))) + } + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + m5 := mload(0xa0) + m6 := mload(0xc0) + // Selector of `log(string,address,uint256,address)`. + mstore(0x00, 0x63fb8bc5) + mstore(0x20, 0x80) + mstore(0x40, p1) + mstore(0x60, p2) + mstore(0x80, p3) + writeString(0xa0, p0) + } + _sendLogPayload(0x1c, 0xc4); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + mstore(0xa0, m5) + mstore(0xc0, m6) + } + } + + function log(bytes32 p0, address p1, uint256 p2, bool p3) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + bytes32 m5; + bytes32 m6; + assembly { + function writeString(pos, w) { + let length := 0 + for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } + mstore(pos, length) + let shift := sub(256, shl(3, length)) + mstore(add(pos, 0x20), shl(shift, shr(shift, w))) + } + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + m5 := mload(0xa0) + m6 := mload(0xc0) + // Selector of `log(string,address,uint256,bool)`. + mstore(0x00, 0xfc4845f0) + mstore(0x20, 0x80) + mstore(0x40, p1) + mstore(0x60, p2) + mstore(0x80, p3) + writeString(0xa0, p0) + } + _sendLogPayload(0x1c, 0xc4); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + mstore(0xa0, m5) + mstore(0xc0, m6) + } + } + + function log(bytes32 p0, address p1, uint256 p2, uint256 p3) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + bytes32 m5; + bytes32 m6; + assembly { + function writeString(pos, w) { + let length := 0 + for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } + mstore(pos, length) + let shift := sub(256, shl(3, length)) + mstore(add(pos, 0x20), shl(shift, shr(shift, w))) + } + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + m5 := mload(0xa0) + m6 := mload(0xc0) + // Selector of `log(string,address,uint256,uint256)`. + mstore(0x00, 0xf8f51b1e) + mstore(0x20, 0x80) + mstore(0x40, p1) + mstore(0x60, p2) + mstore(0x80, p3) + writeString(0xa0, p0) + } + _sendLogPayload(0x1c, 0xc4); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + mstore(0xa0, m5) + mstore(0xc0, m6) + } + } + + function log(bytes32 p0, address p1, uint256 p2, bytes32 p3) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + bytes32 m5; + bytes32 m6; + bytes32 m7; + bytes32 m8; + assembly { + function writeString(pos, w) { + let length := 0 + for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } + mstore(pos, length) + let shift := sub(256, shl(3, length)) + mstore(add(pos, 0x20), shl(shift, shr(shift, w))) + } + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + m5 := mload(0xa0) + m6 := mload(0xc0) + m7 := mload(0xe0) + m8 := mload(0x100) + // Selector of `log(string,address,uint256,string)`. + mstore(0x00, 0x5a477632) + mstore(0x20, 0x80) + mstore(0x40, p1) + mstore(0x60, p2) + mstore(0x80, 0xc0) + writeString(0xa0, p0) + writeString(0xe0, p3) + } + _sendLogPayload(0x1c, 0x104); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + mstore(0xa0, m5) + mstore(0xc0, m6) + mstore(0xe0, m7) + mstore(0x100, m8) + } + } + + function log(bytes32 p0, address p1, bytes32 p2, address p3) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + bytes32 m5; + bytes32 m6; + bytes32 m7; + bytes32 m8; + assembly { + function writeString(pos, w) { + let length := 0 + for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } + mstore(pos, length) + let shift := sub(256, shl(3, length)) + mstore(add(pos, 0x20), shl(shift, shr(shift, w))) + } + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + m5 := mload(0xa0) + m6 := mload(0xc0) + m7 := mload(0xe0) + m8 := mload(0x100) + // Selector of `log(string,address,string,address)`. + mstore(0x00, 0xaabc9a31) + mstore(0x20, 0x80) + mstore(0x40, p1) + mstore(0x60, 0xc0) + mstore(0x80, p3) + writeString(0xa0, p0) + writeString(0xe0, p2) + } + _sendLogPayload(0x1c, 0x104); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + mstore(0xa0, m5) + mstore(0xc0, m6) + mstore(0xe0, m7) + mstore(0x100, m8) + } + } + + function log(bytes32 p0, address p1, bytes32 p2, bool p3) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + bytes32 m5; + bytes32 m6; + bytes32 m7; + bytes32 m8; + assembly { + function writeString(pos, w) { + let length := 0 + for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } + mstore(pos, length) + let shift := sub(256, shl(3, length)) + mstore(add(pos, 0x20), shl(shift, shr(shift, w))) + } + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + m5 := mload(0xa0) + m6 := mload(0xc0) + m7 := mload(0xe0) + m8 := mload(0x100) + // Selector of `log(string,address,string,bool)`. + mstore(0x00, 0x5f15d28c) + mstore(0x20, 0x80) + mstore(0x40, p1) + mstore(0x60, 0xc0) + mstore(0x80, p3) + writeString(0xa0, p0) + writeString(0xe0, p2) + } + _sendLogPayload(0x1c, 0x104); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + mstore(0xa0, m5) + mstore(0xc0, m6) + mstore(0xe0, m7) + mstore(0x100, m8) + } + } + + function log(bytes32 p0, address p1, bytes32 p2, uint256 p3) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + bytes32 m5; + bytes32 m6; + bytes32 m7; + bytes32 m8; + assembly { + function writeString(pos, w) { + let length := 0 + for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } + mstore(pos, length) + let shift := sub(256, shl(3, length)) + mstore(add(pos, 0x20), shl(shift, shr(shift, w))) + } + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + m5 := mload(0xa0) + m6 := mload(0xc0) + m7 := mload(0xe0) + m8 := mload(0x100) + // Selector of `log(string,address,string,uint256)`. + mstore(0x00, 0x91d1112e) + mstore(0x20, 0x80) + mstore(0x40, p1) + mstore(0x60, 0xc0) + mstore(0x80, p3) + writeString(0xa0, p0) + writeString(0xe0, p2) + } + _sendLogPayload(0x1c, 0x104); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + mstore(0xa0, m5) + mstore(0xc0, m6) + mstore(0xe0, m7) + mstore(0x100, m8) + } + } + + function log(bytes32 p0, address p1, bytes32 p2, bytes32 p3) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + bytes32 m5; + bytes32 m6; + bytes32 m7; + bytes32 m8; + bytes32 m9; + bytes32 m10; + assembly { + function writeString(pos, w) { + let length := 0 + for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } + mstore(pos, length) + let shift := sub(256, shl(3, length)) + mstore(add(pos, 0x20), shl(shift, shr(shift, w))) + } + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + m5 := mload(0xa0) + m6 := mload(0xc0) + m7 := mload(0xe0) + m8 := mload(0x100) + m9 := mload(0x120) + m10 := mload(0x140) + // Selector of `log(string,address,string,string)`. + mstore(0x00, 0x245986f2) + mstore(0x20, 0x80) + mstore(0x40, p1) + mstore(0x60, 0xc0) + mstore(0x80, 0x100) + writeString(0xa0, p0) + writeString(0xe0, p2) + writeString(0x120, p3) + } + _sendLogPayload(0x1c, 0x144); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + mstore(0xa0, m5) + mstore(0xc0, m6) + mstore(0xe0, m7) + mstore(0x100, m8) + mstore(0x120, m9) + mstore(0x140, m10) + } + } + + function log(bytes32 p0, bool p1, address p2, address p3) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + bytes32 m5; + bytes32 m6; + assembly { + function writeString(pos, w) { + let length := 0 + for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } + mstore(pos, length) + let shift := sub(256, shl(3, length)) + mstore(add(pos, 0x20), shl(shift, shr(shift, w))) + } + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + m5 := mload(0xa0) + m6 := mload(0xc0) + // Selector of `log(string,bool,address,address)`. + mstore(0x00, 0x33e9dd1d) + mstore(0x20, 0x80) + mstore(0x40, p1) + mstore(0x60, p2) + mstore(0x80, p3) + writeString(0xa0, p0) + } + _sendLogPayload(0x1c, 0xc4); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + mstore(0xa0, m5) + mstore(0xc0, m6) + } + } + + function log(bytes32 p0, bool p1, address p2, bool p3) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + bytes32 m5; + bytes32 m6; + assembly { + function writeString(pos, w) { + let length := 0 + for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } + mstore(pos, length) + let shift := sub(256, shl(3, length)) + mstore(add(pos, 0x20), shl(shift, shr(shift, w))) + } + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + m5 := mload(0xa0) + m6 := mload(0xc0) + // Selector of `log(string,bool,address,bool)`. + mstore(0x00, 0x958c28c6) + mstore(0x20, 0x80) + mstore(0x40, p1) + mstore(0x60, p2) + mstore(0x80, p3) + writeString(0xa0, p0) + } + _sendLogPayload(0x1c, 0xc4); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + mstore(0xa0, m5) + mstore(0xc0, m6) + } + } + + function log(bytes32 p0, bool p1, address p2, uint256 p3) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + bytes32 m5; + bytes32 m6; + assembly { + function writeString(pos, w) { + let length := 0 + for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } + mstore(pos, length) + let shift := sub(256, shl(3, length)) + mstore(add(pos, 0x20), shl(shift, shr(shift, w))) + } + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + m5 := mload(0xa0) + m6 := mload(0xc0) + // Selector of `log(string,bool,address,uint256)`. + mstore(0x00, 0x5d08bb05) + mstore(0x20, 0x80) + mstore(0x40, p1) + mstore(0x60, p2) + mstore(0x80, p3) + writeString(0xa0, p0) + } + _sendLogPayload(0x1c, 0xc4); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + mstore(0xa0, m5) + mstore(0xc0, m6) + } + } + + function log(bytes32 p0, bool p1, address p2, bytes32 p3) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + bytes32 m5; + bytes32 m6; + bytes32 m7; + bytes32 m8; + assembly { + function writeString(pos, w) { + let length := 0 + for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } + mstore(pos, length) + let shift := sub(256, shl(3, length)) + mstore(add(pos, 0x20), shl(shift, shr(shift, w))) + } + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + m5 := mload(0xa0) + m6 := mload(0xc0) + m7 := mload(0xe0) + m8 := mload(0x100) + // Selector of `log(string,bool,address,string)`. + mstore(0x00, 0x2d8e33a4) + mstore(0x20, 0x80) + mstore(0x40, p1) + mstore(0x60, p2) + mstore(0x80, 0xc0) + writeString(0xa0, p0) + writeString(0xe0, p3) + } + _sendLogPayload(0x1c, 0x104); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + mstore(0xa0, m5) + mstore(0xc0, m6) + mstore(0xe0, m7) + mstore(0x100, m8) + } + } + + function log(bytes32 p0, bool p1, bool p2, address p3) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + bytes32 m5; + bytes32 m6; + assembly { + function writeString(pos, w) { + let length := 0 + for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } + mstore(pos, length) + let shift := sub(256, shl(3, length)) + mstore(add(pos, 0x20), shl(shift, shr(shift, w))) + } + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + m5 := mload(0xa0) + m6 := mload(0xc0) + // Selector of `log(string,bool,bool,address)`. + mstore(0x00, 0x7190a529) + mstore(0x20, 0x80) + mstore(0x40, p1) + mstore(0x60, p2) + mstore(0x80, p3) + writeString(0xa0, p0) + } + _sendLogPayload(0x1c, 0xc4); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + mstore(0xa0, m5) + mstore(0xc0, m6) + } + } + + function log(bytes32 p0, bool p1, bool p2, bool p3) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + bytes32 m5; + bytes32 m6; + assembly { + function writeString(pos, w) { + let length := 0 + for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } + mstore(pos, length) + let shift := sub(256, shl(3, length)) + mstore(add(pos, 0x20), shl(shift, shr(shift, w))) + } + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + m5 := mload(0xa0) + m6 := mload(0xc0) + // Selector of `log(string,bool,bool,bool)`. + mstore(0x00, 0x895af8c5) + mstore(0x20, 0x80) + mstore(0x40, p1) + mstore(0x60, p2) + mstore(0x80, p3) + writeString(0xa0, p0) + } + _sendLogPayload(0x1c, 0xc4); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + mstore(0xa0, m5) + mstore(0xc0, m6) + } + } + + function log(bytes32 p0, bool p1, bool p2, uint256 p3) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + bytes32 m5; + bytes32 m6; + assembly { + function writeString(pos, w) { + let length := 0 + for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } + mstore(pos, length) + let shift := sub(256, shl(3, length)) + mstore(add(pos, 0x20), shl(shift, shr(shift, w))) + } + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + m5 := mload(0xa0) + m6 := mload(0xc0) + // Selector of `log(string,bool,bool,uint256)`. + mstore(0x00, 0x8e3f78a9) + mstore(0x20, 0x80) + mstore(0x40, p1) + mstore(0x60, p2) + mstore(0x80, p3) + writeString(0xa0, p0) + } + _sendLogPayload(0x1c, 0xc4); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + mstore(0xa0, m5) + mstore(0xc0, m6) + } + } + + function log(bytes32 p0, bool p1, bool p2, bytes32 p3) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + bytes32 m5; + bytes32 m6; + bytes32 m7; + bytes32 m8; + assembly { + function writeString(pos, w) { + let length := 0 + for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } + mstore(pos, length) + let shift := sub(256, shl(3, length)) + mstore(add(pos, 0x20), shl(shift, shr(shift, w))) + } + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + m5 := mload(0xa0) + m6 := mload(0xc0) + m7 := mload(0xe0) + m8 := mload(0x100) + // Selector of `log(string,bool,bool,string)`. + mstore(0x00, 0x9d22d5dd) + mstore(0x20, 0x80) + mstore(0x40, p1) + mstore(0x60, p2) + mstore(0x80, 0xc0) + writeString(0xa0, p0) + writeString(0xe0, p3) + } + _sendLogPayload(0x1c, 0x104); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + mstore(0xa0, m5) + mstore(0xc0, m6) + mstore(0xe0, m7) + mstore(0x100, m8) + } + } + + function log(bytes32 p0, bool p1, uint256 p2, address p3) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + bytes32 m5; + bytes32 m6; + assembly { + function writeString(pos, w) { + let length := 0 + for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } + mstore(pos, length) + let shift := sub(256, shl(3, length)) + mstore(add(pos, 0x20), shl(shift, shr(shift, w))) + } + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + m5 := mload(0xa0) + m6 := mload(0xc0) + // Selector of `log(string,bool,uint256,address)`. + mstore(0x00, 0x935e09bf) + mstore(0x20, 0x80) + mstore(0x40, p1) + mstore(0x60, p2) + mstore(0x80, p3) + writeString(0xa0, p0) + } + _sendLogPayload(0x1c, 0xc4); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + mstore(0xa0, m5) + mstore(0xc0, m6) + } + } + + function log(bytes32 p0, bool p1, uint256 p2, bool p3) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + bytes32 m5; + bytes32 m6; + assembly { + function writeString(pos, w) { + let length := 0 + for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } + mstore(pos, length) + let shift := sub(256, shl(3, length)) + mstore(add(pos, 0x20), shl(shift, shr(shift, w))) + } + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + m5 := mload(0xa0) + m6 := mload(0xc0) + // Selector of `log(string,bool,uint256,bool)`. + mstore(0x00, 0x8af7cf8a) + mstore(0x20, 0x80) + mstore(0x40, p1) + mstore(0x60, p2) + mstore(0x80, p3) + writeString(0xa0, p0) + } + _sendLogPayload(0x1c, 0xc4); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + mstore(0xa0, m5) + mstore(0xc0, m6) + } + } + + function log(bytes32 p0, bool p1, uint256 p2, uint256 p3) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + bytes32 m5; + bytes32 m6; + assembly { + function writeString(pos, w) { + let length := 0 + for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } + mstore(pos, length) + let shift := sub(256, shl(3, length)) + mstore(add(pos, 0x20), shl(shift, shr(shift, w))) + } + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + m5 := mload(0xa0) + m6 := mload(0xc0) + // Selector of `log(string,bool,uint256,uint256)`. + mstore(0x00, 0x64b5bb67) + mstore(0x20, 0x80) + mstore(0x40, p1) + mstore(0x60, p2) + mstore(0x80, p3) + writeString(0xa0, p0) + } + _sendLogPayload(0x1c, 0xc4); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + mstore(0xa0, m5) + mstore(0xc0, m6) + } + } + + function log(bytes32 p0, bool p1, uint256 p2, bytes32 p3) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + bytes32 m5; + bytes32 m6; + bytes32 m7; + bytes32 m8; + assembly { + function writeString(pos, w) { + let length := 0 + for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } + mstore(pos, length) + let shift := sub(256, shl(3, length)) + mstore(add(pos, 0x20), shl(shift, shr(shift, w))) + } + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + m5 := mload(0xa0) + m6 := mload(0xc0) + m7 := mload(0xe0) + m8 := mload(0x100) + // Selector of `log(string,bool,uint256,string)`. + mstore(0x00, 0x742d6ee7) + mstore(0x20, 0x80) + mstore(0x40, p1) + mstore(0x60, p2) + mstore(0x80, 0xc0) + writeString(0xa0, p0) + writeString(0xe0, p3) + } + _sendLogPayload(0x1c, 0x104); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + mstore(0xa0, m5) + mstore(0xc0, m6) + mstore(0xe0, m7) + mstore(0x100, m8) + } + } + + function log(bytes32 p0, bool p1, bytes32 p2, address p3) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + bytes32 m5; + bytes32 m6; + bytes32 m7; + bytes32 m8; + assembly { + function writeString(pos, w) { + let length := 0 + for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } + mstore(pos, length) + let shift := sub(256, shl(3, length)) + mstore(add(pos, 0x20), shl(shift, shr(shift, w))) + } + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + m5 := mload(0xa0) + m6 := mload(0xc0) + m7 := mload(0xe0) + m8 := mload(0x100) + // Selector of `log(string,bool,string,address)`. + mstore(0x00, 0xe0625b29) + mstore(0x20, 0x80) + mstore(0x40, p1) + mstore(0x60, 0xc0) + mstore(0x80, p3) + writeString(0xa0, p0) + writeString(0xe0, p2) + } + _sendLogPayload(0x1c, 0x104); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + mstore(0xa0, m5) + mstore(0xc0, m6) + mstore(0xe0, m7) + mstore(0x100, m8) + } + } + + function log(bytes32 p0, bool p1, bytes32 p2, bool p3) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + bytes32 m5; + bytes32 m6; + bytes32 m7; + bytes32 m8; + assembly { + function writeString(pos, w) { + let length := 0 + for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } + mstore(pos, length) + let shift := sub(256, shl(3, length)) + mstore(add(pos, 0x20), shl(shift, shr(shift, w))) + } + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + m5 := mload(0xa0) + m6 := mload(0xc0) + m7 := mload(0xe0) + m8 := mload(0x100) + // Selector of `log(string,bool,string,bool)`. + mstore(0x00, 0x3f8a701d) + mstore(0x20, 0x80) + mstore(0x40, p1) + mstore(0x60, 0xc0) + mstore(0x80, p3) + writeString(0xa0, p0) + writeString(0xe0, p2) + } + _sendLogPayload(0x1c, 0x104); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + mstore(0xa0, m5) + mstore(0xc0, m6) + mstore(0xe0, m7) + mstore(0x100, m8) + } + } + + function log(bytes32 p0, bool p1, bytes32 p2, uint256 p3) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + bytes32 m5; + bytes32 m6; + bytes32 m7; + bytes32 m8; + assembly { + function writeString(pos, w) { + let length := 0 + for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } + mstore(pos, length) + let shift := sub(256, shl(3, length)) + mstore(add(pos, 0x20), shl(shift, shr(shift, w))) + } + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + m5 := mload(0xa0) + m6 := mload(0xc0) + m7 := mload(0xe0) + m8 := mload(0x100) + // Selector of `log(string,bool,string,uint256)`. + mstore(0x00, 0x24f91465) + mstore(0x20, 0x80) + mstore(0x40, p1) + mstore(0x60, 0xc0) + mstore(0x80, p3) + writeString(0xa0, p0) + writeString(0xe0, p2) + } + _sendLogPayload(0x1c, 0x104); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + mstore(0xa0, m5) + mstore(0xc0, m6) + mstore(0xe0, m7) + mstore(0x100, m8) + } + } + + function log(bytes32 p0, bool p1, bytes32 p2, bytes32 p3) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + bytes32 m5; + bytes32 m6; + bytes32 m7; + bytes32 m8; + bytes32 m9; + bytes32 m10; + assembly { + function writeString(pos, w) { + let length := 0 + for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } + mstore(pos, length) + let shift := sub(256, shl(3, length)) + mstore(add(pos, 0x20), shl(shift, shr(shift, w))) + } + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + m5 := mload(0xa0) + m6 := mload(0xc0) + m7 := mload(0xe0) + m8 := mload(0x100) + m9 := mload(0x120) + m10 := mload(0x140) + // Selector of `log(string,bool,string,string)`. + mstore(0x00, 0xa826caeb) + mstore(0x20, 0x80) + mstore(0x40, p1) + mstore(0x60, 0xc0) + mstore(0x80, 0x100) + writeString(0xa0, p0) + writeString(0xe0, p2) + writeString(0x120, p3) + } + _sendLogPayload(0x1c, 0x144); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + mstore(0xa0, m5) + mstore(0xc0, m6) + mstore(0xe0, m7) + mstore(0x100, m8) + mstore(0x120, m9) + mstore(0x140, m10) + } + } + + function log(bytes32 p0, uint256 p1, address p2, address p3) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + bytes32 m5; + bytes32 m6; + assembly { + function writeString(pos, w) { + let length := 0 + for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } + mstore(pos, length) + let shift := sub(256, shl(3, length)) + mstore(add(pos, 0x20), shl(shift, shr(shift, w))) + } + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + m5 := mload(0xa0) + m6 := mload(0xc0) + // Selector of `log(string,uint256,address,address)`. + mstore(0x00, 0x5ea2b7ae) + mstore(0x20, 0x80) + mstore(0x40, p1) + mstore(0x60, p2) + mstore(0x80, p3) + writeString(0xa0, p0) + } + _sendLogPayload(0x1c, 0xc4); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + mstore(0xa0, m5) + mstore(0xc0, m6) + } + } + + function log(bytes32 p0, uint256 p1, address p2, bool p3) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + bytes32 m5; + bytes32 m6; + assembly { + function writeString(pos, w) { + let length := 0 + for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } + mstore(pos, length) + let shift := sub(256, shl(3, length)) + mstore(add(pos, 0x20), shl(shift, shr(shift, w))) + } + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + m5 := mload(0xa0) + m6 := mload(0xc0) + // Selector of `log(string,uint256,address,bool)`. + mstore(0x00, 0x82112a42) + mstore(0x20, 0x80) + mstore(0x40, p1) + mstore(0x60, p2) + mstore(0x80, p3) + writeString(0xa0, p0) + } + _sendLogPayload(0x1c, 0xc4); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + mstore(0xa0, m5) + mstore(0xc0, m6) + } + } + + function log(bytes32 p0, uint256 p1, address p2, uint256 p3) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + bytes32 m5; + bytes32 m6; + assembly { + function writeString(pos, w) { + let length := 0 + for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } + mstore(pos, length) + let shift := sub(256, shl(3, length)) + mstore(add(pos, 0x20), shl(shift, shr(shift, w))) + } + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + m5 := mload(0xa0) + m6 := mload(0xc0) + // Selector of `log(string,uint256,address,uint256)`. + mstore(0x00, 0x4f04fdc6) + mstore(0x20, 0x80) + mstore(0x40, p1) + mstore(0x60, p2) + mstore(0x80, p3) + writeString(0xa0, p0) + } + _sendLogPayload(0x1c, 0xc4); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + mstore(0xa0, m5) + mstore(0xc0, m6) + } + } + + function log(bytes32 p0, uint256 p1, address p2, bytes32 p3) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + bytes32 m5; + bytes32 m6; + bytes32 m7; + bytes32 m8; + assembly { + function writeString(pos, w) { + let length := 0 + for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } + mstore(pos, length) + let shift := sub(256, shl(3, length)) + mstore(add(pos, 0x20), shl(shift, shr(shift, w))) + } + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + m5 := mload(0xa0) + m6 := mload(0xc0) + m7 := mload(0xe0) + m8 := mload(0x100) + // Selector of `log(string,uint256,address,string)`. + mstore(0x00, 0x9ffb2f93) + mstore(0x20, 0x80) + mstore(0x40, p1) + mstore(0x60, p2) + mstore(0x80, 0xc0) + writeString(0xa0, p0) + writeString(0xe0, p3) + } + _sendLogPayload(0x1c, 0x104); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + mstore(0xa0, m5) + mstore(0xc0, m6) + mstore(0xe0, m7) + mstore(0x100, m8) + } + } + + function log(bytes32 p0, uint256 p1, bool p2, address p3) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + bytes32 m5; + bytes32 m6; + assembly { + function writeString(pos, w) { + let length := 0 + for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } + mstore(pos, length) + let shift := sub(256, shl(3, length)) + mstore(add(pos, 0x20), shl(shift, shr(shift, w))) + } + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + m5 := mload(0xa0) + m6 := mload(0xc0) + // Selector of `log(string,uint256,bool,address)`. + mstore(0x00, 0xe0e95b98) + mstore(0x20, 0x80) + mstore(0x40, p1) + mstore(0x60, p2) + mstore(0x80, p3) + writeString(0xa0, p0) + } + _sendLogPayload(0x1c, 0xc4); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + mstore(0xa0, m5) + mstore(0xc0, m6) + } + } + + function log(bytes32 p0, uint256 p1, bool p2, bool p3) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + bytes32 m5; + bytes32 m6; + assembly { + function writeString(pos, w) { + let length := 0 + for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } + mstore(pos, length) + let shift := sub(256, shl(3, length)) + mstore(add(pos, 0x20), shl(shift, shr(shift, w))) + } + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + m5 := mload(0xa0) + m6 := mload(0xc0) + // Selector of `log(string,uint256,bool,bool)`. + mstore(0x00, 0x354c36d6) + mstore(0x20, 0x80) + mstore(0x40, p1) + mstore(0x60, p2) + mstore(0x80, p3) + writeString(0xa0, p0) + } + _sendLogPayload(0x1c, 0xc4); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + mstore(0xa0, m5) + mstore(0xc0, m6) + } + } + + function log(bytes32 p0, uint256 p1, bool p2, uint256 p3) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + bytes32 m5; + bytes32 m6; + assembly { + function writeString(pos, w) { + let length := 0 + for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } + mstore(pos, length) + let shift := sub(256, shl(3, length)) + mstore(add(pos, 0x20), shl(shift, shr(shift, w))) + } + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + m5 := mload(0xa0) + m6 := mload(0xc0) + // Selector of `log(string,uint256,bool,uint256)`. + mstore(0x00, 0xe41b6f6f) + mstore(0x20, 0x80) + mstore(0x40, p1) + mstore(0x60, p2) + mstore(0x80, p3) + writeString(0xa0, p0) + } + _sendLogPayload(0x1c, 0xc4); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + mstore(0xa0, m5) + mstore(0xc0, m6) + } + } + + function log(bytes32 p0, uint256 p1, bool p2, bytes32 p3) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + bytes32 m5; + bytes32 m6; + bytes32 m7; + bytes32 m8; + assembly { + function writeString(pos, w) { + let length := 0 + for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } + mstore(pos, length) + let shift := sub(256, shl(3, length)) + mstore(add(pos, 0x20), shl(shift, shr(shift, w))) + } + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + m5 := mload(0xa0) + m6 := mload(0xc0) + m7 := mload(0xe0) + m8 := mload(0x100) + // Selector of `log(string,uint256,bool,string)`. + mstore(0x00, 0xabf73a98) + mstore(0x20, 0x80) + mstore(0x40, p1) + mstore(0x60, p2) + mstore(0x80, 0xc0) + writeString(0xa0, p0) + writeString(0xe0, p3) + } + _sendLogPayload(0x1c, 0x104); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + mstore(0xa0, m5) + mstore(0xc0, m6) + mstore(0xe0, m7) + mstore(0x100, m8) + } + } + + function log(bytes32 p0, uint256 p1, uint256 p2, address p3) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + bytes32 m5; + bytes32 m6; + assembly { + function writeString(pos, w) { + let length := 0 + for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } + mstore(pos, length) + let shift := sub(256, shl(3, length)) + mstore(add(pos, 0x20), shl(shift, shr(shift, w))) + } + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + m5 := mload(0xa0) + m6 := mload(0xc0) + // Selector of `log(string,uint256,uint256,address)`. + mstore(0x00, 0xe21de278) + mstore(0x20, 0x80) + mstore(0x40, p1) + mstore(0x60, p2) + mstore(0x80, p3) + writeString(0xa0, p0) + } + _sendLogPayload(0x1c, 0xc4); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + mstore(0xa0, m5) + mstore(0xc0, m6) + } + } + + function log(bytes32 p0, uint256 p1, uint256 p2, bool p3) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + bytes32 m5; + bytes32 m6; + assembly { + function writeString(pos, w) { + let length := 0 + for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } + mstore(pos, length) + let shift := sub(256, shl(3, length)) + mstore(add(pos, 0x20), shl(shift, shr(shift, w))) + } + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + m5 := mload(0xa0) + m6 := mload(0xc0) + // Selector of `log(string,uint256,uint256,bool)`. + mstore(0x00, 0x7626db92) + mstore(0x20, 0x80) + mstore(0x40, p1) + mstore(0x60, p2) + mstore(0x80, p3) + writeString(0xa0, p0) + } + _sendLogPayload(0x1c, 0xc4); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + mstore(0xa0, m5) + mstore(0xc0, m6) + } + } + + function log(bytes32 p0, uint256 p1, uint256 p2, uint256 p3) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + bytes32 m5; + bytes32 m6; + assembly { + function writeString(pos, w) { + let length := 0 + for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } + mstore(pos, length) + let shift := sub(256, shl(3, length)) + mstore(add(pos, 0x20), shl(shift, shr(shift, w))) + } + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + m5 := mload(0xa0) + m6 := mload(0xc0) + // Selector of `log(string,uint256,uint256,uint256)`. + mstore(0x00, 0xa7a87853) + mstore(0x20, 0x80) + mstore(0x40, p1) + mstore(0x60, p2) + mstore(0x80, p3) + writeString(0xa0, p0) + } + _sendLogPayload(0x1c, 0xc4); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + mstore(0xa0, m5) + mstore(0xc0, m6) + } + } + + function log(bytes32 p0, uint256 p1, uint256 p2, bytes32 p3) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + bytes32 m5; + bytes32 m6; + bytes32 m7; + bytes32 m8; + assembly { + function writeString(pos, w) { + let length := 0 + for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } + mstore(pos, length) + let shift := sub(256, shl(3, length)) + mstore(add(pos, 0x20), shl(shift, shr(shift, w))) + } + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + m5 := mload(0xa0) + m6 := mload(0xc0) + m7 := mload(0xe0) + m8 := mload(0x100) + // Selector of `log(string,uint256,uint256,string)`. + mstore(0x00, 0x854b3496) + mstore(0x20, 0x80) + mstore(0x40, p1) + mstore(0x60, p2) + mstore(0x80, 0xc0) + writeString(0xa0, p0) + writeString(0xe0, p3) + } + _sendLogPayload(0x1c, 0x104); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + mstore(0xa0, m5) + mstore(0xc0, m6) + mstore(0xe0, m7) + mstore(0x100, m8) + } + } + + function log(bytes32 p0, uint256 p1, bytes32 p2, address p3) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + bytes32 m5; + bytes32 m6; + bytes32 m7; + bytes32 m8; + assembly { + function writeString(pos, w) { + let length := 0 + for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } + mstore(pos, length) + let shift := sub(256, shl(3, length)) + mstore(add(pos, 0x20), shl(shift, shr(shift, w))) + } + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + m5 := mload(0xa0) + m6 := mload(0xc0) + m7 := mload(0xe0) + m8 := mload(0x100) + // Selector of `log(string,uint256,string,address)`. + mstore(0x00, 0x7c4632a4) + mstore(0x20, 0x80) + mstore(0x40, p1) + mstore(0x60, 0xc0) + mstore(0x80, p3) + writeString(0xa0, p0) + writeString(0xe0, p2) + } + _sendLogPayload(0x1c, 0x104); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + mstore(0xa0, m5) + mstore(0xc0, m6) + mstore(0xe0, m7) + mstore(0x100, m8) + } + } + + function log(bytes32 p0, uint256 p1, bytes32 p2, bool p3) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + bytes32 m5; + bytes32 m6; + bytes32 m7; + bytes32 m8; + assembly { + function writeString(pos, w) { + let length := 0 + for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } + mstore(pos, length) + let shift := sub(256, shl(3, length)) + mstore(add(pos, 0x20), shl(shift, shr(shift, w))) + } + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + m5 := mload(0xa0) + m6 := mload(0xc0) + m7 := mload(0xe0) + m8 := mload(0x100) + // Selector of `log(string,uint256,string,bool)`. + mstore(0x00, 0x7d24491d) + mstore(0x20, 0x80) + mstore(0x40, p1) + mstore(0x60, 0xc0) + mstore(0x80, p3) + writeString(0xa0, p0) + writeString(0xe0, p2) + } + _sendLogPayload(0x1c, 0x104); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + mstore(0xa0, m5) + mstore(0xc0, m6) + mstore(0xe0, m7) + mstore(0x100, m8) + } + } + + function log(bytes32 p0, uint256 p1, bytes32 p2, uint256 p3) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + bytes32 m5; + bytes32 m6; + bytes32 m7; + bytes32 m8; + assembly { + function writeString(pos, w) { + let length := 0 + for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } + mstore(pos, length) + let shift := sub(256, shl(3, length)) + mstore(add(pos, 0x20), shl(shift, shr(shift, w))) + } + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + m5 := mload(0xa0) + m6 := mload(0xc0) + m7 := mload(0xe0) + m8 := mload(0x100) + // Selector of `log(string,uint256,string,uint256)`. + mstore(0x00, 0xc67ea9d1) + mstore(0x20, 0x80) + mstore(0x40, p1) + mstore(0x60, 0xc0) + mstore(0x80, p3) + writeString(0xa0, p0) + writeString(0xe0, p2) + } + _sendLogPayload(0x1c, 0x104); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + mstore(0xa0, m5) + mstore(0xc0, m6) + mstore(0xe0, m7) + mstore(0x100, m8) + } + } + + function log(bytes32 p0, uint256 p1, bytes32 p2, bytes32 p3) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + bytes32 m5; + bytes32 m6; + bytes32 m7; + bytes32 m8; + bytes32 m9; + bytes32 m10; + assembly { + function writeString(pos, w) { + let length := 0 + for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } + mstore(pos, length) + let shift := sub(256, shl(3, length)) + mstore(add(pos, 0x20), shl(shift, shr(shift, w))) + } + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + m5 := mload(0xa0) + m6 := mload(0xc0) + m7 := mload(0xe0) + m8 := mload(0x100) + m9 := mload(0x120) + m10 := mload(0x140) + // Selector of `log(string,uint256,string,string)`. + mstore(0x00, 0x5ab84e1f) + mstore(0x20, 0x80) + mstore(0x40, p1) + mstore(0x60, 0xc0) + mstore(0x80, 0x100) + writeString(0xa0, p0) + writeString(0xe0, p2) + writeString(0x120, p3) + } + _sendLogPayload(0x1c, 0x144); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + mstore(0xa0, m5) + mstore(0xc0, m6) + mstore(0xe0, m7) + mstore(0x100, m8) + mstore(0x120, m9) + mstore(0x140, m10) + } + } + + function log(bytes32 p0, bytes32 p1, address p2, address p3) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + bytes32 m5; + bytes32 m6; + bytes32 m7; + bytes32 m8; + assembly { + function writeString(pos, w) { + let length := 0 + for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } + mstore(pos, length) + let shift := sub(256, shl(3, length)) + mstore(add(pos, 0x20), shl(shift, shr(shift, w))) + } + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + m5 := mload(0xa0) + m6 := mload(0xc0) + m7 := mload(0xe0) + m8 := mload(0x100) + // Selector of `log(string,string,address,address)`. + mstore(0x00, 0x439c7bef) + mstore(0x20, 0x80) + mstore(0x40, 0xc0) + mstore(0x60, p2) + mstore(0x80, p3) + writeString(0xa0, p0) + writeString(0xe0, p1) + } + _sendLogPayload(0x1c, 0x104); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + mstore(0xa0, m5) + mstore(0xc0, m6) + mstore(0xe0, m7) + mstore(0x100, m8) + } + } + + function log(bytes32 p0, bytes32 p1, address p2, bool p3) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + bytes32 m5; + bytes32 m6; + bytes32 m7; + bytes32 m8; + assembly { + function writeString(pos, w) { + let length := 0 + for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } + mstore(pos, length) + let shift := sub(256, shl(3, length)) + mstore(add(pos, 0x20), shl(shift, shr(shift, w))) + } + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + m5 := mload(0xa0) + m6 := mload(0xc0) + m7 := mload(0xe0) + m8 := mload(0x100) + // Selector of `log(string,string,address,bool)`. + mstore(0x00, 0x5ccd4e37) + mstore(0x20, 0x80) + mstore(0x40, 0xc0) + mstore(0x60, p2) + mstore(0x80, p3) + writeString(0xa0, p0) + writeString(0xe0, p1) + } + _sendLogPayload(0x1c, 0x104); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + mstore(0xa0, m5) + mstore(0xc0, m6) + mstore(0xe0, m7) + mstore(0x100, m8) + } + } + + function log(bytes32 p0, bytes32 p1, address p2, uint256 p3) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + bytes32 m5; + bytes32 m6; + bytes32 m7; + bytes32 m8; + assembly { + function writeString(pos, w) { + let length := 0 + for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } + mstore(pos, length) + let shift := sub(256, shl(3, length)) + mstore(add(pos, 0x20), shl(shift, shr(shift, w))) + } + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + m5 := mload(0xa0) + m6 := mload(0xc0) + m7 := mload(0xe0) + m8 := mload(0x100) + // Selector of `log(string,string,address,uint256)`. + mstore(0x00, 0x7cc3c607) + mstore(0x20, 0x80) + mstore(0x40, 0xc0) + mstore(0x60, p2) + mstore(0x80, p3) + writeString(0xa0, p0) + writeString(0xe0, p1) + } + _sendLogPayload(0x1c, 0x104); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + mstore(0xa0, m5) + mstore(0xc0, m6) + mstore(0xe0, m7) + mstore(0x100, m8) + } + } + + function log(bytes32 p0, bytes32 p1, address p2, bytes32 p3) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + bytes32 m5; + bytes32 m6; + bytes32 m7; + bytes32 m8; + bytes32 m9; + bytes32 m10; + assembly { + function writeString(pos, w) { + let length := 0 + for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } + mstore(pos, length) + let shift := sub(256, shl(3, length)) + mstore(add(pos, 0x20), shl(shift, shr(shift, w))) + } + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + m5 := mload(0xa0) + m6 := mload(0xc0) + m7 := mload(0xe0) + m8 := mload(0x100) + m9 := mload(0x120) + m10 := mload(0x140) + // Selector of `log(string,string,address,string)`. + mstore(0x00, 0xeb1bff80) + mstore(0x20, 0x80) + mstore(0x40, 0xc0) + mstore(0x60, p2) + mstore(0x80, 0x100) + writeString(0xa0, p0) + writeString(0xe0, p1) + writeString(0x120, p3) + } + _sendLogPayload(0x1c, 0x144); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + mstore(0xa0, m5) + mstore(0xc0, m6) + mstore(0xe0, m7) + mstore(0x100, m8) + mstore(0x120, m9) + mstore(0x140, m10) + } + } + + function log(bytes32 p0, bytes32 p1, bool p2, address p3) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + bytes32 m5; + bytes32 m6; + bytes32 m7; + bytes32 m8; + assembly { + function writeString(pos, w) { + let length := 0 + for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } + mstore(pos, length) + let shift := sub(256, shl(3, length)) + mstore(add(pos, 0x20), shl(shift, shr(shift, w))) + } + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + m5 := mload(0xa0) + m6 := mload(0xc0) + m7 := mload(0xe0) + m8 := mload(0x100) + // Selector of `log(string,string,bool,address)`. + mstore(0x00, 0xc371c7db) + mstore(0x20, 0x80) + mstore(0x40, 0xc0) + mstore(0x60, p2) + mstore(0x80, p3) + writeString(0xa0, p0) + writeString(0xe0, p1) + } + _sendLogPayload(0x1c, 0x104); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + mstore(0xa0, m5) + mstore(0xc0, m6) + mstore(0xe0, m7) + mstore(0x100, m8) + } + } + + function log(bytes32 p0, bytes32 p1, bool p2, bool p3) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + bytes32 m5; + bytes32 m6; + bytes32 m7; + bytes32 m8; + assembly { + function writeString(pos, w) { + let length := 0 + for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } + mstore(pos, length) + let shift := sub(256, shl(3, length)) + mstore(add(pos, 0x20), shl(shift, shr(shift, w))) + } + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + m5 := mload(0xa0) + m6 := mload(0xc0) + m7 := mload(0xe0) + m8 := mload(0x100) + // Selector of `log(string,string,bool,bool)`. + mstore(0x00, 0x40785869) + mstore(0x20, 0x80) + mstore(0x40, 0xc0) + mstore(0x60, p2) + mstore(0x80, p3) + writeString(0xa0, p0) + writeString(0xe0, p1) + } + _sendLogPayload(0x1c, 0x104); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + mstore(0xa0, m5) + mstore(0xc0, m6) + mstore(0xe0, m7) + mstore(0x100, m8) + } + } + + function log(bytes32 p0, bytes32 p1, bool p2, uint256 p3) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + bytes32 m5; + bytes32 m6; + bytes32 m7; + bytes32 m8; + assembly { + function writeString(pos, w) { + let length := 0 + for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } + mstore(pos, length) + let shift := sub(256, shl(3, length)) + mstore(add(pos, 0x20), shl(shift, shr(shift, w))) + } + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + m5 := mload(0xa0) + m6 := mload(0xc0) + m7 := mload(0xe0) + m8 := mload(0x100) + // Selector of `log(string,string,bool,uint256)`. + mstore(0x00, 0xd6aefad2) + mstore(0x20, 0x80) + mstore(0x40, 0xc0) + mstore(0x60, p2) + mstore(0x80, p3) + writeString(0xa0, p0) + writeString(0xe0, p1) + } + _sendLogPayload(0x1c, 0x104); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + mstore(0xa0, m5) + mstore(0xc0, m6) + mstore(0xe0, m7) + mstore(0x100, m8) + } + } + + function log(bytes32 p0, bytes32 p1, bool p2, bytes32 p3) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + bytes32 m5; + bytes32 m6; + bytes32 m7; + bytes32 m8; + bytes32 m9; + bytes32 m10; + assembly { + function writeString(pos, w) { + let length := 0 + for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } + mstore(pos, length) + let shift := sub(256, shl(3, length)) + mstore(add(pos, 0x20), shl(shift, shr(shift, w))) + } + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + m5 := mload(0xa0) + m6 := mload(0xc0) + m7 := mload(0xe0) + m8 := mload(0x100) + m9 := mload(0x120) + m10 := mload(0x140) + // Selector of `log(string,string,bool,string)`. + mstore(0x00, 0x5e84b0ea) + mstore(0x20, 0x80) + mstore(0x40, 0xc0) + mstore(0x60, p2) + mstore(0x80, 0x100) + writeString(0xa0, p0) + writeString(0xe0, p1) + writeString(0x120, p3) + } + _sendLogPayload(0x1c, 0x144); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + mstore(0xa0, m5) + mstore(0xc0, m6) + mstore(0xe0, m7) + mstore(0x100, m8) + mstore(0x120, m9) + mstore(0x140, m10) + } + } + + function log(bytes32 p0, bytes32 p1, uint256 p2, address p3) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + bytes32 m5; + bytes32 m6; + bytes32 m7; + bytes32 m8; + assembly { + function writeString(pos, w) { + let length := 0 + for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } + mstore(pos, length) + let shift := sub(256, shl(3, length)) + mstore(add(pos, 0x20), shl(shift, shr(shift, w))) + } + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + m5 := mload(0xa0) + m6 := mload(0xc0) + m7 := mload(0xe0) + m8 := mload(0x100) + // Selector of `log(string,string,uint256,address)`. + mstore(0x00, 0x1023f7b2) + mstore(0x20, 0x80) + mstore(0x40, 0xc0) + mstore(0x60, p2) + mstore(0x80, p3) + writeString(0xa0, p0) + writeString(0xe0, p1) + } + _sendLogPayload(0x1c, 0x104); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + mstore(0xa0, m5) + mstore(0xc0, m6) + mstore(0xe0, m7) + mstore(0x100, m8) + } + } + + function log(bytes32 p0, bytes32 p1, uint256 p2, bool p3) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + bytes32 m5; + bytes32 m6; + bytes32 m7; + bytes32 m8; + assembly { + function writeString(pos, w) { + let length := 0 + for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } + mstore(pos, length) + let shift := sub(256, shl(3, length)) + mstore(add(pos, 0x20), shl(shift, shr(shift, w))) + } + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + m5 := mload(0xa0) + m6 := mload(0xc0) + m7 := mload(0xe0) + m8 := mload(0x100) + // Selector of `log(string,string,uint256,bool)`. + mstore(0x00, 0xc3a8a654) + mstore(0x20, 0x80) + mstore(0x40, 0xc0) + mstore(0x60, p2) + mstore(0x80, p3) + writeString(0xa0, p0) + writeString(0xe0, p1) + } + _sendLogPayload(0x1c, 0x104); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + mstore(0xa0, m5) + mstore(0xc0, m6) + mstore(0xe0, m7) + mstore(0x100, m8) + } + } + + function log(bytes32 p0, bytes32 p1, uint256 p2, uint256 p3) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + bytes32 m5; + bytes32 m6; + bytes32 m7; + bytes32 m8; + assembly { + function writeString(pos, w) { + let length := 0 + for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } + mstore(pos, length) + let shift := sub(256, shl(3, length)) + mstore(add(pos, 0x20), shl(shift, shr(shift, w))) + } + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + m5 := mload(0xa0) + m6 := mload(0xc0) + m7 := mload(0xe0) + m8 := mload(0x100) + // Selector of `log(string,string,uint256,uint256)`. + mstore(0x00, 0xf45d7d2c) + mstore(0x20, 0x80) + mstore(0x40, 0xc0) + mstore(0x60, p2) + mstore(0x80, p3) + writeString(0xa0, p0) + writeString(0xe0, p1) + } + _sendLogPayload(0x1c, 0x104); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + mstore(0xa0, m5) + mstore(0xc0, m6) + mstore(0xe0, m7) + mstore(0x100, m8) + } + } + + function log(bytes32 p0, bytes32 p1, uint256 p2, bytes32 p3) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + bytes32 m5; + bytes32 m6; + bytes32 m7; + bytes32 m8; + bytes32 m9; + bytes32 m10; + assembly { + function writeString(pos, w) { + let length := 0 + for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } + mstore(pos, length) + let shift := sub(256, shl(3, length)) + mstore(add(pos, 0x20), shl(shift, shr(shift, w))) + } + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + m5 := mload(0xa0) + m6 := mload(0xc0) + m7 := mload(0xe0) + m8 := mload(0x100) + m9 := mload(0x120) + m10 := mload(0x140) + // Selector of `log(string,string,uint256,string)`. + mstore(0x00, 0x5d1a971a) + mstore(0x20, 0x80) + mstore(0x40, 0xc0) + mstore(0x60, p2) + mstore(0x80, 0x100) + writeString(0xa0, p0) + writeString(0xe0, p1) + writeString(0x120, p3) + } + _sendLogPayload(0x1c, 0x144); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + mstore(0xa0, m5) + mstore(0xc0, m6) + mstore(0xe0, m7) + mstore(0x100, m8) + mstore(0x120, m9) + mstore(0x140, m10) + } + } + + function log(bytes32 p0, bytes32 p1, bytes32 p2, address p3) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + bytes32 m5; + bytes32 m6; + bytes32 m7; + bytes32 m8; + bytes32 m9; + bytes32 m10; + assembly { + function writeString(pos, w) { + let length := 0 + for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } + mstore(pos, length) + let shift := sub(256, shl(3, length)) + mstore(add(pos, 0x20), shl(shift, shr(shift, w))) + } + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + m5 := mload(0xa0) + m6 := mload(0xc0) + m7 := mload(0xe0) + m8 := mload(0x100) + m9 := mload(0x120) + m10 := mload(0x140) + // Selector of `log(string,string,string,address)`. + mstore(0x00, 0x6d572f44) + mstore(0x20, 0x80) + mstore(0x40, 0xc0) + mstore(0x60, 0x100) + mstore(0x80, p3) + writeString(0xa0, p0) + writeString(0xe0, p1) + writeString(0x120, p2) + } + _sendLogPayload(0x1c, 0x144); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + mstore(0xa0, m5) + mstore(0xc0, m6) + mstore(0xe0, m7) + mstore(0x100, m8) + mstore(0x120, m9) + mstore(0x140, m10) + } + } + + function log(bytes32 p0, bytes32 p1, bytes32 p2, bool p3) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + bytes32 m5; + bytes32 m6; + bytes32 m7; + bytes32 m8; + bytes32 m9; + bytes32 m10; + assembly { + function writeString(pos, w) { + let length := 0 + for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } + mstore(pos, length) + let shift := sub(256, shl(3, length)) + mstore(add(pos, 0x20), shl(shift, shr(shift, w))) + } + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + m5 := mload(0xa0) + m6 := mload(0xc0) + m7 := mload(0xe0) + m8 := mload(0x100) + m9 := mload(0x120) + m10 := mload(0x140) + // Selector of `log(string,string,string,bool)`. + mstore(0x00, 0x2c1754ed) + mstore(0x20, 0x80) + mstore(0x40, 0xc0) + mstore(0x60, 0x100) + mstore(0x80, p3) + writeString(0xa0, p0) + writeString(0xe0, p1) + writeString(0x120, p2) + } + _sendLogPayload(0x1c, 0x144); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + mstore(0xa0, m5) + mstore(0xc0, m6) + mstore(0xe0, m7) + mstore(0x100, m8) + mstore(0x120, m9) + mstore(0x140, m10) + } + } + + function log(bytes32 p0, bytes32 p1, bytes32 p2, uint256 p3) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + bytes32 m5; + bytes32 m6; + bytes32 m7; + bytes32 m8; + bytes32 m9; + bytes32 m10; + assembly { + function writeString(pos, w) { + let length := 0 + for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } + mstore(pos, length) + let shift := sub(256, shl(3, length)) + mstore(add(pos, 0x20), shl(shift, shr(shift, w))) + } + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + m5 := mload(0xa0) + m6 := mload(0xc0) + m7 := mload(0xe0) + m8 := mload(0x100) + m9 := mload(0x120) + m10 := mload(0x140) + // Selector of `log(string,string,string,uint256)`. + mstore(0x00, 0x8eafb02b) + mstore(0x20, 0x80) + mstore(0x40, 0xc0) + mstore(0x60, 0x100) + mstore(0x80, p3) + writeString(0xa0, p0) + writeString(0xe0, p1) + writeString(0x120, p2) + } + _sendLogPayload(0x1c, 0x144); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + mstore(0xa0, m5) + mstore(0xc0, m6) + mstore(0xe0, m7) + mstore(0x100, m8) + mstore(0x120, m9) + mstore(0x140, m10) + } + } + + function log(bytes32 p0, bytes32 p1, bytes32 p2, bytes32 p3) internal pure { + bytes32 m0; + bytes32 m1; + bytes32 m2; + bytes32 m3; + bytes32 m4; + bytes32 m5; + bytes32 m6; + bytes32 m7; + bytes32 m8; + bytes32 m9; + bytes32 m10; + bytes32 m11; + bytes32 m12; + assembly { + function writeString(pos, w) { + let length := 0 + for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } } + mstore(pos, length) + let shift := sub(256, shl(3, length)) + mstore(add(pos, 0x20), shl(shift, shr(shift, w))) + } + m0 := mload(0x00) + m1 := mload(0x20) + m2 := mload(0x40) + m3 := mload(0x60) + m4 := mload(0x80) + m5 := mload(0xa0) + m6 := mload(0xc0) + m7 := mload(0xe0) + m8 := mload(0x100) + m9 := mload(0x120) + m10 := mload(0x140) + m11 := mload(0x160) + m12 := mload(0x180) + // Selector of `log(string,string,string,string)`. + mstore(0x00, 0xde68f20a) + mstore(0x20, 0x80) + mstore(0x40, 0xc0) + mstore(0x60, 0x100) + mstore(0x80, 0x140) + writeString(0xa0, p0) + writeString(0xe0, p1) + writeString(0x120, p2) + writeString(0x160, p3) + } + _sendLogPayload(0x1c, 0x184); + assembly { + mstore(0x00, m0) + mstore(0x20, m1) + mstore(0x40, m2) + mstore(0x60, m3) + mstore(0x80, m4) + mstore(0xa0, m5) + mstore(0xc0, m6) + mstore(0xe0, m7) + mstore(0x100, m8) + mstore(0x120, m9) + mstore(0x140, m10) + mstore(0x160, m11) + mstore(0x180, m12) + } + } +} diff --git a/docs/crypto/zkCTF/day1/Ethereal/mint-contracts/lib/forge-std/test/StdAssertions.t.sol b/docs/crypto/zkCTF/day1/Ethereal/mint-contracts/lib/forge-std/test/StdAssertions.t.sol new file mode 100644 index 0000000..ae998f1 --- /dev/null +++ b/docs/crypto/zkCTF/day1/Ethereal/mint-contracts/lib/forge-std/test/StdAssertions.t.sol @@ -0,0 +1,1015 @@ +// SPDX-License-Identifier: MIT +pragma solidity >=0.7.0 <0.9.0; + +import "../src/Test.sol"; + +contract StdAssertionsTest is Test { + string constant CUSTOM_ERROR = "guh!"; + + bool constant EXPECT_PASS = false; + bool constant EXPECT_FAIL = true; + + bool constant SHOULD_REVERT = true; + bool constant SHOULD_RETURN = false; + + bool constant STRICT_REVERT_DATA = true; + bool constant NON_STRICT_REVERT_DATA = false; + + TestTest t = new TestTest(); + + /*////////////////////////////////////////////////////////////////////////// + FAIL(STRING) + //////////////////////////////////////////////////////////////////////////*/ + + function test_ShouldFail() external { + vm.expectEmit(false, false, false, true); + emit log_named_string("Error", CUSTOM_ERROR); + t._fail(CUSTOM_ERROR); + } + + /*////////////////////////////////////////////////////////////////////////// + ASSERT_FALSE + //////////////////////////////////////////////////////////////////////////*/ + + function test_AssertFalse_Pass() external { + t._assertFalse(false, EXPECT_PASS); + } + + function test_AssertFalse_Fail() external { + vm.expectEmit(false, false, false, true); + emit log("Error: Assertion Failed"); + t._assertFalse(true, EXPECT_FAIL); + } + + function test_AssertFalse_Err_Pass() external { + t._assertFalse(false, CUSTOM_ERROR, EXPECT_PASS); + } + + function test_AssertFalse_Err_Fail() external { + vm.expectEmit(false, false, false, true); + emit log_named_string("Error", CUSTOM_ERROR); + t._assertFalse(true, CUSTOM_ERROR, EXPECT_FAIL); + } + + /*////////////////////////////////////////////////////////////////////////// + ASSERT_EQ(BOOL) + //////////////////////////////////////////////////////////////////////////*/ + + function testFuzz_AssertEq_Bool_Pass(bool a) external { + t._assertEq(a, a, EXPECT_PASS); + } + + function testFuzz_AssertEq_Bool_Fail(bool a, bool b) external { + vm.assume(a != b); + + vm.expectEmit(false, false, false, true); + emit log("Error: a == b not satisfied [bool]"); + t._assertEq(a, b, EXPECT_FAIL); + } + + function testFuzz_AssertEq_BoolErr_Pass(bool a) external { + t._assertEq(a, a, CUSTOM_ERROR, EXPECT_PASS); + } + + function testFuzz_AssertEq_BoolErr_Fail(bool a, bool b) external { + vm.assume(a != b); + + vm.expectEmit(false, false, false, true); + emit log_named_string("Error", CUSTOM_ERROR); + t._assertEq(a, b, CUSTOM_ERROR, EXPECT_FAIL); + } + + /*////////////////////////////////////////////////////////////////////////// + ASSERT_EQ(BYTES) + //////////////////////////////////////////////////////////////////////////*/ + + function testFuzz_AssertEq_Bytes_Pass(bytes calldata a) external { + t._assertEq(a, a, EXPECT_PASS); + } + + function testFuzz_AssertEq_Bytes_Fail(bytes calldata a, bytes calldata b) external { + vm.assume(keccak256(a) != keccak256(b)); + + vm.expectEmit(false, false, false, true); + emit log("Error: a == b not satisfied [bytes]"); + t._assertEq(a, b, EXPECT_FAIL); + } + + function testFuzz_AssertEq_BytesErr_Pass(bytes calldata a) external { + t._assertEq(a, a, CUSTOM_ERROR, EXPECT_PASS); + } + + function testFuzz_AssertEq_BytesErr_Fail(bytes calldata a, bytes calldata b) external { + vm.assume(keccak256(a) != keccak256(b)); + + vm.expectEmit(false, false, false, true); + emit log_named_string("Error", CUSTOM_ERROR); + t._assertEq(a, b, CUSTOM_ERROR, EXPECT_FAIL); + } + + /*////////////////////////////////////////////////////////////////////////// + ASSERT_EQ(ARRAY) + //////////////////////////////////////////////////////////////////////////*/ + + function testFuzz_AssertEq_UintArr_Pass(uint256 e0, uint256 e1, uint256 e2) public { + uint256[] memory a = new uint256[](3); + a[0] = e0; + a[1] = e1; + a[2] = e2; + uint256[] memory b = new uint256[](3); + b[0] = e0; + b[1] = e1; + b[2] = e2; + + t._assertEq(a, b, EXPECT_PASS); + } + + function testFuzz_AssertEq_IntArr_Pass(int256 e0, int256 e1, int256 e2) public { + int256[] memory a = new int256[](3); + a[0] = e0; + a[1] = e1; + a[2] = e2; + int256[] memory b = new int256[](3); + b[0] = e0; + b[1] = e1; + b[2] = e2; + + t._assertEq(a, b, EXPECT_PASS); + } + + function testFuzz_AssertEq_AddressArr_Pass(address e0, address e1, address e2) public { + address[] memory a = new address[](3); + a[0] = e0; + a[1] = e1; + a[2] = e2; + address[] memory b = new address[](3); + b[0] = e0; + b[1] = e1; + b[2] = e2; + + t._assertEq(a, b, EXPECT_PASS); + } + + function testFuzz_AssertEq_UintArr_FailEl(uint256 e1) public { + vm.assume(e1 != 0); + uint256[] memory a = new uint256[](3); + uint256[] memory b = new uint256[](3); + b[1] = e1; + + vm.expectEmit(false, false, false, true); + emit log("Error: a == b not satisfied [uint[]]"); + t._assertEq(a, b, EXPECT_FAIL); + } + + function testFuzz_AssertEq_IntArr_FailEl(int256 e1) public { + vm.assume(e1 != 0); + int256[] memory a = new int256[](3); + int256[] memory b = new int256[](3); + b[1] = e1; + + vm.expectEmit(false, false, false, true); + emit log("Error: a == b not satisfied [int[]]"); + t._assertEq(a, b, EXPECT_FAIL); + } + + function testFuzz_AssertEq_AddressArr_FailEl(address e1) public { + vm.assume(e1 != address(0)); + address[] memory a = new address[](3); + address[] memory b = new address[](3); + b[1] = e1; + + vm.expectEmit(false, false, false, true); + emit log("Error: a == b not satisfied [address[]]"); + t._assertEq(a, b, EXPECT_FAIL); + } + + function testFuzz_AssertEq_UintArrErr_FailEl(uint256 e1) public { + vm.assume(e1 != 0); + uint256[] memory a = new uint256[](3); + uint256[] memory b = new uint256[](3); + b[1] = e1; + + vm.expectEmit(false, false, false, true); + emit log_named_string("Error", CUSTOM_ERROR); + vm.expectEmit(false, false, false, true); + emit log("Error: a == b not satisfied [uint[]]"); + t._assertEq(a, b, CUSTOM_ERROR, EXPECT_FAIL); + } + + function testFuzz_AssertEq_IntArrErr_FailEl(int256 e1) public { + vm.assume(e1 != 0); + int256[] memory a = new int256[](3); + int256[] memory b = new int256[](3); + b[1] = e1; + + vm.expectEmit(false, false, false, true); + emit log_named_string("Error", CUSTOM_ERROR); + vm.expectEmit(false, false, false, true); + emit log("Error: a == b not satisfied [int[]]"); + t._assertEq(a, b, CUSTOM_ERROR, EXPECT_FAIL); + } + + function testFuzz_AssertEq_AddressArrErr_FailEl(address e1) public { + vm.assume(e1 != address(0)); + address[] memory a = new address[](3); + address[] memory b = new address[](3); + b[1] = e1; + + vm.expectEmit(false, false, false, true); + emit log_named_string("Error", CUSTOM_ERROR); + vm.expectEmit(false, false, false, true); + emit log("Error: a == b not satisfied [address[]]"); + t._assertEq(a, b, CUSTOM_ERROR, EXPECT_FAIL); + } + + function testFuzz_AssertEq_UintArr_FailLen(uint256 lenA, uint256 lenB) public { + vm.assume(lenA != lenB); + vm.assume(lenA <= 10000); + vm.assume(lenB <= 10000); + uint256[] memory a = new uint256[](lenA); + uint256[] memory b = new uint256[](lenB); + + vm.expectEmit(false, false, false, true); + emit log("Error: a == b not satisfied [uint[]]"); + t._assertEq(a, b, EXPECT_FAIL); + } + + function testFuzz_AssertEq_IntArr_FailLen(uint256 lenA, uint256 lenB) public { + vm.assume(lenA != lenB); + vm.assume(lenA <= 10000); + vm.assume(lenB <= 10000); + int256[] memory a = new int256[](lenA); + int256[] memory b = new int256[](lenB); + + vm.expectEmit(false, false, false, true); + emit log("Error: a == b not satisfied [int[]]"); + t._assertEq(a, b, EXPECT_FAIL); + } + + function testFuzz_AssertEq_AddressArr_FailLen(uint256 lenA, uint256 lenB) public { + vm.assume(lenA != lenB); + vm.assume(lenA <= 10000); + vm.assume(lenB <= 10000); + address[] memory a = new address[](lenA); + address[] memory b = new address[](lenB); + + vm.expectEmit(false, false, false, true); + emit log("Error: a == b not satisfied [address[]]"); + t._assertEq(a, b, EXPECT_FAIL); + } + + function testFuzz_AssertEq_UintArrErr_FailLen(uint256 lenA, uint256 lenB) public { + vm.assume(lenA != lenB); + vm.assume(lenA <= 10000); + vm.assume(lenB <= 10000); + uint256[] memory a = new uint256[](lenA); + uint256[] memory b = new uint256[](lenB); + + vm.expectEmit(false, false, false, true); + emit log_named_string("Error", CUSTOM_ERROR); + vm.expectEmit(false, false, false, true); + emit log("Error: a == b not satisfied [uint[]]"); + t._assertEq(a, b, CUSTOM_ERROR, EXPECT_FAIL); + } + + function testFuzz_AssertEq_IntArrErr_FailLen(uint256 lenA, uint256 lenB) public { + vm.assume(lenA != lenB); + vm.assume(lenA <= 10000); + vm.assume(lenB <= 10000); + int256[] memory a = new int256[](lenA); + int256[] memory b = new int256[](lenB); + + vm.expectEmit(false, false, false, true); + emit log_named_string("Error", CUSTOM_ERROR); + vm.expectEmit(false, false, false, true); + emit log("Error: a == b not satisfied [int[]]"); + t._assertEq(a, b, CUSTOM_ERROR, EXPECT_FAIL); + } + + function testFuzz_AssertEq_AddressArrErr_FailLen(uint256 lenA, uint256 lenB) public { + vm.assume(lenA != lenB); + vm.assume(lenA <= 10000); + vm.assume(lenB <= 10000); + address[] memory a = new address[](lenA); + address[] memory b = new address[](lenB); + + vm.expectEmit(false, false, false, true); + emit log_named_string("Error", CUSTOM_ERROR); + vm.expectEmit(false, false, false, true); + emit log("Error: a == b not satisfied [address[]]"); + t._assertEq(a, b, CUSTOM_ERROR, EXPECT_FAIL); + } + + /*////////////////////////////////////////////////////////////////////////// + ASSERT_EQ(UINT) + //////////////////////////////////////////////////////////////////////////*/ + + function test_AssertEqUint() public { + assertEqUint(uint8(1), uint128(1)); + assertEqUint(uint64(2), uint64(2)); + } + + function testFail_AssertEqUint() public { + assertEqUint(uint64(1), uint96(2)); + assertEqUint(uint160(3), uint160(4)); + } + + /*////////////////////////////////////////////////////////////////////////// + APPROX_EQ_ABS(UINT) + //////////////////////////////////////////////////////////////////////////*/ + + function testFuzz_AssertApproxEqAbs_Uint_Pass(uint256 a, uint256 b, uint256 maxDelta) external { + vm.assume(stdMath.delta(a, b) <= maxDelta); + + t._assertApproxEqAbs(a, b, maxDelta, EXPECT_PASS); + } + + function testFuzz_AssertApproxEqAbs_Uint_Fail(uint256 a, uint256 b, uint256 maxDelta) external { + vm.assume(stdMath.delta(a, b) > maxDelta); + + vm.expectEmit(false, false, false, true); + emit log("Error: a ~= b not satisfied [uint]"); + t._assertApproxEqAbs(a, b, maxDelta, EXPECT_FAIL); + } + + function testFuzz_AssertApproxEqAbs_UintErr_Pass(uint256 a, uint256 b, uint256 maxDelta) external { + vm.assume(stdMath.delta(a, b) <= maxDelta); + + t._assertApproxEqAbs(a, b, maxDelta, CUSTOM_ERROR, EXPECT_PASS); + } + + function testFuzz_AssertApproxEqAbs_UintErr_Fail(uint256 a, uint256 b, uint256 maxDelta) external { + vm.assume(stdMath.delta(a, b) > maxDelta); + + vm.expectEmit(false, false, false, true); + emit log_named_string("Error", CUSTOM_ERROR); + t._assertApproxEqAbs(a, b, maxDelta, CUSTOM_ERROR, EXPECT_FAIL); + } + + /*////////////////////////////////////////////////////////////////////////// + APPROX_EQ_ABS_DECIMAL(UINT) + //////////////////////////////////////////////////////////////////////////*/ + + function testFuzz_AssertApproxEqAbsDecimal_Uint_Pass(uint256 a, uint256 b, uint256 maxDelta, uint256 decimals) + external + { + vm.assume(stdMath.delta(a, b) <= maxDelta); + + t._assertApproxEqAbsDecimal(a, b, maxDelta, decimals, EXPECT_PASS); + } + + function testFuzz_AssertApproxEqAbsDecimal_Uint_Fail(uint256 a, uint256 b, uint256 maxDelta, uint256 decimals) + external + { + vm.assume(stdMath.delta(a, b) > maxDelta); + + vm.expectEmit(false, false, false, true); + emit log("Error: a ~= b not satisfied [uint]"); + t._assertApproxEqAbsDecimal(a, b, maxDelta, decimals, EXPECT_FAIL); + } + + function testFuzz_AssertApproxEqAbsDecimal_UintErr_Pass(uint256 a, uint256 b, uint256 maxDelta, uint256 decimals) + external + { + vm.assume(stdMath.delta(a, b) <= maxDelta); + + t._assertApproxEqAbsDecimal(a, b, maxDelta, decimals, CUSTOM_ERROR, EXPECT_PASS); + } + + function testFuzz_AssertApproxEqAbsDecimal_UintErr_Fail(uint256 a, uint256 b, uint256 maxDelta, uint256 decimals) + external + { + vm.assume(stdMath.delta(a, b) > maxDelta); + + vm.expectEmit(false, false, false, true); + emit log_named_string("Error", CUSTOM_ERROR); + t._assertApproxEqAbsDecimal(a, b, maxDelta, decimals, CUSTOM_ERROR, EXPECT_FAIL); + } + + /*////////////////////////////////////////////////////////////////////////// + APPROX_EQ_ABS(INT) + //////////////////////////////////////////////////////////////////////////*/ + + function testFuzz_AssertApproxEqAbs_Int_Pass(int256 a, int256 b, uint256 maxDelta) external { + vm.assume(stdMath.delta(a, b) <= maxDelta); + + t._assertApproxEqAbs(a, b, maxDelta, EXPECT_PASS); + } + + function testFuzz_AssertApproxEqAbs_Int_Fail(int256 a, int256 b, uint256 maxDelta) external { + vm.assume(stdMath.delta(a, b) > maxDelta); + + vm.expectEmit(false, false, false, true); + emit log("Error: a ~= b not satisfied [int]"); + t._assertApproxEqAbs(a, b, maxDelta, EXPECT_FAIL); + } + + function testFuzz_AssertApproxEqAbs_IntErr_Pass(int256 a, int256 b, uint256 maxDelta) external { + vm.assume(stdMath.delta(a, b) <= maxDelta); + + t._assertApproxEqAbs(a, b, maxDelta, CUSTOM_ERROR, EXPECT_PASS); + } + + function testFuzz_AssertApproxEqAbs_IntErr_Fail(int256 a, int256 b, uint256 maxDelta) external { + vm.assume(stdMath.delta(a, b) > maxDelta); + + vm.expectEmit(false, false, false, true); + emit log_named_string("Error", CUSTOM_ERROR); + t._assertApproxEqAbs(a, b, maxDelta, CUSTOM_ERROR, EXPECT_FAIL); + } + + /*////////////////////////////////////////////////////////////////////////// + APPROX_EQ_ABS_DECIMAL(INT) + //////////////////////////////////////////////////////////////////////////*/ + + function testFuzz_AssertApproxEqAbsDecimal_Int_Pass(int256 a, int256 b, uint256 maxDelta, uint256 decimals) + external + { + vm.assume(stdMath.delta(a, b) <= maxDelta); + + t._assertApproxEqAbsDecimal(a, b, maxDelta, decimals, EXPECT_PASS); + } + + function testFuzz_AssertApproxEqAbsDecimal_Int_Fail(int256 a, int256 b, uint256 maxDelta, uint256 decimals) + external + { + vm.assume(stdMath.delta(a, b) > maxDelta); + + vm.expectEmit(false, false, false, true); + emit log("Error: a ~= b not satisfied [int]"); + t._assertApproxEqAbsDecimal(a, b, maxDelta, decimals, EXPECT_FAIL); + } + + function testFuzz_AssertApproxEqAbsDecimal_IntErr_Pass(int256 a, int256 b, uint256 maxDelta, uint256 decimals) + external + { + vm.assume(stdMath.delta(a, b) <= maxDelta); + + t._assertApproxEqAbsDecimal(a, b, maxDelta, decimals, CUSTOM_ERROR, EXPECT_PASS); + } + + function testFuzz_AssertApproxEqAbsDecimal_IntErr_Fail(int256 a, int256 b, uint256 maxDelta, uint256 decimals) + external + { + vm.assume(stdMath.delta(a, b) > maxDelta); + + vm.expectEmit(false, false, false, true); + emit log_named_string("Error", CUSTOM_ERROR); + t._assertApproxEqAbsDecimal(a, b, maxDelta, decimals, CUSTOM_ERROR, EXPECT_FAIL); + } + + /*////////////////////////////////////////////////////////////////////////// + APPROX_EQ_REL(UINT) + //////////////////////////////////////////////////////////////////////////*/ + + function testFuzz_AssertApproxEqRel_Uint_Pass(uint256 a, uint256 b, uint256 maxPercentDelta) external { + vm.assume(a < type(uint128).max && b < type(uint128).max && b != 0); + vm.assume(stdMath.percentDelta(a, b) <= maxPercentDelta); + + t._assertApproxEqRel(a, b, maxPercentDelta, EXPECT_PASS); + } + + function testFuzz_AssertApproxEqRel_Uint_Fail(uint256 a, uint256 b, uint256 maxPercentDelta) external { + vm.assume(a < type(uint128).max && b < type(uint128).max && b != 0); + vm.assume(stdMath.percentDelta(a, b) > maxPercentDelta); + + vm.expectEmit(false, false, false, true); + emit log("Error: a ~= b not satisfied [uint]"); + t._assertApproxEqRel(a, b, maxPercentDelta, EXPECT_FAIL); + } + + function testFuzz_AssertApproxEqRel_UintErr_Pass(uint256 a, uint256 b, uint256 maxPercentDelta) external { + vm.assume(a < type(uint128).max && b < type(uint128).max && b != 0); + vm.assume(stdMath.percentDelta(a, b) <= maxPercentDelta); + + t._assertApproxEqRel(a, b, maxPercentDelta, CUSTOM_ERROR, EXPECT_PASS); + } + + function testFuzz_AssertApproxEqRel_UintErr_Fail(uint256 a, uint256 b, uint256 maxPercentDelta) external { + vm.assume(a < type(uint128).max && b < type(uint128).max && b != 0); + vm.assume(stdMath.percentDelta(a, b) > maxPercentDelta); + + vm.expectEmit(false, false, false, true); + emit log_named_string("Error", CUSTOM_ERROR); + t._assertApproxEqRel(a, b, maxPercentDelta, CUSTOM_ERROR, EXPECT_FAIL); + } + + /*////////////////////////////////////////////////////////////////////////// + APPROX_EQ_REL_DECIMAL(UINT) + //////////////////////////////////////////////////////////////////////////*/ + + function testFuzz_AssertApproxEqRelDecimal_Uint_Pass( + uint256 a, + uint256 b, + uint256 maxPercentDelta, + uint256 decimals + ) external { + vm.assume(a < type(uint128).max && b < type(uint128).max && b != 0); + vm.assume(stdMath.percentDelta(a, b) <= maxPercentDelta); + + t._assertApproxEqRelDecimal(a, b, maxPercentDelta, decimals, EXPECT_PASS); + } + + function testFuzz_AssertApproxEqRelDecimal_Uint_Fail( + uint256 a, + uint256 b, + uint256 maxPercentDelta, + uint256 decimals + ) external { + vm.assume(a < type(uint128).max && b < type(uint128).max && b != 0); + vm.assume(stdMath.percentDelta(a, b) > maxPercentDelta); + + vm.expectEmit(false, false, false, true); + emit log("Error: a ~= b not satisfied [uint]"); + t._assertApproxEqRelDecimal(a, b, maxPercentDelta, decimals, EXPECT_FAIL); + } + + function testFuzz_AssertApproxEqRelDecimal_UintErr_Pass( + uint256 a, + uint256 b, + uint256 maxPercentDelta, + uint256 decimals + ) external { + vm.assume(a < type(uint128).max && b < type(uint128).max && b != 0); + vm.assume(stdMath.percentDelta(a, b) <= maxPercentDelta); + + t._assertApproxEqRelDecimal(a, b, maxPercentDelta, decimals, CUSTOM_ERROR, EXPECT_PASS); + } + + function testFuzz_AssertApproxEqRelDecimal_UintErr_Fail( + uint256 a, + uint256 b, + uint256 maxPercentDelta, + uint256 decimals + ) external { + vm.assume(a < type(uint128).max && b < type(uint128).max && b != 0); + vm.assume(stdMath.percentDelta(a, b) > maxPercentDelta); + + vm.expectEmit(false, false, false, true); + emit log_named_string("Error", CUSTOM_ERROR); + t._assertApproxEqRelDecimal(a, b, maxPercentDelta, decimals, CUSTOM_ERROR, EXPECT_FAIL); + } + + /*////////////////////////////////////////////////////////////////////////// + APPROX_EQ_REL(INT) + //////////////////////////////////////////////////////////////////////////*/ + + function testFuzz_AssertApproxEqRel_Int_Pass(int128 a, int128 b, uint128 maxPercentDelta) external { + vm.assume(b != 0); + vm.assume(stdMath.percentDelta(a, b) <= maxPercentDelta); + + t._assertApproxEqRel(a, b, maxPercentDelta, EXPECT_PASS); + } + + function testFuzz_AssertApproxEqRel_Int_Fail(int128 a, int128 b, uint128 maxPercentDelta) external { + vm.assume(b != 0); + vm.assume(stdMath.percentDelta(a, b) > maxPercentDelta); + + vm.expectEmit(false, false, false, true); + emit log("Error: a ~= b not satisfied [int]"); + t._assertApproxEqRel(a, b, maxPercentDelta, EXPECT_FAIL); + } + + function testFuzz_AssertApproxEqRel_IntErr_Pass(int128 a, int128 b, uint128 maxPercentDelta) external { + vm.assume(b != 0); + vm.assume(stdMath.percentDelta(a, b) <= maxPercentDelta); + + t._assertApproxEqRel(a, b, maxPercentDelta, CUSTOM_ERROR, EXPECT_PASS); + } + + function testFuzz_AssertApproxEqRel_IntErr_Fail(int128 a, int128 b, uint128 maxPercentDelta) external { + vm.assume(b != 0); + vm.assume(stdMath.percentDelta(a, b) > maxPercentDelta); + + vm.expectEmit(false, false, false, true); + emit log_named_string("Error", CUSTOM_ERROR); + t._assertApproxEqRel(a, b, maxPercentDelta, CUSTOM_ERROR, EXPECT_FAIL); + } + + /*////////////////////////////////////////////////////////////////////////// + APPROX_EQ_REL_DECIMAL(INT) + //////////////////////////////////////////////////////////////////////////*/ + + function testAssertApproxEqRelDecimal_Int_Pass(int128 a, int128 b, uint128 maxPercentDelta, uint128 decimals) + external + { + vm.assume(b != 0); + vm.assume(stdMath.percentDelta(a, b) <= maxPercentDelta); + + t._assertApproxEqRelDecimal(a, b, maxPercentDelta, decimals, EXPECT_PASS); + } + + function testAssertApproxEqRelDecimal_Int_Fail(int128 a, int128 b, uint128 maxPercentDelta, uint128 decimals) + external + { + vm.assume(b != 0); + vm.assume(stdMath.percentDelta(a, b) > maxPercentDelta); + + vm.expectEmit(false, false, false, true); + emit log("Error: a ~= b not satisfied [int]"); + t._assertApproxEqRelDecimal(a, b, maxPercentDelta, decimals, EXPECT_FAIL); + } + + function testAssertApproxEqRelDecimal_IntErr_Pass(int128 a, int128 b, uint128 maxPercentDelta, uint128 decimals) + external + { + vm.assume(b != 0); + vm.assume(stdMath.percentDelta(a, b) <= maxPercentDelta); + + t._assertApproxEqRelDecimal(a, b, maxPercentDelta, decimals, CUSTOM_ERROR, EXPECT_PASS); + } + + function testAssertApproxEqRelDecimal_IntErr_Fail(int128 a, int128 b, uint128 maxPercentDelta, uint128 decimals) + external + { + vm.assume(b != 0); + vm.assume(stdMath.percentDelta(a, b) > maxPercentDelta); + + vm.expectEmit(false, false, false, true); + emit log_named_string("Error", CUSTOM_ERROR); + t._assertApproxEqRelDecimal(a, b, maxPercentDelta, decimals, CUSTOM_ERROR, EXPECT_FAIL); + } + + /*////////////////////////////////////////////////////////////////////////// + ASSERT_EQ_CALL + //////////////////////////////////////////////////////////////////////////*/ + + function testFuzz_AssertEqCall_Return_Pass( + bytes memory callDataA, + bytes memory callDataB, + bytes memory returnData, + bool strictRevertData + ) external { + address targetA = address(new TestMockCall(returnData, SHOULD_RETURN)); + address targetB = address(new TestMockCall(returnData, SHOULD_RETURN)); + + t._assertEqCall(targetA, callDataA, targetB, callDataB, strictRevertData, EXPECT_PASS); + } + + function testFuzz_RevertWhenCalled_AssertEqCall_Return_Fail( + bytes memory callDataA, + bytes memory callDataB, + bytes memory returnDataA, + bytes memory returnDataB, + bool strictRevertData + ) external { + vm.assume(keccak256(returnDataA) != keccak256(returnDataB)); + + address targetA = address(new TestMockCall(returnDataA, SHOULD_RETURN)); + address targetB = address(new TestMockCall(returnDataB, SHOULD_RETURN)); + + vm.expectEmit(true, true, true, true); + emit log_named_string("Error", "Call return data does not match"); + t._assertEqCall(targetA, callDataA, targetB, callDataB, strictRevertData, EXPECT_FAIL); + } + + function testFuzz_AssertEqCall_Revert_Pass( + bytes memory callDataA, + bytes memory callDataB, + bytes memory revertDataA, + bytes memory revertDataB + ) external { + address targetA = address(new TestMockCall(revertDataA, SHOULD_REVERT)); + address targetB = address(new TestMockCall(revertDataB, SHOULD_REVERT)); + + t._assertEqCall(targetA, callDataA, targetB, callDataB, NON_STRICT_REVERT_DATA, EXPECT_PASS); + } + + function testFuzz_RevertWhenCalled_AssertEqCall_Revert_Fail( + bytes memory callDataA, + bytes memory callDataB, + bytes memory revertDataA, + bytes memory revertDataB + ) external { + vm.assume(keccak256(revertDataA) != keccak256(revertDataB)); + + address targetA = address(new TestMockCall(revertDataA, SHOULD_REVERT)); + address targetB = address(new TestMockCall(revertDataB, SHOULD_REVERT)); + + vm.expectEmit(true, true, true, true); + emit log_named_string("Error", "Call revert data does not match"); + t._assertEqCall(targetA, callDataA, targetB, callDataB, STRICT_REVERT_DATA, EXPECT_FAIL); + } + + function testFuzz_RevertWhenCalled_AssertEqCall_Fail( + bytes memory callDataA, + bytes memory callDataB, + bytes memory returnDataA, + bytes memory returnDataB, + bool strictRevertData + ) external { + address targetA = address(new TestMockCall(returnDataA, SHOULD_RETURN)); + address targetB = address(new TestMockCall(returnDataB, SHOULD_REVERT)); + + vm.expectEmit(true, true, true, true); + emit log_named_bytes(" Left call return data", returnDataA); + vm.expectEmit(true, true, true, true); + emit log_named_bytes(" Right call revert data", returnDataB); + t._assertEqCall(targetA, callDataA, targetB, callDataB, strictRevertData, EXPECT_FAIL); + + vm.expectEmit(true, true, true, true); + emit log_named_bytes(" Left call revert data", returnDataB); + vm.expectEmit(true, true, true, true); + emit log_named_bytes(" Right call return data", returnDataA); + t._assertEqCall(targetB, callDataB, targetA, callDataA, strictRevertData, EXPECT_FAIL); + } + + /*////////////////////////////////////////////////////////////////////////// + ASSERT_NOT_EQ(BYTES) + //////////////////////////////////////////////////////////////////////////*/ + + function testFuzz_AssertNotEq_Bytes_Pass(bytes32 a, bytes32 b) external { + vm.assume(a != b); + t._assertNotEq(a, b, EXPECT_PASS); + } + + function testFuzz_AssertNotEq_Bytes_Fail(bytes32 a) external { + vm.expectEmit(false, false, false, true); + emit log("Error: a != b not satisfied [bytes32]"); + t._assertNotEq(a, a, EXPECT_FAIL); + } + + function testFuzz_AssertNotEq_BytesErr_Pass(bytes32 a, bytes32 b) external { + vm.assume(a != b); + t._assertNotEq(a, b, CUSTOM_ERROR, EXPECT_PASS); + } + + function testFuzz_AsserNottEq_BytesErr_Fail(bytes32 a) external { + vm.expectEmit(false, false, false, true); + emit log_named_string("Error", CUSTOM_ERROR); + t._assertNotEq(a, a, CUSTOM_ERROR, EXPECT_FAIL); + } + + /*////////////////////////////////////////////////////////////////////////// + ASSERT_NOT_EQ(UINT) + //////////////////////////////////////////////////////////////////////////*/ + + function test_AssertNotEqUint() public { + assertNotEq(uint8(1), uint128(2)); + assertNotEq(uint64(3), uint64(4)); + } + + function testFail_AssertNotEqUint() public { + assertNotEq(uint64(1), uint96(1)); + assertNotEq(uint160(2), uint160(2)); + } +} + +contract TestTest is Test { + modifier expectFailure(bool expectFail) { + bool preState = vm.load(HEVM_ADDRESS, bytes32("failed")) != bytes32(0x00); + _; + bool postState = vm.load(HEVM_ADDRESS, bytes32("failed")) != bytes32(0x00); + + if (preState == true) { + return; + } + + if (expectFail) { + require(postState == true, "expected failure not triggered"); + + // unwind the expected failure + vm.store(HEVM_ADDRESS, bytes32("failed"), bytes32(uint256(0x00))); + } else { + require(postState == false, "unexpected failure was triggered"); + } + } + + function _fail(string memory err) external expectFailure(true) { + fail(err); + } + + function _assertFalse(bool data, bool expectFail) external expectFailure(expectFail) { + assertFalse(data); + } + + function _assertFalse(bool data, string memory err, bool expectFail) external expectFailure(expectFail) { + assertFalse(data, err); + } + + function _assertEq(bool a, bool b, bool expectFail) external expectFailure(expectFail) { + assertEq(a, b); + } + + function _assertEq(bool a, bool b, string memory err, bool expectFail) external expectFailure(expectFail) { + assertEq(a, b, err); + } + + function _assertEq(bytes memory a, bytes memory b, bool expectFail) external expectFailure(expectFail) { + assertEq(a, b); + } + + function _assertEq(bytes memory a, bytes memory b, string memory err, bool expectFail) + external + expectFailure(expectFail) + { + assertEq(a, b, err); + } + + function _assertEq(uint256[] memory a, uint256[] memory b, bool expectFail) external expectFailure(expectFail) { + assertEq(a, b); + } + + function _assertEq(int256[] memory a, int256[] memory b, bool expectFail) external expectFailure(expectFail) { + assertEq(a, b); + } + + function _assertEq(address[] memory a, address[] memory b, bool expectFail) external expectFailure(expectFail) { + assertEq(a, b); + } + + function _assertEq(uint256[] memory a, uint256[] memory b, string memory err, bool expectFail) + external + expectFailure(expectFail) + { + assertEq(a, b, err); + } + + function _assertEq(int256[] memory a, int256[] memory b, string memory err, bool expectFail) + external + expectFailure(expectFail) + { + assertEq(a, b, err); + } + + function _assertEq(address[] memory a, address[] memory b, string memory err, bool expectFail) + external + expectFailure(expectFail) + { + assertEq(a, b, err); + } + + function _assertNotEq(bytes32 a, bytes32 b, bool expectFail) external expectFailure(expectFail) { + assertNotEq32(a, b); + } + + function _assertNotEq(bytes32 a, bytes32 b, string memory err, bool expectFail) + external + expectFailure(expectFail) + { + assertNotEq32(a, b, err); + } + + function _assertApproxEqAbs(uint256 a, uint256 b, uint256 maxDelta, bool expectFail) + external + expectFailure(expectFail) + { + assertApproxEqAbs(a, b, maxDelta); + } + + function _assertApproxEqAbs(uint256 a, uint256 b, uint256 maxDelta, string memory err, bool expectFail) + external + expectFailure(expectFail) + { + assertApproxEqAbs(a, b, maxDelta, err); + } + + function _assertApproxEqAbsDecimal(uint256 a, uint256 b, uint256 maxDelta, uint256 decimals, bool expectFail) + external + expectFailure(expectFail) + { + assertApproxEqAbsDecimal(a, b, maxDelta, decimals); + } + + function _assertApproxEqAbsDecimal( + uint256 a, + uint256 b, + uint256 maxDelta, + uint256 decimals, + string memory err, + bool expectFail + ) external expectFailure(expectFail) { + assertApproxEqAbsDecimal(a, b, maxDelta, decimals, err); + } + + function _assertApproxEqAbs(int256 a, int256 b, uint256 maxDelta, bool expectFail) + external + expectFailure(expectFail) + { + assertApproxEqAbs(a, b, maxDelta); + } + + function _assertApproxEqAbs(int256 a, int256 b, uint256 maxDelta, string memory err, bool expectFail) + external + expectFailure(expectFail) + { + assertApproxEqAbs(a, b, maxDelta, err); + } + + function _assertApproxEqAbsDecimal(int256 a, int256 b, uint256 maxDelta, uint256 decimals, bool expectFail) + external + expectFailure(expectFail) + { + assertApproxEqAbsDecimal(a, b, maxDelta, decimals); + } + + function _assertApproxEqAbsDecimal( + int256 a, + int256 b, + uint256 maxDelta, + uint256 decimals, + string memory err, + bool expectFail + ) external expectFailure(expectFail) { + assertApproxEqAbsDecimal(a, b, maxDelta, decimals, err); + } + + function _assertApproxEqRel(uint256 a, uint256 b, uint256 maxPercentDelta, bool expectFail) + external + expectFailure(expectFail) + { + assertApproxEqRel(a, b, maxPercentDelta); + } + + function _assertApproxEqRel(uint256 a, uint256 b, uint256 maxPercentDelta, string memory err, bool expectFail) + external + expectFailure(expectFail) + { + assertApproxEqRel(a, b, maxPercentDelta, err); + } + + function _assertApproxEqRelDecimal(uint256 a, uint256 b, uint256 maxPercentDelta, uint256 decimals, bool expectFail) + external + expectFailure(expectFail) + { + assertApproxEqRelDecimal(a, b, maxPercentDelta, decimals); + } + + function _assertApproxEqRelDecimal( + uint256 a, + uint256 b, + uint256 maxPercentDelta, + uint256 decimals, + string memory err, + bool expectFail + ) external expectFailure(expectFail) { + assertApproxEqRelDecimal(a, b, maxPercentDelta, decimals, err); + } + + function _assertApproxEqRel(int256 a, int256 b, uint256 maxPercentDelta, bool expectFail) + external + expectFailure(expectFail) + { + assertApproxEqRel(a, b, maxPercentDelta); + } + + function _assertApproxEqRel(int256 a, int256 b, uint256 maxPercentDelta, string memory err, bool expectFail) + external + expectFailure(expectFail) + { + assertApproxEqRel(a, b, maxPercentDelta, err); + } + + function _assertApproxEqRelDecimal(int256 a, int256 b, uint256 maxPercentDelta, uint256 decimals, bool expectFail) + external + expectFailure(expectFail) + { + assertApproxEqRelDecimal(a, b, maxPercentDelta, decimals); + } + + function _assertApproxEqRelDecimal( + int256 a, + int256 b, + uint256 maxPercentDelta, + uint256 decimals, + string memory err, + bool expectFail + ) external expectFailure(expectFail) { + assertApproxEqRelDecimal(a, b, maxPercentDelta, decimals, err); + } + + function _assertEqCall( + address targetA, + bytes memory callDataA, + address targetB, + bytes memory callDataB, + bool strictRevertData, + bool expectFail + ) external expectFailure(expectFail) { + assertEqCall(targetA, callDataA, targetB, callDataB, strictRevertData); + } +} + +contract TestMockCall { + bytes returnData; + bool shouldRevert; + + constructor(bytes memory returnData_, bool shouldRevert_) { + returnData = returnData_; + shouldRevert = shouldRevert_; + } + + fallback() external payable { + bytes memory returnData_ = returnData; + + if (shouldRevert) { + assembly { + revert(add(returnData_, 0x20), mload(returnData_)) + } + } else { + assembly { + return(add(returnData_, 0x20), mload(returnData_)) + } + } + } +} diff --git a/docs/crypto/zkCTF/day1/Ethereal/mint-contracts/lib/forge-std/test/StdChains.t.sol b/docs/crypto/zkCTF/day1/Ethereal/mint-contracts/lib/forge-std/test/StdChains.t.sol new file mode 100644 index 0000000..b329125 --- /dev/null +++ b/docs/crypto/zkCTF/day1/Ethereal/mint-contracts/lib/forge-std/test/StdChains.t.sol @@ -0,0 +1,216 @@ +// SPDX-License-Identifier: MIT +pragma solidity >=0.7.0 <0.9.0; + +import "../src/Test.sol"; + +contract StdChainsMock is Test { + function exposed_getChain(string memory chainAlias) public returns (Chain memory) { + return getChain(chainAlias); + } + + function exposed_getChain(uint256 chainId) public returns (Chain memory) { + return getChain(chainId); + } + + function exposed_setChain(string memory chainAlias, ChainData memory chainData) public { + setChain(chainAlias, chainData); + } + + function exposed_setFallbackToDefaultRpcUrls(bool useDefault) public { + setFallbackToDefaultRpcUrls(useDefault); + } +} + +contract StdChainsTest is Test { + function test_ChainRpcInitialization() public { + // RPCs specified in `foundry.toml` should be updated. + assertEq(getChain(1).rpcUrl, "https://mainnet.infura.io/v3/b1d3925804e74152b316ca7da97060d3"); + assertEq(getChain("optimism_goerli").rpcUrl, "https://goerli.optimism.io/"); + assertEq(getChain("arbitrum_one_goerli").rpcUrl, "https://goerli-rollup.arbitrum.io/rpc/"); + + // Environment variables should be the next fallback + assertEq(getChain("arbitrum_nova").rpcUrl, "https://nova.arbitrum.io/rpc"); + vm.setEnv("ARBITRUM_NOVA_RPC_URL", "myoverride"); + assertEq(getChain("arbitrum_nova").rpcUrl, "myoverride"); + vm.setEnv("ARBITRUM_NOVA_RPC_URL", "https://nova.arbitrum.io/rpc"); + + // Cannot override RPCs defined in `foundry.toml` + vm.setEnv("MAINNET_RPC_URL", "myoverride2"); + assertEq(getChain("mainnet").rpcUrl, "https://mainnet.infura.io/v3/b1d3925804e74152b316ca7da97060d3"); + + // Other RPCs should remain unchanged. + assertEq(getChain(31337).rpcUrl, "http://127.0.0.1:8545"); + assertEq(getChain("sepolia").rpcUrl, "https://sepolia.infura.io/v3/b9794ad1ddf84dfb8c34d6bb5dca2001"); + } + + function testFuzz_Rpc(string memory rpcAlias) internal { + string memory rpcUrl = getChain(rpcAlias).rpcUrl; + vm.createSelectFork(rpcUrl); + } + + // Ensure we can connect to the default RPC URL for each chain. + // function testRpcs() public { + // testRpc("mainnet"); + // testRpc("goerli"); + // testRpc("sepolia"); + // testRpc("optimism"); + // testRpc("optimism_goerli"); + // testRpc("arbitrum_one"); + // testRpc("arbitrum_one_goerli"); + // testRpc("arbitrum_nova"); + // testRpc("polygon"); + // testRpc("polygon_mumbai"); + // testRpc("avalanche"); + // testRpc("avalanche_fuji"); + // testRpc("bnb_smart_chain"); + // testRpc("bnb_smart_chain_testnet"); + // testRpc("gnosis_chain"); + // testRpc("moonbeam"); + // testRpc("moonriver"); + // testRpc("moonbase"); + // testRpc("base_goerli"); + // testRpc("base"); + // } + + function test_ChainNoDefault() public { + // We deploy a mock to properly test the revert. + StdChainsMock stdChainsMock = new StdChainsMock(); + + vm.expectRevert("StdChains getChain(string): Chain with alias \"does_not_exist\" not found."); + stdChainsMock.exposed_getChain("does_not_exist"); + } + + function test_SetChainFirstFails() public { + // We deploy a mock to properly test the revert. + StdChainsMock stdChainsMock = new StdChainsMock(); + + vm.expectRevert("StdChains setChain(string,ChainData): Chain ID 31337 already used by \"anvil\"."); + stdChainsMock.exposed_setChain("anvil2", ChainData("Anvil", 31337, "URL")); + } + + function test_ChainBubbleUp() public { + // We deploy a mock to properly test the revert. + StdChainsMock stdChainsMock = new StdChainsMock(); + + stdChainsMock.exposed_setChain("needs_undefined_env_var", ChainData("", 123456789, "")); + vm.expectRevert( + "Failed to resolve env var `UNDEFINED_RPC_URL_PLACEHOLDER` in `${UNDEFINED_RPC_URL_PLACEHOLDER}`: environment variable not found" + ); + stdChainsMock.exposed_getChain("needs_undefined_env_var"); + } + + function test_CannotSetChain_ChainIdExists() public { + // We deploy a mock to properly test the revert. + StdChainsMock stdChainsMock = new StdChainsMock(); + + stdChainsMock.exposed_setChain("custom_chain", ChainData("Custom Chain", 123456789, "https://custom.chain/")); + + vm.expectRevert('StdChains setChain(string,ChainData): Chain ID 123456789 already used by "custom_chain".'); + + stdChainsMock.exposed_setChain("another_custom_chain", ChainData("", 123456789, "")); + } + + function test_SetChain() public { + setChain("custom_chain", ChainData("Custom Chain", 123456789, "https://custom.chain/")); + Chain memory customChain = getChain("custom_chain"); + assertEq(customChain.name, "Custom Chain"); + assertEq(customChain.chainId, 123456789); + assertEq(customChain.chainAlias, "custom_chain"); + assertEq(customChain.rpcUrl, "https://custom.chain/"); + Chain memory chainById = getChain(123456789); + assertEq(chainById.name, customChain.name); + assertEq(chainById.chainId, customChain.chainId); + assertEq(chainById.chainAlias, customChain.chainAlias); + assertEq(chainById.rpcUrl, customChain.rpcUrl); + customChain.name = "Another Custom Chain"; + customChain.chainId = 987654321; + setChain("another_custom_chain", customChain); + Chain memory anotherCustomChain = getChain("another_custom_chain"); + assertEq(anotherCustomChain.name, "Another Custom Chain"); + assertEq(anotherCustomChain.chainId, 987654321); + assertEq(anotherCustomChain.chainAlias, "another_custom_chain"); + assertEq(anotherCustomChain.rpcUrl, "https://custom.chain/"); + // Verify the first chain data was not overwritten + chainById = getChain(123456789); + assertEq(chainById.name, "Custom Chain"); + assertEq(chainById.chainId, 123456789); + } + + function test_SetNoEmptyAlias() public { + // We deploy a mock to properly test the revert. + StdChainsMock stdChainsMock = new StdChainsMock(); + + vm.expectRevert("StdChains setChain(string,ChainData): Chain alias cannot be the empty string."); + stdChainsMock.exposed_setChain("", ChainData("", 123456789, "")); + } + + function test_SetNoChainId0() public { + // We deploy a mock to properly test the revert. + StdChainsMock stdChainsMock = new StdChainsMock(); + + vm.expectRevert("StdChains setChain(string,ChainData): Chain ID cannot be 0."); + stdChainsMock.exposed_setChain("alias", ChainData("", 0, "")); + } + + function test_GetNoChainId0() public { + // We deploy a mock to properly test the revert. + StdChainsMock stdChainsMock = new StdChainsMock(); + + vm.expectRevert("StdChains getChain(uint256): Chain ID cannot be 0."); + stdChainsMock.exposed_getChain(0); + } + + function test_GetNoEmptyAlias() public { + // We deploy a mock to properly test the revert. + StdChainsMock stdChainsMock = new StdChainsMock(); + + vm.expectRevert("StdChains getChain(string): Chain alias cannot be the empty string."); + stdChainsMock.exposed_getChain(""); + } + + function test_ChainIdNotFound() public { + // We deploy a mock to properly test the revert. + StdChainsMock stdChainsMock = new StdChainsMock(); + + vm.expectRevert("StdChains getChain(string): Chain with alias \"no_such_alias\" not found."); + stdChainsMock.exposed_getChain("no_such_alias"); + } + + function test_ChainAliasNotFound() public { + // We deploy a mock to properly test the revert. + StdChainsMock stdChainsMock = new StdChainsMock(); + + vm.expectRevert("StdChains getChain(uint256): Chain with ID 321 not found."); + + stdChainsMock.exposed_getChain(321); + } + + function test_SetChain_ExistingOne() public { + // We deploy a mock to properly test the revert. + StdChainsMock stdChainsMock = new StdChainsMock(); + + setChain("custom_chain", ChainData("Custom Chain", 123456789, "https://custom.chain/")); + assertEq(getChain(123456789).chainId, 123456789); + + setChain("custom_chain", ChainData("Modified Chain", 999999999, "https://modified.chain/")); + vm.expectRevert("StdChains getChain(uint256): Chain with ID 123456789 not found."); + stdChainsMock.exposed_getChain(123456789); + + Chain memory modifiedChain = getChain(999999999); + assertEq(modifiedChain.name, "Modified Chain"); + assertEq(modifiedChain.chainId, 999999999); + assertEq(modifiedChain.rpcUrl, "https://modified.chain/"); + } + + function test_DontUseDefaultRpcUrl() public { + // We deploy a mock to properly test the revert. + StdChainsMock stdChainsMock = new StdChainsMock(); + + // Should error if default RPCs flag is set to false. + stdChainsMock.exposed_setFallbackToDefaultRpcUrls(false); + vm.expectRevert(); + stdChainsMock.exposed_getChain(31337); + vm.expectRevert(); + stdChainsMock.exposed_getChain("sepolia"); + } +} diff --git a/docs/crypto/zkCTF/day1/Ethereal/mint-contracts/lib/forge-std/test/StdCheats.t.sol b/docs/crypto/zkCTF/day1/Ethereal/mint-contracts/lib/forge-std/test/StdCheats.t.sol new file mode 100644 index 0000000..e94923c --- /dev/null +++ b/docs/crypto/zkCTF/day1/Ethereal/mint-contracts/lib/forge-std/test/StdCheats.t.sol @@ -0,0 +1,610 @@ +// SPDX-License-Identifier: MIT +pragma solidity >=0.7.0 <0.9.0; + +import "../src/StdCheats.sol"; +import "../src/Test.sol"; +import "../src/StdJson.sol"; + +contract StdCheatsTest is Test { + Bar test; + + using stdJson for string; + + function setUp() public { + test = new Bar(); + } + + function test_Skip() public { + vm.warp(100); + skip(25); + assertEq(block.timestamp, 125); + } + + function test_Rewind() public { + vm.warp(100); + rewind(25); + assertEq(block.timestamp, 75); + } + + function test_Hoax() public { + hoax(address(1337)); + test.bar{value: 100}(address(1337)); + } + + function test_HoaxOrigin() public { + hoax(address(1337), address(1337)); + test.origin{value: 100}(address(1337)); + } + + function test_HoaxDifferentAddresses() public { + hoax(address(1337), address(7331)); + test.origin{value: 100}(address(1337), address(7331)); + } + + function test_StartHoax() public { + startHoax(address(1337)); + test.bar{value: 100}(address(1337)); + test.bar{value: 100}(address(1337)); + vm.stopPrank(); + test.bar(address(this)); + } + + function test_StartHoaxOrigin() public { + startHoax(address(1337), address(1337)); + test.origin{value: 100}(address(1337)); + test.origin{value: 100}(address(1337)); + vm.stopPrank(); + test.bar(address(this)); + } + + function test_ChangePrankMsgSender() public { + vm.startPrank(address(1337)); + test.bar(address(1337)); + changePrank(address(0xdead)); + test.bar(address(0xdead)); + changePrank(address(1337)); + test.bar(address(1337)); + vm.stopPrank(); + } + + function test_ChangePrankMsgSenderAndTxOrigin() public { + vm.startPrank(address(1337), address(1338)); + test.origin(address(1337), address(1338)); + changePrank(address(0xdead), address(0xbeef)); + test.origin(address(0xdead), address(0xbeef)); + changePrank(address(1337), address(1338)); + test.origin(address(1337), address(1338)); + vm.stopPrank(); + } + + function test_MakeAccountEquivalence() public { + Account memory account = makeAccount("1337"); + (address addr, uint256 key) = makeAddrAndKey("1337"); + assertEq(account.addr, addr); + assertEq(account.key, key); + } + + function test_MakeAddrEquivalence() public { + (address addr,) = makeAddrAndKey("1337"); + assertEq(makeAddr("1337"), addr); + } + + function test_MakeAddrSigning() public { + (address addr, uint256 key) = makeAddrAndKey("1337"); + bytes32 hash = keccak256("some_message"); + + (uint8 v, bytes32 r, bytes32 s) = vm.sign(key, hash); + assertEq(ecrecover(hash, v, r, s), addr); + } + + function test_Deal() public { + deal(address(this), 1 ether); + assertEq(address(this).balance, 1 ether); + } + + function test_DealToken() public { + Bar barToken = new Bar(); + address bar = address(barToken); + deal(bar, address(this), 10000e18); + assertEq(barToken.balanceOf(address(this)), 10000e18); + } + + function test_DealTokenAdjustTotalSupply() public { + Bar barToken = new Bar(); + address bar = address(barToken); + deal(bar, address(this), 10000e18, true); + assertEq(barToken.balanceOf(address(this)), 10000e18); + assertEq(barToken.totalSupply(), 20000e18); + deal(bar, address(this), 0, true); + assertEq(barToken.balanceOf(address(this)), 0); + assertEq(barToken.totalSupply(), 10000e18); + } + + function test_DealERC1155Token() public { + BarERC1155 barToken = new BarERC1155(); + address bar = address(barToken); + dealERC1155(bar, address(this), 0, 10000e18, false); + assertEq(barToken.balanceOf(address(this), 0), 10000e18); + } + + function test_DealERC1155TokenAdjustTotalSupply() public { + BarERC1155 barToken = new BarERC1155(); + address bar = address(barToken); + dealERC1155(bar, address(this), 0, 10000e18, true); + assertEq(barToken.balanceOf(address(this), 0), 10000e18); + assertEq(barToken.totalSupply(0), 20000e18); + dealERC1155(bar, address(this), 0, 0, true); + assertEq(barToken.balanceOf(address(this), 0), 0); + assertEq(barToken.totalSupply(0), 10000e18); + } + + function test_DealERC721Token() public { + BarERC721 barToken = new BarERC721(); + address bar = address(barToken); + dealERC721(bar, address(2), 1); + assertEq(barToken.balanceOf(address(2)), 1); + assertEq(barToken.balanceOf(address(1)), 0); + dealERC721(bar, address(1), 2); + assertEq(barToken.balanceOf(address(1)), 1); + assertEq(barToken.balanceOf(bar), 1); + } + + function test_DeployCode() public { + address deployed = deployCode("StdCheats.t.sol:Bar", bytes("")); + assertEq(string(getCode(deployed)), string(getCode(address(test)))); + } + + function test_DestroyAccount() public { + // deploy something to destroy it + BarERC721 barToken = new BarERC721(); + address bar = address(barToken); + vm.setNonce(bar, 10); + deal(bar, 100); + + uint256 prevThisBalance = address(this).balance; + uint256 size; + assembly { + size := extcodesize(bar) + } + + assertGt(size, 0); + assertEq(bar.balance, 100); + assertEq(vm.getNonce(bar), 10); + + destroyAccount(bar, address(this)); + assembly { + size := extcodesize(bar) + } + assertEq(address(this).balance, prevThisBalance + 100); + assertEq(vm.getNonce(bar), 0); + assertEq(size, 0); + assertEq(bar.balance, 0); + } + + function test_DeployCodeNoArgs() public { + address deployed = deployCode("StdCheats.t.sol:Bar"); + assertEq(string(getCode(deployed)), string(getCode(address(test)))); + } + + function test_DeployCodeVal() public { + address deployed = deployCode("StdCheats.t.sol:Bar", bytes(""), 1 ether); + assertEq(string(getCode(deployed)), string(getCode(address(test)))); + assertEq(deployed.balance, 1 ether); + } + + function test_DeployCodeValNoArgs() public { + address deployed = deployCode("StdCheats.t.sol:Bar", 1 ether); + assertEq(string(getCode(deployed)), string(getCode(address(test)))); + assertEq(deployed.balance, 1 ether); + } + + // We need this so we can call "this.deployCode" rather than "deployCode" directly + function deployCodeHelper(string memory what) external { + deployCode(what); + } + + function test_DeployCodeFail() public { + vm.expectRevert(bytes("StdCheats deployCode(string): Deployment failed.")); + this.deployCodeHelper("StdCheats.t.sol:RevertingContract"); + } + + function getCode(address who) internal view returns (bytes memory o_code) { + /// @solidity memory-safe-assembly + assembly { + // retrieve the size of the code, this needs assembly + let size := extcodesize(who) + // allocate output byte array - this could also be done without assembly + // by using o_code = new bytes(size) + o_code := mload(0x40) + // new "memory end" including padding + mstore(0x40, add(o_code, and(add(add(size, 0x20), 0x1f), not(0x1f)))) + // store length in memory + mstore(o_code, size) + // actually retrieve the code, this needs assembly + extcodecopy(who, add(o_code, 0x20), 0, size) + } + } + + function test_DeriveRememberKey() public { + string memory mnemonic = "test test test test test test test test test test test junk"; + + (address deployer, uint256 privateKey) = deriveRememberKey(mnemonic, 0); + assertEq(deployer, 0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266); + assertEq(privateKey, 0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80); + } + + function test_BytesToUint() public { + assertEq(3, bytesToUint_test(hex"03")); + assertEq(2, bytesToUint_test(hex"02")); + assertEq(255, bytesToUint_test(hex"ff")); + assertEq(29625, bytesToUint_test(hex"73b9")); + } + + function test_ParseJsonTxDetail() public { + string memory root = vm.projectRoot(); + string memory path = string.concat(root, "/test/fixtures/broadcast.log.json"); + string memory json = vm.readFile(path); + bytes memory transactionDetails = json.parseRaw(".transactions[0].tx"); + RawTx1559Detail memory rawTxDetail = abi.decode(transactionDetails, (RawTx1559Detail)); + Tx1559Detail memory txDetail = rawToConvertedEIP1559Detail(rawTxDetail); + assertEq(txDetail.from, 0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266); + assertEq(txDetail.to, 0xe7f1725E7734CE288F8367e1Bb143E90bb3F0512); + assertEq( + txDetail.data, + hex"23e99187000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000013370000000000000000000000000000000000000000000000000000000000000060000000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000030000000000000000000000000000000000000000000000000000000000000004" + ); + assertEq(txDetail.nonce, 3); + assertEq(txDetail.txType, 2); + assertEq(txDetail.gas, 29625); + assertEq(txDetail.value, 0); + } + + function test_ReadEIP1559Transaction() public view { + string memory root = vm.projectRoot(); + string memory path = string.concat(root, "/test/fixtures/broadcast.log.json"); + uint256 index = 0; + Tx1559 memory transaction = readTx1559(path, index); + transaction; + } + + function test_ReadEIP1559Transactions() public view { + string memory root = vm.projectRoot(); + string memory path = string.concat(root, "/test/fixtures/broadcast.log.json"); + Tx1559[] memory transactions = readTx1559s(path); + transactions; + } + + function test_ReadReceipt() public { + string memory root = vm.projectRoot(); + string memory path = string.concat(root, "/test/fixtures/broadcast.log.json"); + uint256 index = 5; + Receipt memory receipt = readReceipt(path, index); + assertEq( + receipt.logsBloom, + hex"00000000000800000000000000000010000000000000000000000000000180000000000000000000000000000000000000000000000008000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000100" + ); + } + + function test_ReadReceipts() public view { + string memory root = vm.projectRoot(); + string memory path = string.concat(root, "/test/fixtures/broadcast.log.json"); + Receipt[] memory receipts = readReceipts(path); + receipts; + } + + function test_GasMeteringModifier() public { + uint256 gas_start_normal = gasleft(); + addInLoop(); + uint256 gas_used_normal = gas_start_normal - gasleft(); + + uint256 gas_start_single = gasleft(); + addInLoopNoGas(); + uint256 gas_used_single = gas_start_single - gasleft(); + + uint256 gas_start_double = gasleft(); + addInLoopNoGasNoGas(); + uint256 gas_used_double = gas_start_double - gasleft(); + + emit log_named_uint("Normal gas", gas_used_normal); + emit log_named_uint("Single modifier gas", gas_used_single); + emit log_named_uint("Double modifier gas", gas_used_double); + assertTrue(gas_used_double + gas_used_single < gas_used_normal); + } + + function addInLoop() internal pure returns (uint256) { + uint256 b; + for (uint256 i; i < 10000; i++) { + b += i; + } + return b; + } + + function addInLoopNoGas() internal noGasMetering returns (uint256) { + return addInLoop(); + } + + function addInLoopNoGasNoGas() internal noGasMetering returns (uint256) { + return addInLoopNoGas(); + } + + function bytesToUint_test(bytes memory b) private pure returns (uint256) { + uint256 number; + for (uint256 i = 0; i < b.length; i++) { + number = number + uint256(uint8(b[i])) * (2 ** (8 * (b.length - (i + 1)))); + } + return number; + } + + function testFuzz_AssumeAddressIsNot(address addr) external { + // skip over Payable and NonPayable enums + for (uint8 i = 2; i < uint8(type(AddressType).max); i++) { + assumeAddressIsNot(addr, AddressType(i)); + } + assertTrue(addr != address(0)); + assertTrue(addr < address(1) || addr > address(9)); + assertTrue(addr != address(vm) || addr != 0x000000000000000000636F6e736F6c652e6c6f67); + } + + function test_AssumePayable() external { + // We deploy a mock version so we can properly test the revert. + StdCheatsMock stdCheatsMock = new StdCheatsMock(); + + // all should revert since these addresses are not payable + + // VM address + vm.expectRevert(); + stdCheatsMock.exposed_assumePayable(0x7109709ECfa91a80626fF3989D68f67F5b1DD12D); + + // Console address + vm.expectRevert(); + stdCheatsMock.exposed_assumePayable(0x000000000000000000636F6e736F6c652e6c6f67); + + // Create2Deployer + vm.expectRevert(); + stdCheatsMock.exposed_assumePayable(0x4e59b44847b379578588920cA78FbF26c0B4956C); + + // all should pass since these addresses are payable + + // vitalik.eth + stdCheatsMock.exposed_assumePayable(0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045); + + // mock payable contract + MockContractPayable cp = new MockContractPayable(); + stdCheatsMock.exposed_assumePayable(address(cp)); + } + + function test_AssumeNotPayable() external { + // We deploy a mock version so we can properly test the revert. + StdCheatsMock stdCheatsMock = new StdCheatsMock(); + + // all should pass since these addresses are not payable + + // VM address + stdCheatsMock.exposed_assumeNotPayable(0x7109709ECfa91a80626fF3989D68f67F5b1DD12D); + + // Console address + stdCheatsMock.exposed_assumeNotPayable(0x000000000000000000636F6e736F6c652e6c6f67); + + // Create2Deployer + stdCheatsMock.exposed_assumeNotPayable(0x4e59b44847b379578588920cA78FbF26c0B4956C); + + // all should revert since these addresses are payable + + // vitalik.eth + vm.expectRevert(); + stdCheatsMock.exposed_assumeNotPayable(0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045); + + // mock payable contract + MockContractPayable cp = new MockContractPayable(); + vm.expectRevert(); + stdCheatsMock.exposed_assumeNotPayable(address(cp)); + } + + function testFuzz_AssumeNotPrecompile(address addr) external { + assumeNotPrecompile(addr, getChain("optimism_goerli").chainId); + assertTrue( + addr < address(1) || (addr > address(9) && addr < address(0x4200000000000000000000000000000000000000)) + || addr > address(0x4200000000000000000000000000000000000800) + ); + } + + function testFuzz_AssumeNotForgeAddress(address addr) external { + assumeNotForgeAddress(addr); + assertTrue( + addr != address(vm) && addr != 0x000000000000000000636F6e736F6c652e6c6f67 + && addr != 0x4e59b44847b379578588920cA78FbF26c0B4956C + ); + } + + function test_CannotDeployCodeTo() external { + vm.expectRevert("StdCheats deployCodeTo(string,bytes,uint256,address): Failed to create runtime bytecode."); + this._revertDeployCodeTo(); + } + + function _revertDeployCodeTo() external { + deployCodeTo("StdCheats.t.sol:RevertingContract", address(0)); + } + + function test_DeployCodeTo() external { + address arbitraryAddress = makeAddr("arbitraryAddress"); + + deployCodeTo( + "StdCheats.t.sol:MockContractWithConstructorArgs", + abi.encode(uint256(6), true, bytes20(arbitraryAddress)), + 1 ether, + arbitraryAddress + ); + + MockContractWithConstructorArgs ct = MockContractWithConstructorArgs(arbitraryAddress); + + assertEq(arbitraryAddress.balance, 1 ether); + assertEq(ct.x(), 6); + assertTrue(ct.y()); + assertEq(ct.z(), bytes20(arbitraryAddress)); + } +} + +contract StdCheatsMock is StdCheats { + function exposed_assumePayable(address addr) external { + assumePayable(addr); + } + + function exposed_assumeNotPayable(address addr) external { + assumeNotPayable(addr); + } + + // We deploy a mock version so we can properly test expected reverts. + function exposed_assumeNotBlacklisted(address token, address addr) external view { + return assumeNotBlacklisted(token, addr); + } +} + +contract StdCheatsForkTest is Test { + address internal constant SHIB = 0x95aD61b0a150d79219dCF64E1E6Cc01f0B64C4cE; + address internal constant USDC = 0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48; + address internal constant USDC_BLACKLISTED_USER = 0x1E34A77868E19A6647b1f2F47B51ed72dEDE95DD; + address internal constant USDT = 0xdAC17F958D2ee523a2206206994597C13D831ec7; + address internal constant USDT_BLACKLISTED_USER = 0x8f8a8F4B54a2aAC7799d7bc81368aC27b852822A; + + function setUp() public { + // All tests of the `assumeNotBlacklisted` method are fork tests using live contracts. + vm.createSelectFork({urlOrAlias: "mainnet", blockNumber: 16_428_900}); + } + + function test_CannotAssumeNoBlacklisted_EOA() external { + // We deploy a mock version so we can properly test the revert. + StdCheatsMock stdCheatsMock = new StdCheatsMock(); + address eoa = vm.addr({privateKey: 1}); + vm.expectRevert("StdCheats assumeNotBlacklisted(address,address): Token address is not a contract."); + stdCheatsMock.exposed_assumeNotBlacklisted(eoa, address(0)); + } + + function testFuzz_AssumeNotBlacklisted_TokenWithoutBlacklist(address addr) external { + assumeNotBlacklisted(SHIB, addr); + assertTrue(true); + } + + function test_AssumeNoBlacklisted_USDC() external { + // We deploy a mock version so we can properly test the revert. + StdCheatsMock stdCheatsMock = new StdCheatsMock(); + vm.expectRevert(); + stdCheatsMock.exposed_assumeNotBlacklisted(USDC, USDC_BLACKLISTED_USER); + } + + function testFuzz_AssumeNotBlacklisted_USDC(address addr) external { + assumeNotBlacklisted(USDC, addr); + assertFalse(USDCLike(USDC).isBlacklisted(addr)); + } + + function test_AssumeNoBlacklisted_USDT() external { + // We deploy a mock version so we can properly test the revert. + StdCheatsMock stdCheatsMock = new StdCheatsMock(); + vm.expectRevert(); + stdCheatsMock.exposed_assumeNotBlacklisted(USDT, USDT_BLACKLISTED_USER); + } + + function testFuzz_AssumeNotBlacklisted_USDT(address addr) external { + assumeNotBlacklisted(USDT, addr); + assertFalse(USDTLike(USDT).isBlackListed(addr)); + } +} + +contract Bar { + constructor() payable { + /// `DEAL` STDCHEAT + totalSupply = 10000e18; + balanceOf[address(this)] = totalSupply; + } + + /// `HOAX` and `CHANGEPRANK` STDCHEATS + function bar(address expectedSender) public payable { + require(msg.sender == expectedSender, "!prank"); + } + + function origin(address expectedSender) public payable { + require(msg.sender == expectedSender, "!prank"); + require(tx.origin == expectedSender, "!prank"); + } + + function origin(address expectedSender, address expectedOrigin) public payable { + require(msg.sender == expectedSender, "!prank"); + require(tx.origin == expectedOrigin, "!prank"); + } + + /// `DEAL` STDCHEAT + mapping(address => uint256) public balanceOf; + uint256 public totalSupply; +} + +contract BarERC1155 { + constructor() payable { + /// `DEALERC1155` STDCHEAT + _totalSupply[0] = 10000e18; + _balances[0][address(this)] = _totalSupply[0]; + } + + function balanceOf(address account, uint256 id) public view virtual returns (uint256) { + return _balances[id][account]; + } + + function totalSupply(uint256 id) public view virtual returns (uint256) { + return _totalSupply[id]; + } + + /// `DEALERC1155` STDCHEAT + mapping(uint256 => mapping(address => uint256)) private _balances; + mapping(uint256 => uint256) private _totalSupply; +} + +contract BarERC721 { + constructor() payable { + /// `DEALERC721` STDCHEAT + _owners[1] = address(1); + _balances[address(1)] = 1; + _owners[2] = address(this); + _owners[3] = address(this); + _balances[address(this)] = 2; + } + + function balanceOf(address owner) public view virtual returns (uint256) { + return _balances[owner]; + } + + function ownerOf(uint256 tokenId) public view virtual returns (address) { + address owner = _owners[tokenId]; + return owner; + } + + mapping(uint256 => address) private _owners; + mapping(address => uint256) private _balances; +} + +interface USDCLike { + function isBlacklisted(address) external view returns (bool); +} + +interface USDTLike { + function isBlackListed(address) external view returns (bool); +} + +contract RevertingContract { + constructor() { + revert(); + } +} + +contract MockContractWithConstructorArgs { + uint256 public immutable x; + bool public y; + bytes20 public z; + + constructor(uint256 _x, bool _y, bytes20 _z) payable { + x = _x; + y = _y; + z = _z; + } +} + +contract MockContractPayable { + receive() external payable {} +} diff --git a/docs/crypto/zkCTF/day1/Ethereal/mint-contracts/lib/forge-std/test/StdError.t.sol b/docs/crypto/zkCTF/day1/Ethereal/mint-contracts/lib/forge-std/test/StdError.t.sol new file mode 100644 index 0000000..a306eaa --- /dev/null +++ b/docs/crypto/zkCTF/day1/Ethereal/mint-contracts/lib/forge-std/test/StdError.t.sol @@ -0,0 +1,120 @@ +// SPDX-License-Identifier: MIT +pragma solidity >=0.8.0 <0.9.0; + +import "../src/StdError.sol"; +import "../src/Test.sol"; + +contract StdErrorsTest is Test { + ErrorsTest test; + + function setUp() public { + test = new ErrorsTest(); + } + + function test_ExpectAssertion() public { + vm.expectRevert(stdError.assertionError); + test.assertionError(); + } + + function test_ExpectArithmetic() public { + vm.expectRevert(stdError.arithmeticError); + test.arithmeticError(10); + } + + function test_ExpectDiv() public { + vm.expectRevert(stdError.divisionError); + test.divError(0); + } + + function test_ExpectMod() public { + vm.expectRevert(stdError.divisionError); + test.modError(0); + } + + function test_ExpectEnum() public { + vm.expectRevert(stdError.enumConversionError); + test.enumConversion(1); + } + + function test_ExpectEncodeStg() public { + vm.expectRevert(stdError.encodeStorageError); + test.encodeStgError(); + } + + function test_ExpectPop() public { + vm.expectRevert(stdError.popError); + test.pop(); + } + + function test_ExpectOOB() public { + vm.expectRevert(stdError.indexOOBError); + test.indexOOBError(1); + } + + function test_ExpectMem() public { + vm.expectRevert(stdError.memOverflowError); + test.mem(); + } + + function test_ExpectIntern() public { + vm.expectRevert(stdError.zeroVarError); + test.intern(); + } +} + +contract ErrorsTest { + enum T { + T1 + } + + uint256[] public someArr; + bytes someBytes; + + function assertionError() public pure { + assert(false); + } + + function arithmeticError(uint256 a) public pure { + a -= 100; + } + + function divError(uint256 a) public pure { + 100 / a; + } + + function modError(uint256 a) public pure { + 100 % a; + } + + function enumConversion(uint256 a) public pure { + T(a); + } + + function encodeStgError() public { + /// @solidity memory-safe-assembly + assembly { + sstore(someBytes.slot, 1) + } + keccak256(someBytes); + } + + function pop() public { + someArr.pop(); + } + + function indexOOBError(uint256 a) public pure { + uint256[] memory t = new uint256[](0); + t[a]; + } + + function mem() public pure { + uint256 l = 2 ** 256 / 32; + new uint256[](l); + } + + function intern() public returns (uint256) { + function(uint256) internal returns (uint256) x; + x(2); + return 7; + } +} diff --git a/docs/crypto/zkCTF/day1/Ethereal/mint-contracts/lib/forge-std/test/StdMath.t.sol b/docs/crypto/zkCTF/day1/Ethereal/mint-contracts/lib/forge-std/test/StdMath.t.sol new file mode 100644 index 0000000..6f50638 --- /dev/null +++ b/docs/crypto/zkCTF/day1/Ethereal/mint-contracts/lib/forge-std/test/StdMath.t.sol @@ -0,0 +1,212 @@ +// SPDX-License-Identifier: MIT +pragma solidity >=0.8.0 <0.9.0; + +import "../src/StdMath.sol"; +import "../src/Test.sol"; + +contract StdMathMock is Test { + function exposed_percentDelta(uint256 a, uint256 b) public pure returns (uint256) { + return stdMath.percentDelta(a, b); + } + + function exposed_percentDelta(int256 a, int256 b) public pure returns (uint256) { + return stdMath.percentDelta(a, b); + } +} + +contract StdMathTest is Test { + function test_GetAbs() external { + assertEq(stdMath.abs(-50), 50); + assertEq(stdMath.abs(50), 50); + assertEq(stdMath.abs(-1337), 1337); + assertEq(stdMath.abs(0), 0); + + assertEq(stdMath.abs(type(int256).min), (type(uint256).max >> 1) + 1); + assertEq(stdMath.abs(type(int256).max), (type(uint256).max >> 1)); + } + + function testFuzz_GetAbs(int256 a) external { + uint256 manualAbs = getAbs(a); + + uint256 abs = stdMath.abs(a); + + assertEq(abs, manualAbs); + } + + function test_GetDelta_Uint() external { + assertEq(stdMath.delta(uint256(0), uint256(0)), 0); + assertEq(stdMath.delta(uint256(0), uint256(1337)), 1337); + assertEq(stdMath.delta(uint256(0), type(uint64).max), type(uint64).max); + assertEq(stdMath.delta(uint256(0), type(uint128).max), type(uint128).max); + assertEq(stdMath.delta(uint256(0), type(uint256).max), type(uint256).max); + + assertEq(stdMath.delta(0, uint256(0)), 0); + assertEq(stdMath.delta(1337, uint256(0)), 1337); + assertEq(stdMath.delta(type(uint64).max, uint256(0)), type(uint64).max); + assertEq(stdMath.delta(type(uint128).max, uint256(0)), type(uint128).max); + assertEq(stdMath.delta(type(uint256).max, uint256(0)), type(uint256).max); + + assertEq(stdMath.delta(1337, uint256(1337)), 0); + assertEq(stdMath.delta(type(uint256).max, type(uint256).max), 0); + assertEq(stdMath.delta(5000, uint256(1250)), 3750); + } + + function testFuzz_GetDelta_Uint(uint256 a, uint256 b) external { + uint256 manualDelta; + if (a > b) { + manualDelta = a - b; + } else { + manualDelta = b - a; + } + + uint256 delta = stdMath.delta(a, b); + + assertEq(delta, manualDelta); + } + + function test_GetDelta_Int() external { + assertEq(stdMath.delta(int256(0), int256(0)), 0); + assertEq(stdMath.delta(int256(0), int256(1337)), 1337); + assertEq(stdMath.delta(int256(0), type(int64).max), type(uint64).max >> 1); + assertEq(stdMath.delta(int256(0), type(int128).max), type(uint128).max >> 1); + assertEq(stdMath.delta(int256(0), type(int256).max), type(uint256).max >> 1); + + assertEq(stdMath.delta(0, int256(0)), 0); + assertEq(stdMath.delta(1337, int256(0)), 1337); + assertEq(stdMath.delta(type(int64).max, int256(0)), type(uint64).max >> 1); + assertEq(stdMath.delta(type(int128).max, int256(0)), type(uint128).max >> 1); + assertEq(stdMath.delta(type(int256).max, int256(0)), type(uint256).max >> 1); + + assertEq(stdMath.delta(-0, int256(0)), 0); + assertEq(stdMath.delta(-1337, int256(0)), 1337); + assertEq(stdMath.delta(type(int64).min, int256(0)), (type(uint64).max >> 1) + 1); + assertEq(stdMath.delta(type(int128).min, int256(0)), (type(uint128).max >> 1) + 1); + assertEq(stdMath.delta(type(int256).min, int256(0)), (type(uint256).max >> 1) + 1); + + assertEq(stdMath.delta(int256(0), -0), 0); + assertEq(stdMath.delta(int256(0), -1337), 1337); + assertEq(stdMath.delta(int256(0), type(int64).min), (type(uint64).max >> 1) + 1); + assertEq(stdMath.delta(int256(0), type(int128).min), (type(uint128).max >> 1) + 1); + assertEq(stdMath.delta(int256(0), type(int256).min), (type(uint256).max >> 1) + 1); + + assertEq(stdMath.delta(1337, int256(1337)), 0); + assertEq(stdMath.delta(type(int256).max, type(int256).max), 0); + assertEq(stdMath.delta(type(int256).min, type(int256).min), 0); + assertEq(stdMath.delta(type(int256).min, type(int256).max), type(uint256).max); + assertEq(stdMath.delta(5000, int256(1250)), 3750); + } + + function testFuzz_GetDelta_Int(int256 a, int256 b) external { + uint256 absA = getAbs(a); + uint256 absB = getAbs(b); + uint256 absDelta = absA > absB ? absA - absB : absB - absA; + + uint256 manualDelta; + if ((a >= 0 && b >= 0) || (a < 0 && b < 0)) { + manualDelta = absDelta; + } + // (a < 0 && b >= 0) || (a >= 0 && b < 0) + else { + manualDelta = absA + absB; + } + + uint256 delta = stdMath.delta(a, b); + + assertEq(delta, manualDelta); + } + + function test_GetPercentDelta_Uint() external { + StdMathMock stdMathMock = new StdMathMock(); + + assertEq(stdMath.percentDelta(uint256(0), uint256(1337)), 1e18); + assertEq(stdMath.percentDelta(uint256(0), type(uint64).max), 1e18); + assertEq(stdMath.percentDelta(uint256(0), type(uint128).max), 1e18); + assertEq(stdMath.percentDelta(uint256(0), type(uint192).max), 1e18); + + assertEq(stdMath.percentDelta(1337, uint256(1337)), 0); + assertEq(stdMath.percentDelta(type(uint192).max, type(uint192).max), 0); + assertEq(stdMath.percentDelta(0, uint256(2500)), 1e18); + assertEq(stdMath.percentDelta(2500, uint256(2500)), 0); + assertEq(stdMath.percentDelta(5000, uint256(2500)), 1e18); + assertEq(stdMath.percentDelta(7500, uint256(2500)), 2e18); + + vm.expectRevert(stdError.divisionError); + stdMathMock.exposed_percentDelta(uint256(1), 0); + } + + function testFuzz_GetPercentDelta_Uint(uint192 a, uint192 b) external { + vm.assume(b != 0); + uint256 manualDelta; + if (a > b) { + manualDelta = a - b; + } else { + manualDelta = b - a; + } + + uint256 manualPercentDelta = manualDelta * 1e18 / b; + uint256 percentDelta = stdMath.percentDelta(a, b); + + assertEq(percentDelta, manualPercentDelta); + } + + function test_GetPercentDelta_Int() external { + // We deploy a mock version so we can properly test the revert. + StdMathMock stdMathMock = new StdMathMock(); + + assertEq(stdMath.percentDelta(int256(0), int256(1337)), 1e18); + assertEq(stdMath.percentDelta(int256(0), -1337), 1e18); + assertEq(stdMath.percentDelta(int256(0), type(int64).min), 1e18); + assertEq(stdMath.percentDelta(int256(0), type(int128).min), 1e18); + assertEq(stdMath.percentDelta(int256(0), type(int192).min), 1e18); + assertEq(stdMath.percentDelta(int256(0), type(int64).max), 1e18); + assertEq(stdMath.percentDelta(int256(0), type(int128).max), 1e18); + assertEq(stdMath.percentDelta(int256(0), type(int192).max), 1e18); + + assertEq(stdMath.percentDelta(1337, int256(1337)), 0); + assertEq(stdMath.percentDelta(type(int192).max, type(int192).max), 0); + assertEq(stdMath.percentDelta(type(int192).min, type(int192).min), 0); + + assertEq(stdMath.percentDelta(type(int192).min, type(int192).max), 2e18); // rounds the 1 wei diff down + assertEq(stdMath.percentDelta(type(int192).max, type(int192).min), 2e18 - 1); // rounds the 1 wei diff down + assertEq(stdMath.percentDelta(0, int256(2500)), 1e18); + assertEq(stdMath.percentDelta(2500, int256(2500)), 0); + assertEq(stdMath.percentDelta(5000, int256(2500)), 1e18); + assertEq(stdMath.percentDelta(7500, int256(2500)), 2e18); + + vm.expectRevert(stdError.divisionError); + stdMathMock.exposed_percentDelta(int256(1), 0); + } + + function testFuzz_GetPercentDelta_Int(int192 a, int192 b) external { + vm.assume(b != 0); + uint256 absA = getAbs(a); + uint256 absB = getAbs(b); + uint256 absDelta = absA > absB ? absA - absB : absB - absA; + + uint256 manualDelta; + if ((a >= 0 && b >= 0) || (a < 0 && b < 0)) { + manualDelta = absDelta; + } + // (a < 0 && b >= 0) || (a >= 0 && b < 0) + else { + manualDelta = absA + absB; + } + + uint256 manualPercentDelta = manualDelta * 1e18 / absB; + uint256 percentDelta = stdMath.percentDelta(a, b); + + assertEq(percentDelta, manualPercentDelta); + } + + /*////////////////////////////////////////////////////////////////////////// + HELPERS + //////////////////////////////////////////////////////////////////////////*/ + + function getAbs(int256 a) private pure returns (uint256) { + if (a < 0) { + return a == type(int256).min ? uint256(type(int256).max) + 1 : uint256(-a); + } + + return uint256(a); + } +} diff --git a/docs/crypto/zkCTF/day1/Ethereal/mint-contracts/lib/forge-std/test/StdStorage.t.sol b/docs/crypto/zkCTF/day1/Ethereal/mint-contracts/lib/forge-std/test/StdStorage.t.sol new file mode 100644 index 0000000..0b3ca9b --- /dev/null +++ b/docs/crypto/zkCTF/day1/Ethereal/mint-contracts/lib/forge-std/test/StdStorage.t.sol @@ -0,0 +1,315 @@ +// SPDX-License-Identifier: MIT +pragma solidity >=0.7.0 <0.9.0; + +import "../src/StdStorage.sol"; +import "../src/Test.sol"; + +contract StdStorageTest is Test { + using stdStorage for StdStorage; + + StorageTest internal test; + + function setUp() public { + test = new StorageTest(); + } + + function test_StorageHidden() public { + assertEq(uint256(keccak256("my.random.var")), stdstore.target(address(test)).sig("hidden()").find()); + } + + function test_StorageObvious() public { + assertEq(uint256(0), stdstore.target(address(test)).sig("exists()").find()); + } + + function test_StorageExtraSload() public { + assertEq(16, stdstore.target(address(test)).sig(test.extra_sload.selector).find()); + } + + function test_StorageCheckedWriteHidden() public { + stdstore.target(address(test)).sig(test.hidden.selector).checked_write(100); + assertEq(uint256(test.hidden()), 100); + } + + function test_StorageCheckedWriteObvious() public { + stdstore.target(address(test)).sig(test.exists.selector).checked_write(100); + assertEq(test.exists(), 100); + } + + function test_StorageCheckedWriteSignedIntegerHidden() public { + stdstore.target(address(test)).sig(test.hidden.selector).checked_write_int(-100); + assertEq(int256(uint256(test.hidden())), -100); + } + + function test_StorageCheckedWriteSignedIntegerObvious() public { + stdstore.target(address(test)).sig(test.tG.selector).checked_write_int(-100); + assertEq(test.tG(), -100); + } + + function test_StorageMapStructA() public { + uint256 slot = + stdstore.target(address(test)).sig(test.map_struct.selector).with_key(address(this)).depth(0).find(); + assertEq(uint256(keccak256(abi.encode(address(this), 4))), slot); + } + + function test_StorageMapStructB() public { + uint256 slot = + stdstore.target(address(test)).sig(test.map_struct.selector).with_key(address(this)).depth(1).find(); + assertEq(uint256(keccak256(abi.encode(address(this), 4))) + 1, slot); + } + + function test_StorageDeepMap() public { + uint256 slot = stdstore.target(address(test)).sig(test.deep_map.selector).with_key(address(this)).with_key( + address(this) + ).find(); + assertEq(uint256(keccak256(abi.encode(address(this), keccak256(abi.encode(address(this), uint256(5)))))), slot); + } + + function test_StorageCheckedWriteDeepMap() public { + stdstore.target(address(test)).sig(test.deep_map.selector).with_key(address(this)).with_key(address(this)) + .checked_write(100); + assertEq(100, test.deep_map(address(this), address(this))); + } + + function test_StorageDeepMapStructA() public { + uint256 slot = stdstore.target(address(test)).sig(test.deep_map_struct.selector).with_key(address(this)) + .with_key(address(this)).depth(0).find(); + assertEq( + bytes32(uint256(keccak256(abi.encode(address(this), keccak256(abi.encode(address(this), uint256(6)))))) + 0), + bytes32(slot) + ); + } + + function test_StorageDeepMapStructB() public { + uint256 slot = stdstore.target(address(test)).sig(test.deep_map_struct.selector).with_key(address(this)) + .with_key(address(this)).depth(1).find(); + assertEq( + bytes32(uint256(keccak256(abi.encode(address(this), keccak256(abi.encode(address(this), uint256(6)))))) + 1), + bytes32(slot) + ); + } + + function test_StorageCheckedWriteDeepMapStructA() public { + stdstore.target(address(test)).sig(test.deep_map_struct.selector).with_key(address(this)).with_key( + address(this) + ).depth(0).checked_write(100); + (uint256 a, uint256 b) = test.deep_map_struct(address(this), address(this)); + assertEq(100, a); + assertEq(0, b); + } + + function test_StorageCheckedWriteDeepMapStructB() public { + stdstore.target(address(test)).sig(test.deep_map_struct.selector).with_key(address(this)).with_key( + address(this) + ).depth(1).checked_write(100); + (uint256 a, uint256 b) = test.deep_map_struct(address(this), address(this)); + assertEq(0, a); + assertEq(100, b); + } + + function test_StorageCheckedWriteMapStructA() public { + stdstore.target(address(test)).sig(test.map_struct.selector).with_key(address(this)).depth(0).checked_write(100); + (uint256 a, uint256 b) = test.map_struct(address(this)); + assertEq(a, 100); + assertEq(b, 0); + } + + function test_StorageCheckedWriteMapStructB() public { + stdstore.target(address(test)).sig(test.map_struct.selector).with_key(address(this)).depth(1).checked_write(100); + (uint256 a, uint256 b) = test.map_struct(address(this)); + assertEq(a, 0); + assertEq(b, 100); + } + + function test_StorageStructA() public { + uint256 slot = stdstore.target(address(test)).sig(test.basic.selector).depth(0).find(); + assertEq(uint256(7), slot); + } + + function test_StorageStructB() public { + uint256 slot = stdstore.target(address(test)).sig(test.basic.selector).depth(1).find(); + assertEq(uint256(7) + 1, slot); + } + + function test_StorageCheckedWriteStructA() public { + stdstore.target(address(test)).sig(test.basic.selector).depth(0).checked_write(100); + (uint256 a, uint256 b) = test.basic(); + assertEq(a, 100); + assertEq(b, 1337); + } + + function test_StorageCheckedWriteStructB() public { + stdstore.target(address(test)).sig(test.basic.selector).depth(1).checked_write(100); + (uint256 a, uint256 b) = test.basic(); + assertEq(a, 1337); + assertEq(b, 100); + } + + function test_StorageMapAddrFound() public { + uint256 slot = stdstore.target(address(test)).sig(test.map_addr.selector).with_key(address(this)).find(); + assertEq(uint256(keccak256(abi.encode(address(this), uint256(1)))), slot); + } + + function test_StorageMapAddrRoot() public { + (uint256 slot, bytes32 key) = + stdstore.target(address(test)).sig(test.map_addr.selector).with_key(address(this)).parent(); + assertEq(address(uint160(uint256(key))), address(this)); + assertEq(uint256(1), slot); + slot = stdstore.target(address(test)).sig(test.map_addr.selector).with_key(address(this)).root(); + assertEq(uint256(1), slot); + } + + function test_StorageMapUintFound() public { + uint256 slot = stdstore.target(address(test)).sig(test.map_uint.selector).with_key(100).find(); + assertEq(uint256(keccak256(abi.encode(100, uint256(2)))), slot); + } + + function test_StorageCheckedWriteMapUint() public { + stdstore.target(address(test)).sig(test.map_uint.selector).with_key(100).checked_write(100); + assertEq(100, test.map_uint(100)); + } + + function test_StorageCheckedWriteMapAddr() public { + stdstore.target(address(test)).sig(test.map_addr.selector).with_key(address(this)).checked_write(100); + assertEq(100, test.map_addr(address(this))); + } + + function test_StorageCheckedWriteMapBool() public { + stdstore.target(address(test)).sig(test.map_bool.selector).with_key(address(this)).checked_write(true); + assertTrue(test.map_bool(address(this))); + } + + function testFail_StorageCheckedWriteMapPacked() public { + // expect PackedSlot error but not external call so cant expectRevert + stdstore.target(address(test)).sig(test.read_struct_lower.selector).with_key(address(uint160(1337))) + .checked_write(100); + } + + function test_StorageCheckedWriteMapPackedSuccess() public { + uint256 full = test.map_packed(address(1337)); + // keep upper 128, set lower 128 to 1337 + full = (full & (uint256((1 << 128) - 1) << 128)) | 1337; + stdstore.target(address(test)).sig(test.map_packed.selector).with_key(address(uint160(1337))).checked_write( + full + ); + assertEq(1337, test.read_struct_lower(address(1337))); + } + + function testFail_StorageConst() public { + // vm.expectRevert(abi.encodeWithSignature("NotStorage(bytes4)", bytes4(keccak256("const()")))); + stdstore.target(address(test)).sig("const()").find(); + } + + function testFail_StorageNativePack() public { + stdstore.target(address(test)).sig(test.tA.selector).find(); + stdstore.target(address(test)).sig(test.tB.selector).find(); + + // these both would fail + stdstore.target(address(test)).sig(test.tC.selector).find(); + stdstore.target(address(test)).sig(test.tD.selector).find(); + } + + function test_StorageReadBytes32() public { + bytes32 val = stdstore.target(address(test)).sig(test.tE.selector).read_bytes32(); + assertEq(val, hex"1337"); + } + + function test_StorageReadBool_False() public { + bool val = stdstore.target(address(test)).sig(test.tB.selector).read_bool(); + assertEq(val, false); + } + + function test_StorageReadBool_True() public { + bool val = stdstore.target(address(test)).sig(test.tH.selector).read_bool(); + assertEq(val, true); + } + + function test_StorageReadBool_Revert() public { + vm.expectRevert("stdStorage read_bool(StdStorage): Cannot decode. Make sure you are reading a bool."); + this.readNonBoolValue(); + } + + function readNonBoolValue() public { + stdstore.target(address(test)).sig(test.tE.selector).read_bool(); + } + + function test_StorageReadAddress() public { + address val = stdstore.target(address(test)).sig(test.tF.selector).read_address(); + assertEq(val, address(1337)); + } + + function test_StorageReadUint() public { + uint256 val = stdstore.target(address(test)).sig(test.exists.selector).read_uint(); + assertEq(val, 1); + } + + function test_StorageReadInt() public { + int256 val = stdstore.target(address(test)).sig(test.tG.selector).read_int(); + assertEq(val, type(int256).min); + } +} + +contract StorageTest { + uint256 public exists = 1; + mapping(address => uint256) public map_addr; + mapping(uint256 => uint256) public map_uint; + mapping(address => uint256) public map_packed; + mapping(address => UnpackedStruct) public map_struct; + mapping(address => mapping(address => uint256)) public deep_map; + mapping(address => mapping(address => UnpackedStruct)) public deep_map_struct; + UnpackedStruct public basic; + + uint248 public tA; + bool public tB; + + bool public tC = false; + uint248 public tD = 1; + + struct UnpackedStruct { + uint256 a; + uint256 b; + } + + mapping(address => bool) public map_bool; + + bytes32 public tE = hex"1337"; + address public tF = address(1337); + int256 public tG = type(int256).min; + bool public tH = true; + bytes32 private tI = ~bytes32(hex"1337"); + + constructor() { + basic = UnpackedStruct({a: 1337, b: 1337}); + + uint256 two = (1 << 128) | 1; + map_packed[msg.sender] = two; + map_packed[address(uint160(1337))] = 1 << 128; + } + + function read_struct_upper(address who) public view returns (uint256) { + return map_packed[who] >> 128; + } + + function read_struct_lower(address who) public view returns (uint256) { + return map_packed[who] & ((1 << 128) - 1); + } + + function hidden() public view returns (bytes32 t) { + bytes32 slot = keccak256("my.random.var"); + /// @solidity memory-safe-assembly + assembly { + t := sload(slot) + } + } + + function const() public pure returns (bytes32 t) { + t = bytes32(hex"1337"); + } + + function extra_sload() public view returns (bytes32 t) { + // trigger read on slot `tE`, and make a staticcall to make sure compiler doesn't optimize this SLOAD away + assembly { + pop(staticcall(gas(), sload(tE.slot), 0, 0, 0, 0)) + } + t = tI; + } +} diff --git a/docs/crypto/zkCTF/day1/Ethereal/mint-contracts/lib/forge-std/test/StdStyle.t.sol b/docs/crypto/zkCTF/day1/Ethereal/mint-contracts/lib/forge-std/test/StdStyle.t.sol new file mode 100644 index 0000000..e12c005 --- /dev/null +++ b/docs/crypto/zkCTF/day1/Ethereal/mint-contracts/lib/forge-std/test/StdStyle.t.sol @@ -0,0 +1,110 @@ +// SPDX-License-Identifier: MIT +pragma solidity >=0.7.0 <0.9.0; + +import "../src/Test.sol"; + +contract StdStyleTest is Test { + function test_StyleColor() public pure { + console2.log(StdStyle.red("StdStyle.red String Test")); + console2.log(StdStyle.red(uint256(10e18))); + console2.log(StdStyle.red(int256(-10e18))); + console2.log(StdStyle.red(true)); + console2.log(StdStyle.red(address(0))); + console2.log(StdStyle.redBytes(hex"7109709ECfa91a80626fF3989D68f67F5b1DD12D")); + console2.log(StdStyle.redBytes32("StdStyle.redBytes32")); + console2.log(StdStyle.green("StdStyle.green String Test")); + console2.log(StdStyle.green(uint256(10e18))); + console2.log(StdStyle.green(int256(-10e18))); + console2.log(StdStyle.green(true)); + console2.log(StdStyle.green(address(0))); + console2.log(StdStyle.greenBytes(hex"7109709ECfa91a80626fF3989D68f67F5b1DD12D")); + console2.log(StdStyle.greenBytes32("StdStyle.greenBytes32")); + console2.log(StdStyle.yellow("StdStyle.yellow String Test")); + console2.log(StdStyle.yellow(uint256(10e18))); + console2.log(StdStyle.yellow(int256(-10e18))); + console2.log(StdStyle.yellow(true)); + console2.log(StdStyle.yellow(address(0))); + console2.log(StdStyle.yellowBytes(hex"7109709ECfa91a80626fF3989D68f67F5b1DD12D")); + console2.log(StdStyle.yellowBytes32("StdStyle.yellowBytes32")); + console2.log(StdStyle.blue("StdStyle.blue String Test")); + console2.log(StdStyle.blue(uint256(10e18))); + console2.log(StdStyle.blue(int256(-10e18))); + console2.log(StdStyle.blue(true)); + console2.log(StdStyle.blue(address(0))); + console2.log(StdStyle.blueBytes(hex"7109709ECfa91a80626fF3989D68f67F5b1DD12D")); + console2.log(StdStyle.blueBytes32("StdStyle.blueBytes32")); + console2.log(StdStyle.magenta("StdStyle.magenta String Test")); + console2.log(StdStyle.magenta(uint256(10e18))); + console2.log(StdStyle.magenta(int256(-10e18))); + console2.log(StdStyle.magenta(true)); + console2.log(StdStyle.magenta(address(0))); + console2.log(StdStyle.magentaBytes(hex"7109709ECfa91a80626fF3989D68f67F5b1DD12D")); + console2.log(StdStyle.magentaBytes32("StdStyle.magentaBytes32")); + console2.log(StdStyle.cyan("StdStyle.cyan String Test")); + console2.log(StdStyle.cyan(uint256(10e18))); + console2.log(StdStyle.cyan(int256(-10e18))); + console2.log(StdStyle.cyan(true)); + console2.log(StdStyle.cyan(address(0))); + console2.log(StdStyle.cyanBytes(hex"7109709ECfa91a80626fF3989D68f67F5b1DD12D")); + console2.log(StdStyle.cyanBytes32("StdStyle.cyanBytes32")); + } + + function test_StyleFontWeight() public pure { + console2.log(StdStyle.bold("StdStyle.bold String Test")); + console2.log(StdStyle.bold(uint256(10e18))); + console2.log(StdStyle.bold(int256(-10e18))); + console2.log(StdStyle.bold(address(0))); + console2.log(StdStyle.bold(true)); + console2.log(StdStyle.boldBytes(hex"7109709ECfa91a80626fF3989D68f67F5b1DD12D")); + console2.log(StdStyle.boldBytes32("StdStyle.boldBytes32")); + console2.log(StdStyle.dim("StdStyle.dim String Test")); + console2.log(StdStyle.dim(uint256(10e18))); + console2.log(StdStyle.dim(int256(-10e18))); + console2.log(StdStyle.dim(address(0))); + console2.log(StdStyle.dim(true)); + console2.log(StdStyle.dimBytes(hex"7109709ECfa91a80626fF3989D68f67F5b1DD12D")); + console2.log(StdStyle.dimBytes32("StdStyle.dimBytes32")); + console2.log(StdStyle.italic("StdStyle.italic String Test")); + console2.log(StdStyle.italic(uint256(10e18))); + console2.log(StdStyle.italic(int256(-10e18))); + console2.log(StdStyle.italic(address(0))); + console2.log(StdStyle.italic(true)); + console2.log(StdStyle.italicBytes(hex"7109709ECfa91a80626fF3989D68f67F5b1DD12D")); + console2.log(StdStyle.italicBytes32("StdStyle.italicBytes32")); + console2.log(StdStyle.underline("StdStyle.underline String Test")); + console2.log(StdStyle.underline(uint256(10e18))); + console2.log(StdStyle.underline(int256(-10e18))); + console2.log(StdStyle.underline(address(0))); + console2.log(StdStyle.underline(true)); + console2.log(StdStyle.underlineBytes(hex"7109709ECfa91a80626fF3989D68f67F5b1DD12D")); + console2.log(StdStyle.underlineBytes32("StdStyle.underlineBytes32")); + console2.log(StdStyle.inverse("StdStyle.inverse String Test")); + console2.log(StdStyle.inverse(uint256(10e18))); + console2.log(StdStyle.inverse(int256(-10e18))); + console2.log(StdStyle.inverse(address(0))); + console2.log(StdStyle.inverse(true)); + console2.log(StdStyle.inverseBytes(hex"7109709ECfa91a80626fF3989D68f67F5b1DD12D")); + console2.log(StdStyle.inverseBytes32("StdStyle.inverseBytes32")); + } + + function test_StyleCombined() public pure { + console2.log(StdStyle.red(StdStyle.bold("Red Bold String Test"))); + console2.log(StdStyle.green(StdStyle.dim(uint256(10e18)))); + console2.log(StdStyle.yellow(StdStyle.italic(int256(-10e18)))); + console2.log(StdStyle.blue(StdStyle.underline(address(0)))); + console2.log(StdStyle.magenta(StdStyle.inverse(true))); + } + + function test_StyleCustom() public pure { + console2.log(h1("Custom Style 1")); + console2.log(h2("Custom Style 2")); + } + + function h1(string memory a) private pure returns (string memory) { + return StdStyle.cyan(StdStyle.inverse(StdStyle.bold(a))); + } + + function h2(string memory a) private pure returns (string memory) { + return StdStyle.magenta(StdStyle.bold(StdStyle.underline(a))); + } +} diff --git a/docs/crypto/zkCTF/day1/Ethereal/mint-contracts/lib/forge-std/test/StdUtils.t.sol b/docs/crypto/zkCTF/day1/Ethereal/mint-contracts/lib/forge-std/test/StdUtils.t.sol new file mode 100644 index 0000000..80acc25 --- /dev/null +++ b/docs/crypto/zkCTF/day1/Ethereal/mint-contracts/lib/forge-std/test/StdUtils.t.sol @@ -0,0 +1,342 @@ +// SPDX-License-Identifier: MIT +pragma solidity >=0.7.0 <0.9.0; + +import "../src/Test.sol"; + +contract StdUtilsMock is StdUtils { + // We deploy a mock version so we can properly test expected reverts. + function exposed_getTokenBalances(address token, address[] memory addresses) + external + returns (uint256[] memory balances) + { + return getTokenBalances(token, addresses); + } + + function exposed_bound(int256 num, int256 min, int256 max) external pure returns (int256) { + return bound(num, min, max); + } + + function exposed_bound(uint256 num, uint256 min, uint256 max) external pure returns (uint256) { + return bound(num, min, max); + } + + function exposed_bytesToUint(bytes memory b) external pure returns (uint256) { + return bytesToUint(b); + } +} + +contract StdUtilsTest is Test { + /*////////////////////////////////////////////////////////////////////////// + BOUND UINT + //////////////////////////////////////////////////////////////////////////*/ + + function test_Bound() public { + assertEq(bound(uint256(5), 0, 4), 0); + assertEq(bound(uint256(0), 69, 69), 69); + assertEq(bound(uint256(0), 68, 69), 68); + assertEq(bound(uint256(10), 150, 190), 174); + assertEq(bound(uint256(300), 2800, 3200), 3107); + assertEq(bound(uint256(9999), 1337, 6666), 4669); + } + + function test_Bound_WithinRange() public { + assertEq(bound(uint256(51), 50, 150), 51); + assertEq(bound(uint256(51), 50, 150), bound(bound(uint256(51), 50, 150), 50, 150)); + assertEq(bound(uint256(149), 50, 150), 149); + assertEq(bound(uint256(149), 50, 150), bound(bound(uint256(149), 50, 150), 50, 150)); + } + + function test_Bound_EdgeCoverage() public { + assertEq(bound(uint256(0), 50, 150), 50); + assertEq(bound(uint256(1), 50, 150), 51); + assertEq(bound(uint256(2), 50, 150), 52); + assertEq(bound(uint256(3), 50, 150), 53); + assertEq(bound(type(uint256).max, 50, 150), 150); + assertEq(bound(type(uint256).max - 1, 50, 150), 149); + assertEq(bound(type(uint256).max - 2, 50, 150), 148); + assertEq(bound(type(uint256).max - 3, 50, 150), 147); + } + + function test_Bound_DistributionIsEven(uint256 min, uint256 size) public { + size = size % 100 + 1; + min = bound(min, UINT256_MAX / 2, UINT256_MAX / 2 + size); + uint256 max = min + size - 1; + uint256 result; + + for (uint256 i = 1; i <= size * 4; ++i) { + // x > max + result = bound(max + i, min, max); + assertEq(result, min + (i - 1) % size); + // x < min + result = bound(min - i, min, max); + assertEq(result, max - (i - 1) % size); + } + } + + function test_Bound(uint256 num, uint256 min, uint256 max) public { + if (min > max) (min, max) = (max, min); + + uint256 result = bound(num, min, max); + + assertGe(result, min); + assertLe(result, max); + assertEq(result, bound(result, min, max)); + if (num >= min && num <= max) assertEq(result, num); + } + + function test_BoundUint256Max() public { + assertEq(bound(0, type(uint256).max - 1, type(uint256).max), type(uint256).max - 1); + assertEq(bound(1, type(uint256).max - 1, type(uint256).max), type(uint256).max); + } + + function test_CannotBoundMaxLessThanMin() public { + // We deploy a mock version so we can properly test the revert. + StdUtilsMock stdUtils = new StdUtilsMock(); + + vm.expectRevert(bytes("StdUtils bound(uint256,uint256,uint256): Max is less than min.")); + stdUtils.exposed_bound(uint256(5), 100, 10); + } + + function test_CannotBoundMaxLessThanMin(uint256 num, uint256 min, uint256 max) public { + // We deploy a mock version so we can properly test the revert. + StdUtilsMock stdUtils = new StdUtilsMock(); + + vm.assume(min > max); + vm.expectRevert(bytes("StdUtils bound(uint256,uint256,uint256): Max is less than min.")); + stdUtils.exposed_bound(num, min, max); + } + + /*////////////////////////////////////////////////////////////////////////// + BOUND INT + //////////////////////////////////////////////////////////////////////////*/ + + function test_BoundInt() public { + assertEq(bound(-3, 0, 4), 2); + assertEq(bound(0, -69, -69), -69); + assertEq(bound(0, -69, -68), -68); + assertEq(bound(-10, 150, 190), 154); + assertEq(bound(-300, 2800, 3200), 2908); + assertEq(bound(9999, -1337, 6666), 1995); + } + + function test_BoundInt_WithinRange() public { + assertEq(bound(51, -50, 150), 51); + assertEq(bound(51, -50, 150), bound(bound(51, -50, 150), -50, 150)); + assertEq(bound(149, -50, 150), 149); + assertEq(bound(149, -50, 150), bound(bound(149, -50, 150), -50, 150)); + } + + function test_BoundInt_EdgeCoverage() public { + assertEq(bound(type(int256).min, -50, 150), -50); + assertEq(bound(type(int256).min + 1, -50, 150), -49); + assertEq(bound(type(int256).min + 2, -50, 150), -48); + assertEq(bound(type(int256).min + 3, -50, 150), -47); + assertEq(bound(type(int256).min, 10, 150), 10); + assertEq(bound(type(int256).min + 1, 10, 150), 11); + assertEq(bound(type(int256).min + 2, 10, 150), 12); + assertEq(bound(type(int256).min + 3, 10, 150), 13); + + assertEq(bound(type(int256).max, -50, 150), 150); + assertEq(bound(type(int256).max - 1, -50, 150), 149); + assertEq(bound(type(int256).max - 2, -50, 150), 148); + assertEq(bound(type(int256).max - 3, -50, 150), 147); + assertEq(bound(type(int256).max, -50, -10), -10); + assertEq(bound(type(int256).max - 1, -50, -10), -11); + assertEq(bound(type(int256).max - 2, -50, -10), -12); + assertEq(bound(type(int256).max - 3, -50, -10), -13); + } + + function test_BoundInt_DistributionIsEven(int256 min, uint256 size) public { + size = size % 100 + 1; + min = bound(min, -int256(size / 2), int256(size - size / 2)); + int256 max = min + int256(size) - 1; + int256 result; + + for (uint256 i = 1; i <= size * 4; ++i) { + // x > max + result = bound(max + int256(i), min, max); + assertEq(result, min + int256((i - 1) % size)); + // x < min + result = bound(min - int256(i), min, max); + assertEq(result, max - int256((i - 1) % size)); + } + } + + function test_BoundInt(int256 num, int256 min, int256 max) public { + if (min > max) (min, max) = (max, min); + + int256 result = bound(num, min, max); + + assertGe(result, min); + assertLe(result, max); + assertEq(result, bound(result, min, max)); + if (num >= min && num <= max) assertEq(result, num); + } + + function test_BoundIntInt256Max() public { + assertEq(bound(0, type(int256).max - 1, type(int256).max), type(int256).max - 1); + assertEq(bound(1, type(int256).max - 1, type(int256).max), type(int256).max); + } + + function test_BoundIntInt256Min() public { + assertEq(bound(0, type(int256).min, type(int256).min + 1), type(int256).min); + assertEq(bound(1, type(int256).min, type(int256).min + 1), type(int256).min + 1); + } + + function test_CannotBoundIntMaxLessThanMin() public { + // We deploy a mock version so we can properly test the revert. + StdUtilsMock stdUtils = new StdUtilsMock(); + + vm.expectRevert(bytes("StdUtils bound(int256,int256,int256): Max is less than min.")); + stdUtils.exposed_bound(-5, 100, 10); + } + + function test_CannotBoundIntMaxLessThanMin(int256 num, int256 min, int256 max) public { + // We deploy a mock version so we can properly test the revert. + StdUtilsMock stdUtils = new StdUtilsMock(); + + vm.assume(min > max); + vm.expectRevert(bytes("StdUtils bound(int256,int256,int256): Max is less than min.")); + stdUtils.exposed_bound(num, min, max); + } + + /*////////////////////////////////////////////////////////////////////////// + BOUND PRIVATE KEY + //////////////////////////////////////////////////////////////////////////*/ + + function test_BoundPrivateKey() public { + assertEq(boundPrivateKey(0), 1); + assertEq(boundPrivateKey(1), 1); + assertEq(boundPrivateKey(300), 300); + assertEq(boundPrivateKey(9999), 9999); + assertEq(boundPrivateKey(SECP256K1_ORDER - 1), SECP256K1_ORDER - 1); + assertEq(boundPrivateKey(SECP256K1_ORDER), 1); + assertEq(boundPrivateKey(SECP256K1_ORDER + 1), 2); + assertEq(boundPrivateKey(UINT256_MAX), UINT256_MAX & SECP256K1_ORDER - 1); // x&y is equivalent to x-x%y + } + + /*////////////////////////////////////////////////////////////////////////// + BYTES TO UINT + //////////////////////////////////////////////////////////////////////////*/ + + function test_BytesToUint() external { + bytes memory maxUint = hex"ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"; + bytes memory two = hex"02"; + bytes memory millionEther = hex"d3c21bcecceda1000000"; + + assertEq(bytesToUint(maxUint), type(uint256).max); + assertEq(bytesToUint(two), 2); + assertEq(bytesToUint(millionEther), 1_000_000 ether); + } + + function test_CannotConvertGT32Bytes() external { + // We deploy a mock version so we can properly test the revert. + StdUtilsMock stdUtils = new StdUtilsMock(); + + bytes memory thirty3Bytes = hex"ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"; + vm.expectRevert("StdUtils bytesToUint(bytes): Bytes length exceeds 32."); + stdUtils.exposed_bytesToUint(thirty3Bytes); + } + + /*////////////////////////////////////////////////////////////////////////// + COMPUTE CREATE ADDRESS + //////////////////////////////////////////////////////////////////////////*/ + + function test_ComputeCreateAddress() external { + address deployer = 0x6C9FC64A53c1b71FB3f9Af64d1ae3A4931A5f4E9; + uint256 nonce = 14; + address createAddress = computeCreateAddress(deployer, nonce); + assertEq(createAddress, 0x68b3465833fb72A70ecDF485E0e4C7bD8665Fc45); + } + + /*////////////////////////////////////////////////////////////////////////// + COMPUTE CREATE2 ADDRESS + //////////////////////////////////////////////////////////////////////////*/ + + function test_ComputeCreate2Address() external { + bytes32 salt = bytes32(uint256(31415)); + bytes32 initcodeHash = keccak256(abi.encode(0x6080)); + address deployer = 0x6C9FC64A53c1b71FB3f9Af64d1ae3A4931A5f4E9; + address create2Address = computeCreate2Address(salt, initcodeHash, deployer); + assertEq(create2Address, 0xB147a5d25748fda14b463EB04B111027C290f4d3); + } + + function test_ComputeCreate2AddressWithDefaultDeployer() external { + bytes32 salt = 0xc290c670fde54e5ef686f9132cbc8711e76a98f0333a438a92daa442c71403c0; + bytes32 initcodeHash = hashInitCode(hex"6080", ""); + assertEq(initcodeHash, 0x1a578b7a4b0b5755db6d121b4118d4bc68fe170dca840c59bc922f14175a76b0); + address create2Address = computeCreate2Address(salt, initcodeHash); + assertEq(create2Address, 0xc0ffEe2198a06235aAbFffe5Db0CacF1717f5Ac6); + } +} + +contract StdUtilsForkTest is Test { + /*////////////////////////////////////////////////////////////////////////// + GET TOKEN BALANCES + //////////////////////////////////////////////////////////////////////////*/ + + address internal SHIB = 0x95aD61b0a150d79219dCF64E1E6Cc01f0B64C4cE; + address internal SHIB_HOLDER_0 = 0x855F5981e831D83e6A4b4EBFCAdAa68D92333170; + address internal SHIB_HOLDER_1 = 0x8F509A90c2e47779cA408Fe00d7A72e359229AdA; + address internal SHIB_HOLDER_2 = 0x0e3bbc0D04fF62211F71f3e4C45d82ad76224385; + + address internal USDC = 0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48; + address internal USDC_HOLDER_0 = 0xDa9CE944a37d218c3302F6B82a094844C6ECEb17; + address internal USDC_HOLDER_1 = 0x3e67F4721E6d1c41a015f645eFa37BEd854fcf52; + + function setUp() public { + // All tests of the `getTokenBalances` method are fork tests using live contracts. + vm.createSelectFork({urlOrAlias: "mainnet", blockNumber: 16_428_900}); + } + + function test_CannotGetTokenBalances_NonTokenContract() external { + // We deploy a mock version so we can properly test the revert. + StdUtilsMock stdUtils = new StdUtilsMock(); + + // The UniswapV2Factory contract has neither a `balanceOf` function nor a fallback function, + // so the `balanceOf` call should revert. + address token = address(0x5C69bEe701ef814a2B6a3EDD4B1652CB9cc5aA6f); + address[] memory addresses = new address[](1); + addresses[0] = USDC_HOLDER_0; + + vm.expectRevert("Multicall3: call failed"); + stdUtils.exposed_getTokenBalances(token, addresses); + } + + function test_CannotGetTokenBalances_EOA() external { + // We deploy a mock version so we can properly test the revert. + StdUtilsMock stdUtils = new StdUtilsMock(); + + address eoa = vm.addr({privateKey: 1}); + address[] memory addresses = new address[](1); + addresses[0] = USDC_HOLDER_0; + vm.expectRevert("StdUtils getTokenBalances(address,address[]): Token address is not a contract."); + stdUtils.exposed_getTokenBalances(eoa, addresses); + } + + function test_GetTokenBalances_Empty() external { + address[] memory addresses = new address[](0); + uint256[] memory balances = getTokenBalances(USDC, addresses); + assertEq(balances.length, 0); + } + + function test_GetTokenBalances_USDC() external { + address[] memory addresses = new address[](2); + addresses[0] = USDC_HOLDER_0; + addresses[1] = USDC_HOLDER_1; + uint256[] memory balances = getTokenBalances(USDC, addresses); + assertEq(balances[0], 159_000_000_000_000); + assertEq(balances[1], 131_350_000_000_000); + } + + function test_GetTokenBalances_SHIB() external { + address[] memory addresses = new address[](3); + addresses[0] = SHIB_HOLDER_0; + addresses[1] = SHIB_HOLDER_1; + addresses[2] = SHIB_HOLDER_2; + uint256[] memory balances = getTokenBalances(SHIB, addresses); + assertEq(balances[0], 3_323_256_285_484.42e18); + assertEq(balances[1], 1_271_702_771_149.99999928e18); + assertEq(balances[2], 606_357_106_247e18); + } +} diff --git a/docs/crypto/zkCTF/day1/Ethereal/mint-contracts/lib/forge-std/test/Vm.t.sol b/docs/crypto/zkCTF/day1/Ethereal/mint-contracts/lib/forge-std/test/Vm.t.sol new file mode 100644 index 0000000..dcea767 --- /dev/null +++ b/docs/crypto/zkCTF/day1/Ethereal/mint-contracts/lib/forge-std/test/Vm.t.sol @@ -0,0 +1,15 @@ +// SPDX-License-Identifier: MIT +pragma solidity >=0.8.0 <0.9.0; + +import {Test} from "../src/Test.sol"; +import {Vm, VmSafe} from "../src/Vm.sol"; + +contract VmTest is Test { + // This test ensures that functions are never accidentally removed from a Vm interface, or + // inadvertently moved between Vm and VmSafe. This test must be updated each time a function is + // added to or removed from Vm or VmSafe. + function test_interfaceId() public { + assertEq(type(VmSafe).interfaceId, bytes4(0x7e017c39), "VmSafe"); + assertEq(type(Vm).interfaceId, bytes4(0xd6a02054), "Vm"); + } +} diff --git a/docs/crypto/zkCTF/day1/Ethereal/mint-contracts/lib/forge-std/test/compilation/CompilationScript.sol b/docs/crypto/zkCTF/day1/Ethereal/mint-contracts/lib/forge-std/test/compilation/CompilationScript.sol new file mode 100644 index 0000000..e205cff --- /dev/null +++ b/docs/crypto/zkCTF/day1/Ethereal/mint-contracts/lib/forge-std/test/compilation/CompilationScript.sol @@ -0,0 +1,10 @@ +// SPDX-License-Identifier: MIT +pragma solidity >=0.6.2 <0.9.0; + +pragma experimental ABIEncoderV2; + +import "../../src/Script.sol"; + +// The purpose of this contract is to benchmark compilation time to avoid accidentally introducing +// a change that results in very long compilation times with via-ir. See https://github.com/foundry-rs/forge-std/issues/207 +contract CompilationScript is Script {} diff --git a/docs/crypto/zkCTF/day1/Ethereal/mint-contracts/lib/forge-std/test/compilation/CompilationScriptBase.sol b/docs/crypto/zkCTF/day1/Ethereal/mint-contracts/lib/forge-std/test/compilation/CompilationScriptBase.sol new file mode 100644 index 0000000..ce8e0e9 --- /dev/null +++ b/docs/crypto/zkCTF/day1/Ethereal/mint-contracts/lib/forge-std/test/compilation/CompilationScriptBase.sol @@ -0,0 +1,10 @@ +// SPDX-License-Identifier: MIT +pragma solidity >=0.6.2 <0.9.0; + +pragma experimental ABIEncoderV2; + +import "../../src/Script.sol"; + +// The purpose of this contract is to benchmark compilation time to avoid accidentally introducing +// a change that results in very long compilation times with via-ir. See https://github.com/foundry-rs/forge-std/issues/207 +contract CompilationScriptBase is ScriptBase {} diff --git a/docs/crypto/zkCTF/day1/Ethereal/mint-contracts/lib/forge-std/test/compilation/CompilationTest.sol b/docs/crypto/zkCTF/day1/Ethereal/mint-contracts/lib/forge-std/test/compilation/CompilationTest.sol new file mode 100644 index 0000000..9beeafe --- /dev/null +++ b/docs/crypto/zkCTF/day1/Ethereal/mint-contracts/lib/forge-std/test/compilation/CompilationTest.sol @@ -0,0 +1,10 @@ +// SPDX-License-Identifier: MIT +pragma solidity >=0.6.2 <0.9.0; + +pragma experimental ABIEncoderV2; + +import "../../src/Test.sol"; + +// The purpose of this contract is to benchmark compilation time to avoid accidentally introducing +// a change that results in very long compilation times with via-ir. See https://github.com/foundry-rs/forge-std/issues/207 +contract CompilationTest is Test {} diff --git a/docs/crypto/zkCTF/day1/Ethereal/mint-contracts/lib/forge-std/test/compilation/CompilationTestBase.sol b/docs/crypto/zkCTF/day1/Ethereal/mint-contracts/lib/forge-std/test/compilation/CompilationTestBase.sol new file mode 100644 index 0000000..e993535 --- /dev/null +++ b/docs/crypto/zkCTF/day1/Ethereal/mint-contracts/lib/forge-std/test/compilation/CompilationTestBase.sol @@ -0,0 +1,10 @@ +// SPDX-License-Identifier: MIT +pragma solidity >=0.6.2 <0.9.0; + +pragma experimental ABIEncoderV2; + +import "../../src/Test.sol"; + +// The purpose of this contract is to benchmark compilation time to avoid accidentally introducing +// a change that results in very long compilation times with via-ir. See https://github.com/foundry-rs/forge-std/issues/207 +contract CompilationTestBase is TestBase {} diff --git a/docs/crypto/zkCTF/day1/Ethereal/mint-contracts/lib/forge-std/test/fixtures/broadcast.log.json b/docs/crypto/zkCTF/day1/Ethereal/mint-contracts/lib/forge-std/test/fixtures/broadcast.log.json new file mode 100644 index 0000000..0a0200b --- /dev/null +++ b/docs/crypto/zkCTF/day1/Ethereal/mint-contracts/lib/forge-std/test/fixtures/broadcast.log.json @@ -0,0 +1,187 @@ +{ + "transactions": [ + { + "hash": "0xc6006863c267735a11476b7f15b15bc718e117e2da114a2be815dd651e1a509f", + "type": "CALL", + "contractName": "Test", + "contractAddress": "0xe7f1725e7734ce288f8367e1bb143e90bb3f0512", + "function": "multiple_arguments(uint256,address,uint256[]):(uint256)", + "arguments": ["1", "0000000000000000000000000000000000001337", "[3,4]"], + "tx": { + "type": "0x02", + "from": "0xf39fd6e51aad88f6f4ce6ab8827279cfffb92266", + "to": "0xe7f1725e7734ce288f8367e1bb143e90bb3f0512", + "gas": "0x73b9", + "value": "0x0", + "data": "0x23e99187000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000013370000000000000000000000000000000000000000000000000000000000000060000000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000030000000000000000000000000000000000000000000000000000000000000004", + "nonce": "0x3", + "accessList": [] + } + }, + { + "hash": "0xedf2b38d8d896519a947a1acf720f859bb35c0c5ecb8dd7511995b67b9853298", + "type": "CALL", + "contractName": "Test", + "contractAddress": "0xe7f1725e7734ce288f8367e1bb143e90bb3f0512", + "function": "inc():(uint256)", + "arguments": [], + "tx": { + "type": "0x02", + "from": "0xf39fd6e51aad88f6f4ce6ab8827279cfffb92266", + "to": "0xe7f1725e7734ce288f8367e1bb143e90bb3f0512", + "gas": "0xdcb2", + "value": "0x0", + "data": "0x371303c0", + "nonce": "0x4", + "accessList": [] + } + }, + { + "hash": "0xa57e8e3981a6c861442e46c9471bd19cb3e21f9a8a6c63a72e7b5c47c6675a7c", + "type": "CALL", + "contractName": "Test", + "contractAddress": "0x7c6b4bbe207d642d98d5c537142d85209e585087", + "function": "t(uint256):(uint256)", + "arguments": ["1"], + "tx": { + "type": "0x02", + "from": "0xf39fd6e51aad88f6f4ce6ab8827279cfffb92266", + "to": "0x7c6b4bbe207d642d98d5c537142d85209e585087", + "gas": "0x8599", + "value": "0x0", + "data": "0xafe29f710000000000000000000000000000000000000000000000000000000000000001", + "nonce": "0x5", + "accessList": [] + } + } + ], + "receipts": [ + { + "transactionHash": "0x481dc86e40bba90403c76f8e144aa9ff04c1da2164299d0298573835f0991181", + "transactionIndex": "0x0", + "blockHash": "0xef0730448490304e5403be0fa8f8ce64f118e9adcca60c07a2ae1ab921d748af", + "blockNumber": "0x1", + "from": "0xf39fd6e51aad88f6f4ce6ab8827279cfffb92266", + "to": null, + "cumulativeGasUsed": "0x13f3a", + "gasUsed": "0x13f3a", + "contractAddress": "0x5fbdb2315678afecb367f032d93f642f64180aa3", + "logs": [], + "status": "0x1", + "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "effectiveGasPrice": "0xee6b2800" + }, + { + "transactionHash": "0x6a187183545b8a9e7f1790e847139379bf5622baff2cb43acf3f5c79470af782", + "transactionIndex": "0x0", + "blockHash": "0xf3acb96a90071640c2a8c067ae4e16aad87e634ea8d8bbbb5b352fba86ba0148", + "blockNumber": "0x2", + "from": "0xf39fd6e51aad88f6f4ce6ab8827279cfffb92266", + "to": null, + "cumulativeGasUsed": "0x45d80", + "gasUsed": "0x45d80", + "contractAddress": "0xe7f1725e7734ce288f8367e1bb143e90bb3f0512", + "logs": [], + "status": "0x1", + "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "effectiveGasPrice": "0xee6b2800" + }, + { + "transactionHash": "0x064ad173b4867bdef2fb60060bbdaf01735fbf10414541ea857772974e74ea9d", + "transactionIndex": "0x0", + "blockHash": "0x8373d02109d3ee06a0225f23da4c161c656ccc48fe0fcee931d325508ae73e58", + "blockNumber": "0x3", + "from": "0xf39fd6e51aad88f6f4ce6ab8827279cfffb92266", + "to": "0x4e59b44847b379578588920ca78fbf26c0b4956c", + "cumulativeGasUsed": "0x45feb", + "gasUsed": "0x45feb", + "contractAddress": null, + "logs": [], + "status": "0x1", + "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "effectiveGasPrice": "0xee6b2800" + }, + { + "transactionHash": "0xc6006863c267735a11476b7f15b15bc718e117e2da114a2be815dd651e1a509f", + "transactionIndex": "0x0", + "blockHash": "0x16712fae5c0e18f75045f84363fb6b4d9a9fe25e660c4ce286833a533c97f629", + "blockNumber": "0x4", + "from": "0xf39fd6e51aad88f6f4ce6ab8827279cfffb92266", + "to": "0xe7f1725e7734ce288f8367e1bb143e90bb3f0512", + "cumulativeGasUsed": "0x5905", + "gasUsed": "0x5905", + "contractAddress": null, + "logs": [], + "status": "0x1", + "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "effectiveGasPrice": "0xee6b2800" + }, + { + "transactionHash": "0xedf2b38d8d896519a947a1acf720f859bb35c0c5ecb8dd7511995b67b9853298", + "transactionIndex": "0x0", + "blockHash": "0x156b88c3eb9a1244ba00a1834f3f70de735b39e3e59006dd03af4fe7d5480c11", + "blockNumber": "0x5", + "from": "0xf39fd6e51aad88f6f4ce6ab8827279cfffb92266", + "to": "0xe7f1725e7734ce288f8367e1bb143e90bb3f0512", + "cumulativeGasUsed": "0xa9c4", + "gasUsed": "0xa9c4", + "contractAddress": null, + "logs": [], + "status": "0x1", + "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "effectiveGasPrice": "0xee6b2800" + }, + { + "transactionHash": "0xa57e8e3981a6c861442e46c9471bd19cb3e21f9a8a6c63a72e7b5c47c6675a7c", + "transactionIndex": "0x0", + "blockHash": "0xcf61faca67dbb2c28952b0b8a379e53b1505ae0821e84779679390cb8571cadb", + "blockNumber": "0x6", + "from": "0xf39fd6e51aad88f6f4ce6ab8827279cfffb92266", + "to": "0x7c6b4bbe207d642d98d5c537142d85209e585087", + "cumulativeGasUsed": "0x66c5", + "gasUsed": "0x66c5", + "contractAddress": null, + "logs": [ + { + "address": "0x7c6b4bbe207d642d98d5c537142d85209e585087", + "topics": [ + "0x0b2e13ff20ac7b474198655583edf70dedd2c1dc980e329c4fbb2fc0748b796b" + ], + "data": "0x000000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000046865726500000000000000000000000000000000000000000000000000000000", + "blockHash": "0xcf61faca67dbb2c28952b0b8a379e53b1505ae0821e84779679390cb8571cadb", + "blockNumber": "0x6", + "transactionHash": "0xa57e8e3981a6c861442e46c9471bd19cb3e21f9a8a6c63a72e7b5c47c6675a7c", + "transactionIndex": "0x1", + "logIndex": "0x0", + "transactionLogIndex": "0x0", + "removed": false + } + ], + "status": "0x1", + "logsBloom": "0x00000000000800000000000000000010000000000000000000000000000180000000000000000000000000000000000000000000000008000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000100", + "effectiveGasPrice": "0xee6b2800" + }, + { + "transactionHash": "0x11fbb10230c168ca1e36a7e5c69a6dbcd04fd9e64ede39d10a83e36ee8065c16", + "transactionIndex": "0x0", + "blockHash": "0xf1e0ed2eda4e923626ec74621006ed50b3fc27580dc7b4cf68a07ca77420e29c", + "blockNumber": "0x7", + "from": "0xf39fd6e51aad88f6f4ce6ab8827279cfffb92266", + "to": "0x0000000000000000000000000000000000001337", + "cumulativeGasUsed": "0x5208", + "gasUsed": "0x5208", + "contractAddress": null, + "logs": [], + "status": "0x1", + "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "effectiveGasPrice": "0xee6b2800" + } + ], + "libraries": [ + "src/Broadcast.t.sol:F:0x5fbdb2315678afecb367f032d93f642f64180aa3" + ], + "pending": [], + "path": "broadcast/Broadcast.t.sol/31337/run-latest.json", + "returns": {}, + "timestamp": 1655140035 +} diff --git a/docs/crypto/zkCTF/day1/Ethereal/mint-contracts/lib/forge-std/test/mocks/MockERC20.t.sol b/docs/crypto/zkCTF/day1/Ethereal/mint-contracts/lib/forge-std/test/mocks/MockERC20.t.sol new file mode 100644 index 0000000..3649e60 --- /dev/null +++ b/docs/crypto/zkCTF/day1/Ethereal/mint-contracts/lib/forge-std/test/mocks/MockERC20.t.sol @@ -0,0 +1,441 @@ +// SPDX-License-Identifier: MIT +pragma solidity >=0.7.0 <0.9.0; + +import {MockERC20} from "../../src/mocks/MockERC20.sol"; +import {StdCheats} from "../../src/StdCheats.sol"; +import {Test} from "../../src/Test.sol"; + +contract Token_ERC20 is MockERC20 { + constructor(string memory name, string memory symbol, uint8 decimals) { + initialize(name, symbol, decimals); + } + + function mint(address to, uint256 value) public virtual { + _mint(to, value); + } + + function burn(address from, uint256 value) public virtual { + _burn(from, value); + } +} + +contract MockERC20Test is StdCheats, Test { + Token_ERC20 token; + + bytes32 constant PERMIT_TYPEHASH = + keccak256("Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)"); + + function setUp() public { + token = new Token_ERC20("Token", "TKN", 18); + } + + function invariantMetadata() public { + assertEq(token.name(), "Token"); + assertEq(token.symbol(), "TKN"); + assertEq(token.decimals(), 18); + } + + function testMint() public { + token.mint(address(0xBEEF), 1e18); + + assertEq(token.totalSupply(), 1e18); + assertEq(token.balanceOf(address(0xBEEF)), 1e18); + } + + function testBurn() public { + token.mint(address(0xBEEF), 1e18); + token.burn(address(0xBEEF), 0.9e18); + + assertEq(token.totalSupply(), 1e18 - 0.9e18); + assertEq(token.balanceOf(address(0xBEEF)), 0.1e18); + } + + function testApprove() public { + assertTrue(token.approve(address(0xBEEF), 1e18)); + + assertEq(token.allowance(address(this), address(0xBEEF)), 1e18); + } + + function testTransfer() public { + token.mint(address(this), 1e18); + + assertTrue(token.transfer(address(0xBEEF), 1e18)); + assertEq(token.totalSupply(), 1e18); + + assertEq(token.balanceOf(address(this)), 0); + assertEq(token.balanceOf(address(0xBEEF)), 1e18); + } + + function testTransferFrom() public { + address from = address(0xABCD); + + token.mint(from, 1e18); + + vm.prank(from); + token.approve(address(this), 1e18); + + assertTrue(token.transferFrom(from, address(0xBEEF), 1e18)); + assertEq(token.totalSupply(), 1e18); + + assertEq(token.allowance(from, address(this)), 0); + + assertEq(token.balanceOf(from), 0); + assertEq(token.balanceOf(address(0xBEEF)), 1e18); + } + + function testInfiniteApproveTransferFrom() public { + address from = address(0xABCD); + + token.mint(from, 1e18); + + vm.prank(from); + token.approve(address(this), type(uint256).max); + + assertTrue(token.transferFrom(from, address(0xBEEF), 1e18)); + assertEq(token.totalSupply(), 1e18); + + assertEq(token.allowance(from, address(this)), type(uint256).max); + + assertEq(token.balanceOf(from), 0); + assertEq(token.balanceOf(address(0xBEEF)), 1e18); + } + + function testPermit() public { + uint256 privateKey = 0xBEEF; + address owner = vm.addr(privateKey); + + (uint8 v, bytes32 r, bytes32 s) = vm.sign( + privateKey, + keccak256( + abi.encodePacked( + "\x19\x01", + token.DOMAIN_SEPARATOR(), + keccak256(abi.encode(PERMIT_TYPEHASH, owner, address(0xCAFE), 1e18, 0, block.timestamp)) + ) + ) + ); + + token.permit(owner, address(0xCAFE), 1e18, block.timestamp, v, r, s); + + assertEq(token.allowance(owner, address(0xCAFE)), 1e18); + assertEq(token.nonces(owner), 1); + } + + function testFailTransferInsufficientBalance() public { + token.mint(address(this), 0.9e18); + token.transfer(address(0xBEEF), 1e18); + } + + function testFailTransferFromInsufficientAllowance() public { + address from = address(0xABCD); + + token.mint(from, 1e18); + + vm.prank(from); + token.approve(address(this), 0.9e18); + + token.transferFrom(from, address(0xBEEF), 1e18); + } + + function testFailTransferFromInsufficientBalance() public { + address from = address(0xABCD); + + token.mint(from, 0.9e18); + + vm.prank(from); + token.approve(address(this), 1e18); + + token.transferFrom(from, address(0xBEEF), 1e18); + } + + function testFailPermitBadNonce() public { + uint256 privateKey = 0xBEEF; + address owner = vm.addr(privateKey); + + (uint8 v, bytes32 r, bytes32 s) = vm.sign( + privateKey, + keccak256( + abi.encodePacked( + "\x19\x01", + token.DOMAIN_SEPARATOR(), + keccak256(abi.encode(PERMIT_TYPEHASH, owner, address(0xCAFE), 1e18, 1, block.timestamp)) + ) + ) + ); + + token.permit(owner, address(0xCAFE), 1e18, block.timestamp, v, r, s); + } + + function testFailPermitBadDeadline() public { + uint256 privateKey = 0xBEEF; + address owner = vm.addr(privateKey); + + (uint8 v, bytes32 r, bytes32 s) = vm.sign( + privateKey, + keccak256( + abi.encodePacked( + "\x19\x01", + token.DOMAIN_SEPARATOR(), + keccak256(abi.encode(PERMIT_TYPEHASH, owner, address(0xCAFE), 1e18, 0, block.timestamp)) + ) + ) + ); + + token.permit(owner, address(0xCAFE), 1e18, block.timestamp + 1, v, r, s); + } + + function testFailPermitPastDeadline() public { + uint256 oldTimestamp = block.timestamp; + uint256 privateKey = 0xBEEF; + address owner = vm.addr(privateKey); + + (uint8 v, bytes32 r, bytes32 s) = vm.sign( + privateKey, + keccak256( + abi.encodePacked( + "\x19\x01", + token.DOMAIN_SEPARATOR(), + keccak256(abi.encode(PERMIT_TYPEHASH, owner, address(0xCAFE), 1e18, 0, oldTimestamp)) + ) + ) + ); + + vm.warp(block.timestamp + 1); + token.permit(owner, address(0xCAFE), 1e18, oldTimestamp, v, r, s); + } + + function testFailPermitReplay() public { + uint256 privateKey = 0xBEEF; + address owner = vm.addr(privateKey); + + (uint8 v, bytes32 r, bytes32 s) = vm.sign( + privateKey, + keccak256( + abi.encodePacked( + "\x19\x01", + token.DOMAIN_SEPARATOR(), + keccak256(abi.encode(PERMIT_TYPEHASH, owner, address(0xCAFE), 1e18, 0, block.timestamp)) + ) + ) + ); + + token.permit(owner, address(0xCAFE), 1e18, block.timestamp, v, r, s); + token.permit(owner, address(0xCAFE), 1e18, block.timestamp, v, r, s); + } + + function testMetadata(string calldata name, string calldata symbol, uint8 decimals) public { + Token_ERC20 tkn = new Token_ERC20(name, symbol, decimals); + assertEq(tkn.name(), name); + assertEq(tkn.symbol(), symbol); + assertEq(tkn.decimals(), decimals); + } + + function testMint(address from, uint256 amount) public { + token.mint(from, amount); + + assertEq(token.totalSupply(), amount); + assertEq(token.balanceOf(from), amount); + } + + function testBurn(address from, uint256 mintAmount, uint256 burnAmount) public { + burnAmount = bound(burnAmount, 0, mintAmount); + + token.mint(from, mintAmount); + token.burn(from, burnAmount); + + assertEq(token.totalSupply(), mintAmount - burnAmount); + assertEq(token.balanceOf(from), mintAmount - burnAmount); + } + + function testApprove(address to, uint256 amount) public { + assertTrue(token.approve(to, amount)); + + assertEq(token.allowance(address(this), to), amount); + } + + function testTransfer(address from, uint256 amount) public { + token.mint(address(this), amount); + + assertTrue(token.transfer(from, amount)); + assertEq(token.totalSupply(), amount); + + if (address(this) == from) { + assertEq(token.balanceOf(address(this)), amount); + } else { + assertEq(token.balanceOf(address(this)), 0); + assertEq(token.balanceOf(from), amount); + } + } + + function testTransferFrom(address to, uint256 approval, uint256 amount) public { + amount = bound(amount, 0, approval); + + address from = address(0xABCD); + + token.mint(from, amount); + + vm.prank(from); + token.approve(address(this), approval); + + assertTrue(token.transferFrom(from, to, amount)); + assertEq(token.totalSupply(), amount); + + uint256 app = from == address(this) || approval == type(uint256).max ? approval : approval - amount; + assertEq(token.allowance(from, address(this)), app); + + if (from == to) { + assertEq(token.balanceOf(from), amount); + } else { + assertEq(token.balanceOf(from), 0); + assertEq(token.balanceOf(to), amount); + } + } + + function testPermit(uint248 privKey, address to, uint256 amount, uint256 deadline) public { + uint256 privateKey = privKey; + if (deadline < block.timestamp) deadline = block.timestamp; + if (privateKey == 0) privateKey = 1; + + address owner = vm.addr(privateKey); + + (uint8 v, bytes32 r, bytes32 s) = vm.sign( + privateKey, + keccak256( + abi.encodePacked( + "\x19\x01", + token.DOMAIN_SEPARATOR(), + keccak256(abi.encode(PERMIT_TYPEHASH, owner, to, amount, 0, deadline)) + ) + ) + ); + + token.permit(owner, to, amount, deadline, v, r, s); + + assertEq(token.allowance(owner, to), amount); + assertEq(token.nonces(owner), 1); + } + + function testFailBurnInsufficientBalance(address to, uint256 mintAmount, uint256 burnAmount) public { + burnAmount = bound(burnAmount, mintAmount + 1, type(uint256).max); + + token.mint(to, mintAmount); + token.burn(to, burnAmount); + } + + function testFailTransferInsufficientBalance(address to, uint256 mintAmount, uint256 sendAmount) public { + sendAmount = bound(sendAmount, mintAmount + 1, type(uint256).max); + + token.mint(address(this), mintAmount); + token.transfer(to, sendAmount); + } + + function testFailTransferFromInsufficientAllowance(address to, uint256 approval, uint256 amount) public { + amount = bound(amount, approval + 1, type(uint256).max); + + address from = address(0xABCD); + + token.mint(from, amount); + + vm.prank(from); + token.approve(address(this), approval); + + token.transferFrom(from, to, amount); + } + + function testFailTransferFromInsufficientBalance(address to, uint256 mintAmount, uint256 sendAmount) public { + sendAmount = bound(sendAmount, mintAmount + 1, type(uint256).max); + + address from = address(0xABCD); + + token.mint(from, mintAmount); + + vm.prank(from); + token.approve(address(this), sendAmount); + + token.transferFrom(from, to, sendAmount); + } + + function testFailPermitBadNonce(uint256 privateKey, address to, uint256 amount, uint256 deadline, uint256 nonce) + public + { + if (deadline < block.timestamp) deadline = block.timestamp; + if (privateKey == 0) privateKey = 1; + if (nonce == 0) nonce = 1; + + address owner = vm.addr(privateKey); + + (uint8 v, bytes32 r, bytes32 s) = vm.sign( + privateKey, + keccak256( + abi.encodePacked( + "\x19\x01", + token.DOMAIN_SEPARATOR(), + keccak256(abi.encode(PERMIT_TYPEHASH, owner, to, amount, nonce, deadline)) + ) + ) + ); + + token.permit(owner, to, amount, deadline, v, r, s); + } + + function testFailPermitBadDeadline(uint256 privateKey, address to, uint256 amount, uint256 deadline) public { + if (deadline < block.timestamp) deadline = block.timestamp; + if (privateKey == 0) privateKey = 1; + + address owner = vm.addr(privateKey); + + (uint8 v, bytes32 r, bytes32 s) = vm.sign( + privateKey, + keccak256( + abi.encodePacked( + "\x19\x01", + token.DOMAIN_SEPARATOR(), + keccak256(abi.encode(PERMIT_TYPEHASH, owner, to, amount, 0, deadline)) + ) + ) + ); + + token.permit(owner, to, amount, deadline + 1, v, r, s); + } + + function testFailPermitPastDeadline(uint256 privateKey, address to, uint256 amount, uint256 deadline) public { + deadline = bound(deadline, 0, block.timestamp - 1); + if (privateKey == 0) privateKey = 1; + + address owner = vm.addr(privateKey); + + (uint8 v, bytes32 r, bytes32 s) = vm.sign( + privateKey, + keccak256( + abi.encodePacked( + "\x19\x01", + token.DOMAIN_SEPARATOR(), + keccak256(abi.encode(PERMIT_TYPEHASH, owner, to, amount, 0, deadline)) + ) + ) + ); + + token.permit(owner, to, amount, deadline, v, r, s); + } + + function testFailPermitReplay(uint256 privateKey, address to, uint256 amount, uint256 deadline) public { + if (deadline < block.timestamp) deadline = block.timestamp; + if (privateKey == 0) privateKey = 1; + + address owner = vm.addr(privateKey); + + (uint8 v, bytes32 r, bytes32 s) = vm.sign( + privateKey, + keccak256( + abi.encodePacked( + "\x19\x01", + token.DOMAIN_SEPARATOR(), + keccak256(abi.encode(PERMIT_TYPEHASH, owner, to, amount, 0, deadline)) + ) + ) + ); + + token.permit(owner, to, amount, deadline, v, r, s); + token.permit(owner, to, amount, deadline, v, r, s); + } +} diff --git a/docs/crypto/zkCTF/day1/Ethereal/mint-contracts/lib/forge-std/test/mocks/MockERC721.t.sol b/docs/crypto/zkCTF/day1/Ethereal/mint-contracts/lib/forge-std/test/mocks/MockERC721.t.sol new file mode 100644 index 0000000..3bf84c9 --- /dev/null +++ b/docs/crypto/zkCTF/day1/Ethereal/mint-contracts/lib/forge-std/test/mocks/MockERC721.t.sol @@ -0,0 +1,721 @@ +// SPDX-License-Identifier: MIT +pragma solidity >=0.7.0 <0.9.0; + +import {MockERC721, IERC721TokenReceiver} from "../../src/mocks/MockERC721.sol"; +import {StdCheats} from "../../src/StdCheats.sol"; +import {Test} from "../../src/Test.sol"; + +contract ERC721Recipient is IERC721TokenReceiver { + address public operator; + address public from; + uint256 public id; + bytes public data; + + function onERC721Received(address _operator, address _from, uint256 _id, bytes calldata _data) + public + virtual + override + returns (bytes4) + { + operator = _operator; + from = _from; + id = _id; + data = _data; + + return IERC721TokenReceiver.onERC721Received.selector; + } +} + +contract RevertingERC721Recipient is IERC721TokenReceiver { + function onERC721Received(address, address, uint256, bytes calldata) public virtual override returns (bytes4) { + revert(string(abi.encodePacked(IERC721TokenReceiver.onERC721Received.selector))); + } +} + +contract WrongReturnDataERC721Recipient is IERC721TokenReceiver { + function onERC721Received(address, address, uint256, bytes calldata) public virtual override returns (bytes4) { + return 0xCAFEBEEF; + } +} + +contract NonERC721Recipient {} + +contract Token_ERC721 is MockERC721 { + constructor(string memory _name, string memory _symbol) { + initialize(_name, _symbol); + } + + function tokenURI(uint256) public pure virtual override returns (string memory) {} + + function mint(address to, uint256 tokenId) public virtual { + _mint(to, tokenId); + } + + function burn(uint256 tokenId) public virtual { + _burn(tokenId); + } + + function safeMint(address to, uint256 tokenId) public virtual { + _safeMint(to, tokenId); + } + + function safeMint(address to, uint256 tokenId, bytes memory data) public virtual { + _safeMint(to, tokenId, data); + } +} + +contract MockERC721Test is StdCheats, Test { + Token_ERC721 token; + + function setUp() public { + token = new Token_ERC721("Token", "TKN"); + } + + function invariantMetadata() public { + assertEq(token.name(), "Token"); + assertEq(token.symbol(), "TKN"); + } + + function testMint() public { + token.mint(address(0xBEEF), 1337); + + assertEq(token.balanceOf(address(0xBEEF)), 1); + assertEq(token.ownerOf(1337), address(0xBEEF)); + } + + function testBurn() public { + token.mint(address(0xBEEF), 1337); + token.burn(1337); + + assertEq(token.balanceOf(address(0xBEEF)), 0); + + vm.expectRevert("NOT_MINTED"); + token.ownerOf(1337); + } + + function testApprove() public { + token.mint(address(this), 1337); + + token.approve(address(0xBEEF), 1337); + + assertEq(token.getApproved(1337), address(0xBEEF)); + } + + function testApproveBurn() public { + token.mint(address(this), 1337); + + token.approve(address(0xBEEF), 1337); + + token.burn(1337); + + assertEq(token.balanceOf(address(this)), 0); + assertEq(token.getApproved(1337), address(0)); + + vm.expectRevert("NOT_MINTED"); + token.ownerOf(1337); + } + + function testApproveAll() public { + token.setApprovalForAll(address(0xBEEF), true); + + assertTrue(token.isApprovedForAll(address(this), address(0xBEEF))); + } + + function testTransferFrom() public { + address from = address(0xABCD); + + token.mint(from, 1337); + + vm.prank(from); + token.approve(address(this), 1337); + + token.transferFrom(from, address(0xBEEF), 1337); + + assertEq(token.getApproved(1337), address(0)); + assertEq(token.ownerOf(1337), address(0xBEEF)); + assertEq(token.balanceOf(address(0xBEEF)), 1); + assertEq(token.balanceOf(from), 0); + } + + function testTransferFromSelf() public { + token.mint(address(this), 1337); + + token.transferFrom(address(this), address(0xBEEF), 1337); + + assertEq(token.getApproved(1337), address(0)); + assertEq(token.ownerOf(1337), address(0xBEEF)); + assertEq(token.balanceOf(address(0xBEEF)), 1); + assertEq(token.balanceOf(address(this)), 0); + } + + function testTransferFromApproveAll() public { + address from = address(0xABCD); + + token.mint(from, 1337); + + vm.prank(from); + token.setApprovalForAll(address(this), true); + + token.transferFrom(from, address(0xBEEF), 1337); + + assertEq(token.getApproved(1337), address(0)); + assertEq(token.ownerOf(1337), address(0xBEEF)); + assertEq(token.balanceOf(address(0xBEEF)), 1); + assertEq(token.balanceOf(from), 0); + } + + function testSafeTransferFromToEOA() public { + address from = address(0xABCD); + + token.mint(from, 1337); + + vm.prank(from); + token.setApprovalForAll(address(this), true); + + token.safeTransferFrom(from, address(0xBEEF), 1337); + + assertEq(token.getApproved(1337), address(0)); + assertEq(token.ownerOf(1337), address(0xBEEF)); + assertEq(token.balanceOf(address(0xBEEF)), 1); + assertEq(token.balanceOf(from), 0); + } + + function testSafeTransferFromToERC721Recipient() public { + address from = address(0xABCD); + ERC721Recipient recipient = new ERC721Recipient(); + + token.mint(from, 1337); + + vm.prank(from); + token.setApprovalForAll(address(this), true); + + token.safeTransferFrom(from, address(recipient), 1337); + + assertEq(token.getApproved(1337), address(0)); + assertEq(token.ownerOf(1337), address(recipient)); + assertEq(token.balanceOf(address(recipient)), 1); + assertEq(token.balanceOf(from), 0); + + assertEq(recipient.operator(), address(this)); + assertEq(recipient.from(), from); + assertEq(recipient.id(), 1337); + assertEq(recipient.data(), ""); + } + + function testSafeTransferFromToERC721RecipientWithData() public { + address from = address(0xABCD); + ERC721Recipient recipient = new ERC721Recipient(); + + token.mint(from, 1337); + + vm.prank(from); + token.setApprovalForAll(address(this), true); + + token.safeTransferFrom(from, address(recipient), 1337, "testing 123"); + + assertEq(token.getApproved(1337), address(0)); + assertEq(token.ownerOf(1337), address(recipient)); + assertEq(token.balanceOf(address(recipient)), 1); + assertEq(token.balanceOf(from), 0); + + assertEq(recipient.operator(), address(this)); + assertEq(recipient.from(), from); + assertEq(recipient.id(), 1337); + assertEq(recipient.data(), "testing 123"); + } + + function testSafeMintToEOA() public { + token.safeMint(address(0xBEEF), 1337); + + assertEq(token.ownerOf(1337), address(address(0xBEEF))); + assertEq(token.balanceOf(address(address(0xBEEF))), 1); + } + + function testSafeMintToERC721Recipient() public { + ERC721Recipient to = new ERC721Recipient(); + + token.safeMint(address(to), 1337); + + assertEq(token.ownerOf(1337), address(to)); + assertEq(token.balanceOf(address(to)), 1); + + assertEq(to.operator(), address(this)); + assertEq(to.from(), address(0)); + assertEq(to.id(), 1337); + assertEq(to.data(), ""); + } + + function testSafeMintToERC721RecipientWithData() public { + ERC721Recipient to = new ERC721Recipient(); + + token.safeMint(address(to), 1337, "testing 123"); + + assertEq(token.ownerOf(1337), address(to)); + assertEq(token.balanceOf(address(to)), 1); + + assertEq(to.operator(), address(this)); + assertEq(to.from(), address(0)); + assertEq(to.id(), 1337); + assertEq(to.data(), "testing 123"); + } + + function testFailMintToZero() public { + token.mint(address(0), 1337); + } + + function testFailDoubleMint() public { + token.mint(address(0xBEEF), 1337); + token.mint(address(0xBEEF), 1337); + } + + function testFailBurnUnMinted() public { + token.burn(1337); + } + + function testFailDoubleBurn() public { + token.mint(address(0xBEEF), 1337); + + token.burn(1337); + token.burn(1337); + } + + function testFailApproveUnMinted() public { + token.approve(address(0xBEEF), 1337); + } + + function testFailApproveUnAuthorized() public { + token.mint(address(0xCAFE), 1337); + + token.approve(address(0xBEEF), 1337); + } + + function testFailTransferFromUnOwned() public { + token.transferFrom(address(0xFEED), address(0xBEEF), 1337); + } + + function testFailTransferFromWrongFrom() public { + token.mint(address(0xCAFE), 1337); + + token.transferFrom(address(0xFEED), address(0xBEEF), 1337); + } + + function testFailTransferFromToZero() public { + token.mint(address(this), 1337); + + token.transferFrom(address(this), address(0), 1337); + } + + function testFailTransferFromNotOwner() public { + token.mint(address(0xFEED), 1337); + + token.transferFrom(address(0xFEED), address(0xBEEF), 1337); + } + + function testFailSafeTransferFromToNonERC721Recipient() public { + token.mint(address(this), 1337); + + token.safeTransferFrom(address(this), address(new NonERC721Recipient()), 1337); + } + + function testFailSafeTransferFromToNonERC721RecipientWithData() public { + token.mint(address(this), 1337); + + token.safeTransferFrom(address(this), address(new NonERC721Recipient()), 1337, "testing 123"); + } + + function testFailSafeTransferFromToRevertingERC721Recipient() public { + token.mint(address(this), 1337); + + token.safeTransferFrom(address(this), address(new RevertingERC721Recipient()), 1337); + } + + function testFailSafeTransferFromToRevertingERC721RecipientWithData() public { + token.mint(address(this), 1337); + + token.safeTransferFrom(address(this), address(new RevertingERC721Recipient()), 1337, "testing 123"); + } + + function testFailSafeTransferFromToERC721RecipientWithWrongReturnData() public { + token.mint(address(this), 1337); + + token.safeTransferFrom(address(this), address(new WrongReturnDataERC721Recipient()), 1337); + } + + function testFailSafeTransferFromToERC721RecipientWithWrongReturnDataWithData() public { + token.mint(address(this), 1337); + + token.safeTransferFrom(address(this), address(new WrongReturnDataERC721Recipient()), 1337, "testing 123"); + } + + function testFailSafeMintToNonERC721Recipient() public { + token.safeMint(address(new NonERC721Recipient()), 1337); + } + + function testFailSafeMintToNonERC721RecipientWithData() public { + token.safeMint(address(new NonERC721Recipient()), 1337, "testing 123"); + } + + function testFailSafeMintToRevertingERC721Recipient() public { + token.safeMint(address(new RevertingERC721Recipient()), 1337); + } + + function testFailSafeMintToRevertingERC721RecipientWithData() public { + token.safeMint(address(new RevertingERC721Recipient()), 1337, "testing 123"); + } + + function testFailSafeMintToERC721RecipientWithWrongReturnData() public { + token.safeMint(address(new WrongReturnDataERC721Recipient()), 1337); + } + + function testFailSafeMintToERC721RecipientWithWrongReturnDataWithData() public { + token.safeMint(address(new WrongReturnDataERC721Recipient()), 1337, "testing 123"); + } + + function testFailBalanceOfZeroAddress() public view { + token.balanceOf(address(0)); + } + + function testFailOwnerOfUnminted() public view { + token.ownerOf(1337); + } + + function testMetadata(string memory name, string memory symbol) public { + MockERC721 tkn = new Token_ERC721(name, symbol); + + assertEq(tkn.name(), name); + assertEq(tkn.symbol(), symbol); + } + + function testMint(address to, uint256 id) public { + if (to == address(0)) to = address(0xBEEF); + + token.mint(to, id); + + assertEq(token.balanceOf(to), 1); + assertEq(token.ownerOf(id), to); + } + + function testBurn(address to, uint256 id) public { + if (to == address(0)) to = address(0xBEEF); + + token.mint(to, id); + token.burn(id); + + assertEq(token.balanceOf(to), 0); + + vm.expectRevert("NOT_MINTED"); + token.ownerOf(id); + } + + function testApprove(address to, uint256 id) public { + if (to == address(0)) to = address(0xBEEF); + + token.mint(address(this), id); + + token.approve(to, id); + + assertEq(token.getApproved(id), to); + } + + function testApproveBurn(address to, uint256 id) public { + token.mint(address(this), id); + + token.approve(address(to), id); + + token.burn(id); + + assertEq(token.balanceOf(address(this)), 0); + assertEq(token.getApproved(id), address(0)); + + vm.expectRevert("NOT_MINTED"); + token.ownerOf(id); + } + + function testApproveAll(address to, bool approved) public { + token.setApprovalForAll(to, approved); + + assertEq(token.isApprovedForAll(address(this), to), approved); + } + + function testTransferFrom(uint256 id, address to) public { + address from = address(0xABCD); + + if (to == address(0) || to == from) to = address(0xBEEF); + + token.mint(from, id); + + vm.prank(from); + token.approve(address(this), id); + + token.transferFrom(from, to, id); + + assertEq(token.getApproved(id), address(0)); + assertEq(token.ownerOf(id), to); + assertEq(token.balanceOf(to), 1); + assertEq(token.balanceOf(from), 0); + } + + function testTransferFromSelf(uint256 id, address to) public { + if (to == address(0) || to == address(this)) to = address(0xBEEF); + + token.mint(address(this), id); + + token.transferFrom(address(this), to, id); + + assertEq(token.getApproved(id), address(0)); + assertEq(token.ownerOf(id), to); + assertEq(token.balanceOf(to), 1); + assertEq(token.balanceOf(address(this)), 0); + } + + function testTransferFromApproveAll(uint256 id, address to) public { + address from = address(0xABCD); + + if (to == address(0) || to == from) to = address(0xBEEF); + + token.mint(from, id); + + vm.prank(from); + token.setApprovalForAll(address(this), true); + + token.transferFrom(from, to, id); + + assertEq(token.getApproved(id), address(0)); + assertEq(token.ownerOf(id), to); + assertEq(token.balanceOf(to), 1); + assertEq(token.balanceOf(from), 0); + } + + function testSafeTransferFromToEOA(uint256 id, address to) public { + address from = address(0xABCD); + + if (to == address(0) || to == from) to = address(0xBEEF); + + if (uint256(uint160(to)) <= 18 || to.code.length > 0) return; + + token.mint(from, id); + + vm.prank(from); + token.setApprovalForAll(address(this), true); + + token.safeTransferFrom(from, to, id); + + assertEq(token.getApproved(id), address(0)); + assertEq(token.ownerOf(id), to); + assertEq(token.balanceOf(to), 1); + assertEq(token.balanceOf(from), 0); + } + + function testSafeTransferFromToERC721Recipient(uint256 id) public { + address from = address(0xABCD); + + ERC721Recipient recipient = new ERC721Recipient(); + + token.mint(from, id); + + vm.prank(from); + token.setApprovalForAll(address(this), true); + + token.safeTransferFrom(from, address(recipient), id); + + assertEq(token.getApproved(id), address(0)); + assertEq(token.ownerOf(id), address(recipient)); + assertEq(token.balanceOf(address(recipient)), 1); + assertEq(token.balanceOf(from), 0); + + assertEq(recipient.operator(), address(this)); + assertEq(recipient.from(), from); + assertEq(recipient.id(), id); + assertEq(recipient.data(), ""); + } + + function testSafeTransferFromToERC721RecipientWithData(uint256 id, bytes calldata data) public { + address from = address(0xABCD); + ERC721Recipient recipient = new ERC721Recipient(); + + token.mint(from, id); + + vm.prank(from); + token.setApprovalForAll(address(this), true); + + token.safeTransferFrom(from, address(recipient), id, data); + + assertEq(token.getApproved(id), address(0)); + assertEq(token.ownerOf(id), address(recipient)); + assertEq(token.balanceOf(address(recipient)), 1); + assertEq(token.balanceOf(from), 0); + + assertEq(recipient.operator(), address(this)); + assertEq(recipient.from(), from); + assertEq(recipient.id(), id); + assertEq(recipient.data(), data); + } + + function testSafeMintToEOA(uint256 id, address to) public { + if (to == address(0)) to = address(0xBEEF); + + if (uint256(uint160(to)) <= 18 || to.code.length > 0) return; + + token.safeMint(to, id); + + assertEq(token.ownerOf(id), address(to)); + assertEq(token.balanceOf(address(to)), 1); + } + + function testSafeMintToERC721Recipient(uint256 id) public { + ERC721Recipient to = new ERC721Recipient(); + + token.safeMint(address(to), id); + + assertEq(token.ownerOf(id), address(to)); + assertEq(token.balanceOf(address(to)), 1); + + assertEq(to.operator(), address(this)); + assertEq(to.from(), address(0)); + assertEq(to.id(), id); + assertEq(to.data(), ""); + } + + function testSafeMintToERC721RecipientWithData(uint256 id, bytes calldata data) public { + ERC721Recipient to = new ERC721Recipient(); + + token.safeMint(address(to), id, data); + + assertEq(token.ownerOf(id), address(to)); + assertEq(token.balanceOf(address(to)), 1); + + assertEq(to.operator(), address(this)); + assertEq(to.from(), address(0)); + assertEq(to.id(), id); + assertEq(to.data(), data); + } + + function testFailMintToZero(uint256 id) public { + token.mint(address(0), id); + } + + function testFailDoubleMint(uint256 id, address to) public { + if (to == address(0)) to = address(0xBEEF); + + token.mint(to, id); + token.mint(to, id); + } + + function testFailBurnUnMinted(uint256 id) public { + token.burn(id); + } + + function testFailDoubleBurn(uint256 id, address to) public { + if (to == address(0)) to = address(0xBEEF); + + token.mint(to, id); + + token.burn(id); + token.burn(id); + } + + function testFailApproveUnMinted(uint256 id, address to) public { + token.approve(to, id); + } + + function testFailApproveUnAuthorized(address owner, uint256 id, address to) public { + if (owner == address(0) || owner == address(this)) owner = address(0xBEEF); + + token.mint(owner, id); + + token.approve(to, id); + } + + function testFailTransferFromUnOwned(address from, address to, uint256 id) public { + token.transferFrom(from, to, id); + } + + function testFailTransferFromWrongFrom(address owner, address from, address to, uint256 id) public { + if (owner == address(0)) to = address(0xBEEF); + if (from == owner) revert(); + + token.mint(owner, id); + + token.transferFrom(from, to, id); + } + + function testFailTransferFromToZero(uint256 id) public { + token.mint(address(this), id); + + token.transferFrom(address(this), address(0), id); + } + + function testFailTransferFromNotOwner(address from, address to, uint256 id) public { + if (from == address(this)) from = address(0xBEEF); + + token.mint(from, id); + + token.transferFrom(from, to, id); + } + + function testFailSafeTransferFromToNonERC721Recipient(uint256 id) public { + token.mint(address(this), id); + + token.safeTransferFrom(address(this), address(new NonERC721Recipient()), id); + } + + function testFailSafeTransferFromToNonERC721RecipientWithData(uint256 id, bytes calldata data) public { + token.mint(address(this), id); + + token.safeTransferFrom(address(this), address(new NonERC721Recipient()), id, data); + } + + function testFailSafeTransferFromToRevertingERC721Recipient(uint256 id) public { + token.mint(address(this), id); + + token.safeTransferFrom(address(this), address(new RevertingERC721Recipient()), id); + } + + function testFailSafeTransferFromToRevertingERC721RecipientWithData(uint256 id, bytes calldata data) public { + token.mint(address(this), id); + + token.safeTransferFrom(address(this), address(new RevertingERC721Recipient()), id, data); + } + + function testFailSafeTransferFromToERC721RecipientWithWrongReturnData(uint256 id) public { + token.mint(address(this), id); + + token.safeTransferFrom(address(this), address(new WrongReturnDataERC721Recipient()), id); + } + + function testFailSafeTransferFromToERC721RecipientWithWrongReturnDataWithData(uint256 id, bytes calldata data) + public + { + token.mint(address(this), id); + + token.safeTransferFrom(address(this), address(new WrongReturnDataERC721Recipient()), id, data); + } + + function testFailSafeMintToNonERC721Recipient(uint256 id) public { + token.safeMint(address(new NonERC721Recipient()), id); + } + + function testFailSafeMintToNonERC721RecipientWithData(uint256 id, bytes calldata data) public { + token.safeMint(address(new NonERC721Recipient()), id, data); + } + + function testFailSafeMintToRevertingERC721Recipient(uint256 id) public { + token.safeMint(address(new RevertingERC721Recipient()), id); + } + + function testFailSafeMintToRevertingERC721RecipientWithData(uint256 id, bytes calldata data) public { + token.safeMint(address(new RevertingERC721Recipient()), id, data); + } + + function testFailSafeMintToERC721RecipientWithWrongReturnData(uint256 id) public { + token.safeMint(address(new WrongReturnDataERC721Recipient()), id); + } + + function testFailSafeMintToERC721RecipientWithWrongReturnDataWithData(uint256 id, bytes calldata data) public { + token.safeMint(address(new WrongReturnDataERC721Recipient()), id, data); + } + + function testFailOwnerOfUnminted(uint256 id) public view { + token.ownerOf(id); + } +} diff --git a/docs/crypto/zkCTF/day1/Ethereal/mint-contracts/script/Counter.s.sol b/docs/crypto/zkCTF/day1/Ethereal/mint-contracts/script/Counter.s.sol new file mode 100644 index 0000000..1a47b40 --- /dev/null +++ b/docs/crypto/zkCTF/day1/Ethereal/mint-contracts/script/Counter.s.sol @@ -0,0 +1,12 @@ +// SPDX-License-Identifier: UNLICENSED +pragma solidity ^0.8.13; + +import {Script, console2} from "forge-std/Script.sol"; + +contract CounterScript is Script { + function setUp() public {} + + function run() public { + vm.broadcast(); + } +} diff --git a/docs/crypto/zkCTF/day1/Ethereal/mint-contracts/src/Constants.sol b/docs/crypto/zkCTF/day1/Ethereal/mint-contracts/src/Constants.sol new file mode 100644 index 0000000..a885e1e --- /dev/null +++ b/docs/crypto/zkCTF/day1/Ethereal/mint-contracts/src/Constants.sol @@ -0,0 +1,72 @@ +// Modified from https://github.com/weijiekoh/libkzg +pragma solidity ^0.8.15; + +import "./Pairing.sol"; + +contract Constants { + using Pairing for *; + + uint256 constant PRIME_Q = 21888242871839275222246405745257275088696311157297823662689037894645226208583; + uint256 constant PRIME_R = 21888242871839275222246405745257275088548364400416034343698204186575808495617; + uint256 constant bn254_b_coeff = 3; + + uint256[] public SRS_G1_X = [ + uint256(0x0000000000000000000000000000000000000000000000000000000000000001), + uint256(0x2f588cffe99db877a4434b598ab28f81e0522910ea52b45f0adaa772b2d5d352), + uint256(0x0bb8ff8630fda7745aa6b57010757d357b48fbd66837605aa8a3da29633774cc), + uint256(0x29607f6f455b4a423398086598f832ad03983c040e68b1b0fb4b8e0959b59bec), + uint256(0x0efcb74f95d874e60607a4dcfb61c08782e4eb3dbfa845d9e2990660ac013949), + uint256(0x1dae94162d6148029d704cfa97285ab362e31e818108fec2296659d0e3a55dd8), + uint256(0x144e236047d637449d381cbacfc5bee0497d0bef615b5fdc4844c7f724c8a77b), + uint256(0x1de1f562998d28c9d22782a2d6bad6cbc728d066032fede32bef97b2bc484e9b), + uint256(0x06706750845bbdefe571c69eef645e64488a1f224b5b41c49f96978b20581041), + uint256(0x2d6200419fad7815715e10f8c5a198d5032ca7bec7a4ea8f24dee5d720b2707f), + uint256(0x09511ec02cda1449a763758003afce9eab83e576b2ea1e803cb2a12650bf787c), + uint256(0x287a4e5b49fab4b3fdcea668678da26436ae201f21ef202e456f9d7b16a86a90), + uint256(0x06d61cedd23e349f55a11ffd447701cdf1d00d3a242177acb0d9c554ee799a9d), + uint256(0x097719abf0c65d4367e02741b4b989734285691ca20e7d1b1a7ef186dc0ab69c), + uint256(0x2cbee87ccdf52205005e5a9a0ce862974dd00662d57fc9d0674102f982df4a45), + uint256(0x0df9fdbb15f99ce4a0c9a8a5280b5878f21737ef27b5fcf3c7ad88ac715d19a0), + uint256(0x1800977bc4b748112c1d924770667d916d90679cfdba41fcea37bf75b9b11ebf) + ]; + + uint256[] public SRS_G1_Y = [ + uint256(0x0000000000000000000000000000000000000000000000000000000000000002), + uint256(0x12f42fa8fd34fb1b33d8c6a718b6590198389b26fc9d8808d971f8b009777a97), + uint256(0x1bbac0306fbe3079ca1caa6f2dafa1cbb1ad970cd019021973da1182ad544c37), + uint256(0x084c6e708ce5df57c4772f98c42dbab136b4cab92b6f17850b9a8f7f0eb19e14), + uint256(0x069617913a37bb74d9ef323d5ce028760c5c672e0025a0a48caf139b32dc70f1), + uint256(0x1dc1975e72b50e62faa67812c42b3e4b0f32273c27b81b38097a3506d2d89b83), + uint256(0x04e34c9484b9885fb074403489a7ec8ecd6d8ab6cb9a00135ce134801a29aa18), + uint256(0x15fa11654eff9029eb8534944a12fef90adba876f37d25046ed23662040e2ee3), + uint256(0x13aeb0921d07cc49ce2bfdf8aabf28e85a3e73bd8e92cdbd7c28c0ef2151999d), + uint256(0x167f03b2bb8cc583a5b880850c0439730cb723f3c9595415f354cacb23dcb724), + uint256(0x04b7796ae07a9642905bdb090e7ad61c328f6b3f5fa070f0c96eb847f47075ac), + uint256(0x23de253b9bc2727af92a66746a70960e3566faf37196bbd94cc2bd1dd9959584), + uint256(0x2d0725bdca137e2c0b1dfaf403beb37a0374d4ab8ce773ab962a259c9f4679e4), + uint256(0x1f4d3f8d3105e06a7710366a36c0d60ae52eb2e263dff04adcb8f711ee9e1fa2), + uint256(0x119c1bb670262cb76aaab5f3a996643c16efd80da02f2a35fb81747f1ebe5c97), + uint256(0x05e1ab74d9103a916de3011e6f908e7bba7e63d31e73955e5cee893e345638d2), + uint256(0x141b05faf7ea69cc972ea80101fb12e975d4a90679715a714171fa98393ab5ab) + ]; + + uint256[] public SRS_G2_X_0 = [ + uint256(0x198e9393920d483a7260bfb731fb5d25f1aa493335a9e71297e485b7aef312c2), + uint256(0x18c1beedba41ddf9af588015b878aca9dc39ab7c42f25492229ae1796076ab3f) + ]; + + uint256[] public SRS_G2_X_1 = [ + uint256(0x1800deef121f1e76426a00665e5c4479674322d4f75edadd46debd5cd992f6ed), + uint256(0x2fca16fc43f7283679e062bfc2bbf54f708772c60b0f4b45358613c3eca37113) + ]; + + uint256[] public SRS_G2_Y_0 = [ + uint256(0x090689d0585ff075ec9e99ad690c3395bc4b313370b38ef355acdadcd122975b), + uint256(0x2c64a7dba9f4202c9a4bd4089bcf281c4c7c90c80efa266bbb36256e82047ceb) + ]; + + uint256[] public SRS_G2_Y_1 = [ + uint256(0x12c85ea5db8c6deb4aab71808dcb408fe3d1e7690c43d37b4ce6cc0166fa7daa), + uint256(0x1edc0a927e4e6907abe201f714d3d89d7f0dbb7001293d37ff1233d208208404) + ]; +} diff --git a/docs/crypto/zkCTF/day1/Ethereal/mint-contracts/src/KZGVerifier.sol b/docs/crypto/zkCTF/day1/Ethereal/mint-contracts/src/KZGVerifier.sol new file mode 100644 index 0000000..f031b57 --- /dev/null +++ b/docs/crypto/zkCTF/day1/Ethereal/mint-contracts/src/KZGVerifier.sol @@ -0,0 +1,198 @@ +// Modified from https://github.com/weijiekoh/libkzg +// Modified from https://github.com/appliedzkp/semaphore/blob/master/contracts/sol/verifier.sol +pragma experimental ABIEncoderV2; +pragma solidity ^0.8.15; + +import "./Pairing.sol"; +import { Constants } from "./Constants.sol"; + +contract Verifier is Constants { + + using Pairing for *; + + // The G1 generator + Pairing.G1Point SRS_G1_0 = Pairing.G1Point({ + X: Constants.SRS_G1_X[0], + Y: Constants.SRS_G1_Y[0] + }); + + // The G2 generator + Pairing.G2Point g2Generator = Pairing.G2Point({ + X: [ Constants.SRS_G2_X_0[0], Constants.SRS_G2_X_1[0] ], + Y: [ Constants.SRS_G2_Y_0[0], Constants.SRS_G2_Y_1[0] ] + + }); + + Pairing.G2Point SRS_G2_1 = Pairing.G2Point({ + X: [ Constants.SRS_G2_X_0[1], Constants.SRS_G2_X_1[1] ], + Y: [ Constants.SRS_G2_Y_0[1], Constants.SRS_G2_Y_1[1] ] + }); + + function g1Check(Pairing.G1Point memory _point) internal pure + { + require(_point.X != 0 || _point.Y != 0, "G1 point at infinity"); + // check encoding + require(_point.X < PRIME_Q); + require(_point.Y < PRIME_Q); + // check on curve + uint256 lhs = mulmod(_point.Y, _point.Y, PRIME_Q); // y^2 + uint256 rhs = mulmod(_point.X, _point.X, PRIME_Q); // x^2 + rhs = mulmod(rhs, _point.X, PRIME_Q); // x^3 + rhs = addmod(rhs, bn254_b_coeff, PRIME_Q); // x^3 + b + require(lhs == rhs); + } + + function verify( + Pairing.G1Point memory _commitment, + Pairing.G1Point memory _proof, + uint256 _index, + uint256 _value + ) public view returns (bool) { + // Make sure each parameter is less than the prime q + g1Check(_commitment); + g1Check(_proof); + require(_index < PRIME_Q, "Verifier.verifyKZG: _index is out of range"); + require(_value < PRIME_Q, "Verifier.verifyKZG: _value is out of range"); + + // Compute commitment - aCommitment + Pairing.G1Point memory commitmentMinusA = Pairing.plus( + _commitment, + Pairing.negate( + Pairing.mulScalar(SRS_G1_0, _value) + ) + ); + + // Negate the proof + Pairing.G1Point memory negProof = Pairing.negate(_proof); + + // Compute index * proof + Pairing.G1Point memory indexMulProof = Pairing.mulScalar(_proof, _index); + + // Returns true if and only if + // e((index * proof) + (commitment - aCommitment), G2.g) * e(-proof, xCommit) == 1 + return Pairing.pairing( + Pairing.plus(indexMulProof, commitmentMinusA), + g2Generator, + negProof, + SRS_G2_1 + ); + } + + function verifySoulBox( + Pairing.G1Point memory _commitment, + Pairing.G1Point memory _proof, + Pairing.G1Point memory _soulBox + ) public view returns (bool) { + // Make sure each parameter is less than the prime q + g1Check(_commitment); + g1Check(_proof); + uint256 _index = 0; + + // Compute commitment - aCommitment + Pairing.G1Point memory commitmentMinusA = Pairing.plus( + _commitment, + Pairing.negate( + _soulBox + ) + ); + + // Negate the proof + Pairing.G1Point memory negProof = Pairing.negate(_proof); + + // Compute index * proof + Pairing.G1Point memory indexMulProof = Pairing.mulScalar(_proof, _index); + + // Returns true if and only if + // e((index * proof) + (commitment - aCommitment), G2.g) * e(-proof, xCommit) == 1 + return Pairing.pairing( + Pairing.plus(indexMulProof, commitmentMinusA), + g2Generator, + negProof, + SRS_G2_1 + ); + } + + function fr_inverse(uint256 a) internal view returns (uint256) { + require(a != 0, "Division by zero"); + return fr_pow(a, Constants.PRIME_R - 2); + } + + function fr_pow(uint256 a, uint256 power) internal view returns (uint256) { + uint256[6] memory input; + uint256[1] memory result; + bool ret; + + input[0] = 32; + input[1] = 32; + input[2] = 32; + input[3] = a; + input[4] = power; + input[5] = Constants.PRIME_R; + + assembly { + ret := staticcall(gas(), 0x05, input, 0xc0, result, 0x20) + } + require(ret); + + return result[0]; + } + + function fr_div(uint256 a, uint256 b) internal view returns (uint256) { + require(b != 0); + return mulmod(a, fr_inverse(b), Constants.PRIME_R); + } + + function fr_mul_add( + uint256 a, + uint256 b, + uint256 c + ) internal pure returns (uint256) { + return addmod(mulmod(a, b, Constants.PRIME_R), c, Constants.PRIME_R); + } + + // Function to calculate barycentric weights + function getBarycentricWeights(uint256[] memory xValues) public view returns (uint256[] memory) { + uint256 m = Constants.PRIME_R; + uint256 n = xValues.length; + uint256[] memory weights = new uint256[](n); + + for (uint256 i = 0; i < n; i++) { + weights[i] = 1; + for (uint256 j = 0; j < n; j++) { + if (i != j) { + uint256 difference = addmod(xValues[i], m - xValues[j], m); + weights[i] = mulmod(weights[i], difference, m); + } + } + weights[i] = fr_div(1, weights[i]); + } + + return weights; + } + + function evaluateBarycentricPolynomial(uint256 x, uint256[] memory yValues, uint256[] memory weights) public view returns (uint256) { + uint256 m = Constants.PRIME_R; + + require(yValues.length == weights.length, "Array lengths must match"); + + uint256 n = weights.length; + uint256 numerator = 0; + uint256 denominator = 0; + + for (uint256 i = 0; i < n; i++) { + if (x == (i+1)) { + return yValues[i]; + } + uint256 temp = 0; + uint256 temp2 = 0; + temp = addmod(x, m - (i+1), m); // x - xValues[i] + temp = fr_div(weights[i], temp); // weights[i] / temp + temp2 = mulmod(temp, yValues[i], m); // temp * yValues[i] + numerator = addmod(numerator, temp2, m); // numerator + temp2 + denominator = addmod(denominator, temp, m); // denominator + temp + } + + return fr_div(numerator, denominator); + } + +} diff --git a/docs/crypto/zkCTF/day1/Ethereal/mint-contracts/src/MintGem.sol b/docs/crypto/zkCTF/day1/Ethereal/mint-contracts/src/MintGem.sol new file mode 100644 index 0000000..9f95e10 --- /dev/null +++ b/docs/crypto/zkCTF/day1/Ethereal/mint-contracts/src/MintGem.sol @@ -0,0 +1,95 @@ +pragma solidity ^0.8.15; + +import "forge-std/console.sol"; +import "./KZGVerifier.sol"; + +contract Mint is Verifier { + struct DepositInfo { + bool registered; + uint256 nonce; + Pairing.G1Point commitment; + Pairing.G1Point soulBox; + uint256[] collectedY; + bool escaped0; + bool escaped1; + } + + // function is_sovled(DepositInfo info) returns (bool) { + // if(DepositInfo.escaped0 && DepositInfo escaped1) + // {return true;} + // else + // {return false;} + // } + + + function getCollectedY(address user) public view returns (uint256[] memory) { + return deposits[user].collectedY; + } + + mapping(address => DepositInfo) public deposits; + event Deposit(Pairing.G1Point indexed soulbox, Pairing.G1Point commitment,uint256 timestamp); + event Minted(address indexed user, uint256 nonce); + event Pwned(uint256 indexed privateKey); + + function register( + Pairing.G1Point calldata _commitment, + Pairing.G1Point calldata _proof, + Pairing.G1Point calldata _soulBox + ) external payable { + address sender = msg.sender; + require(!deposits[sender].registered, "User registered"); + require(verifySoulBox(_commitment, _proof, _soulBox), "Invalid soul box proof"); + deposits[sender] = DepositInfo({ + registered: true, + nonce: 1, + commitment: _commitment, + soulBox: _soulBox, + collectedY: new uint256[](0), + escaped0: false, + escaped1: false + }); + emit Deposit(_soulBox, _commitment, block.timestamp); + } + + function getNonce(address _user) public view returns (uint256) { + return deposits[_user].nonce; + } + + function mint( + Pairing.G1Point calldata _proof, + uint256 _value + ) external { + address sender = msg.sender; + uint256 nonce = getNonce(sender); + require(deposits[sender].registered, "User registered"); + require(verify(deposits[sender].commitment, _proof, nonce, _value), "Invalid mint proof"); + deposits[sender].collectedY.push(_value); + + uint256[] memory xArray = new uint256[](nonce); + for (uint256 i = 0; i < nonce; i++) { + xArray[i] = i+1; + } + uint256[] memory wArray = getBarycentricWeights(xArray); + // recover private_key = f(0) by lagrange interpolation + uint256 soul = evaluateBarycentricPolynomial(0, deposits[sender].collectedY, wArray); + Pairing.G1Point memory soulBox = Pairing.mulScalar(SRS_G1_0, soul); + require(soulBox.X != deposits[sender].soulBox.X, "Soul dispersed"); + + if(nonce == 10){ + deposits[sender].escaped0 = true; + } + if(nonce == 20){ + deposits[sender].escaped1 = true; + } + + emit Minted(sender, deposits[sender].nonce); + deposits[sender].nonce += 1; + } + + function replay() external { + address sender = msg.sender; + require(deposits[sender].registered, "User not registered"); + delete(deposits[sender]); + delete(deposits[sender].collectedY); + } +} \ No newline at end of file diff --git a/docs/crypto/zkCTF/day1/Ethereal/mint-contracts/src/Pairing.sol b/docs/crypto/zkCTF/day1/Ethereal/mint-contracts/src/Pairing.sol new file mode 100644 index 0000000..7949391 --- /dev/null +++ b/docs/crypto/zkCTF/day1/Ethereal/mint-contracts/src/Pairing.sol @@ -0,0 +1,122 @@ +// Modified from https://github.com/weijiekoh/libkzg +pragma solidity ^0.8.15; + +library Pairing { + + uint256 constant PRIME_Q = 21888242871839275222246405745257275088696311157297823662689037894645226208583; + + struct G1Point { + uint256 X; + uint256 Y; + } + + // Encoding of field elements is: X[0] * z + X[1] + struct G2Point { + uint256[2] X; + uint256[2] Y; + } + + /* + * @return The negation of p, i.e. p.plus(p.negate()) should be zero. + */ + function negate(G1Point memory p) internal pure returns (G1Point memory) { + + // The prime q in the base field F_q for G1 + if (p.X == 0 && p.Y == 0) { + return G1Point(0, 0); + } else { + return G1Point(p.X, PRIME_Q - (p.Y % PRIME_Q)); + } + } + + /* + * @return The sum of two points of G1 + */ + function plus( + G1Point memory p1, + G1Point memory p2 + ) internal view returns (G1Point memory r) { + + uint256[4] memory input; + input[0] = p1.X; + input[1] = p1.Y; + input[2] = p2.X; + input[3] = p2.Y; + bool success; + + // solium-disable-next-line security/no-inline-assembly + assembly { + success := staticcall(sub(gas(), 2000), 6, input, 0xc0, r, 0x60) + // Use "invalid" to make gas estimation work + switch success case 0 { invalid() } + } + + require(success, "pairing-add-failed"); + } + + /* + * @return The product of a point on G1 and a scalar, i.e. + * p == p.scalar_mul(1) and p.plus(p) == p.scalar_mul(2) for all + * points p. + */ + function mulScalar(G1Point memory p, uint256 s) internal view returns (G1Point memory r) { + + uint256[3] memory input; + input[0] = p.X; + input[1] = p.Y; + input[2] = s; + bool success; + // solium-disable-next-line security/no-inline-assembly + assembly { + success := staticcall(sub(gas(), 2000), 7, input, 0x80, r, 0x60) + // Use "invalid" to make gas estimation work + switch success case 0 { invalid() } + } + require (success, "pairing-mul-failed"); + } + + /* @return The result of computing the pairing check + * e(p1[0], p2[0]) * .... * e(p1[n], p2[n]) == 1 + * For example, + * pairing([P1(), P1().negate()], [P2(), P2()]) should return true. + */ + function pairing( + G1Point memory a1, + G2Point memory a2, + G1Point memory b1, + G2Point memory b2 + ) internal view returns (bool) { + + G1Point[2] memory p1 = [a1, b1]; + G2Point[2] memory p2 = [a2, b2]; + + uint256 inputSize = 12; + uint256[] memory input = new uint256[](inputSize); + + for (uint256 i = 0; i < 2; i++) { + uint256 j = i * 6; + input[j + 0] = p1[i].X; + input[j + 1] = p1[i].Y; + input[j + 2] = p2[i].X[0]; + input[j + 3] = p2[i].X[1]; + input[j + 4] = p2[i].Y[0]; + input[j + 5] = p2[i].Y[1]; + } + + uint256[1] memory out; + bool success; + + // solium-disable-next-line security/no-inline-assembly + assembly { + success := staticcall(sub(gas(), 2000), 8, add(input, 0x20), mul(inputSize, 0x20), out, 0x20) + // Use "invalid" to make gas estimation work + switch success case 0 { invalid() } + } + + require(success, "pairing-opcode-failed"); + + return out[0] != 0; + } +} + + diff --git a/docs/crypto/zkCTF/day1/Ethereal/mint-contracts/test/MintNFT.t.sol b/docs/crypto/zkCTF/day1/Ethereal/mint-contracts/test/MintNFT.t.sol new file mode 100644 index 0000000..04fd2a9 --- /dev/null +++ b/docs/crypto/zkCTF/day1/Ethereal/mint-contracts/test/MintNFT.t.sol @@ -0,0 +1,29 @@ +// SPDX-License-Identifier: UNLICENSED +pragma solidity ^0.8.13; + +import "forge-std/Test.sol"; +import "../src/MintGem.sol"; +import "../src/KZGVerifier.sol"; +import "forge-std/console.sol"; + +contract MintTest is Test, Verifier { + Mint public mint; + + function setUp() public { + mint = new Mint(); + } + + receive() external payable {} + + function testWeights() external view { + // x = uint256[1,2,3,4,5,6,7,8,9,10] + uint256[] memory x = new uint256[](10); + for (uint256 i = 0; i < 10; i++) { + x[i] = i + 1; + } + uint256[] memory weights = getBarycentricWeights(x); + console.logUint(weights[0]); + console.logUint(weights[1]); + console.logUint(weights[2]); + } +} diff --git a/docs/crypto/zkCTF/day1/Kid Math/.gitignore b/docs/crypto/zkCTF/day1/Kid Math/.gitignore new file mode 100644 index 0000000..ea8c4bf --- /dev/null +++ b/docs/crypto/zkCTF/day1/Kid Math/.gitignore @@ -0,0 +1 @@ +/target diff --git a/docs/crypto/zkCTF/day1/Kid Math/Cargo.lock b/docs/crypto/zkCTF/day1/Kid Math/Cargo.lock new file mode 100644 index 0000000..47dd7c2 --- /dev/null +++ b/docs/crypto/zkCTF/day1/Kid Math/Cargo.lock @@ -0,0 +1,1932 @@ +# This file is automatically @generated by Cargo. +# It is not intended for manual editing. +version = 3 + +[[package]] +name = "addr2line" +version = "0.21.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8a30b2e23b9e17a9f90641c7ab1549cd9b44f296d3ccbf309d2863cfe398a0cb" +dependencies = [ + "gimli", +] + +[[package]] +name = "adler" +version = "1.0.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f26201604c87b1e01bd3d98f8d5d9a8fcbb815e8cedb41ffccbeb4bf593a35fe" + +[[package]] +name = "aho-corasick" +version = "1.1.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b2969dcb958b36655471fc61f7e416fa76033bdd4bfed0678d8fee1e2d07a1f0" +dependencies = [ + "memchr", +] + +[[package]] +name = "android-tzdata" +version = "0.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e999941b234f3131b00bc13c22d06e8c5ff726d1b6318ac7eb276997bbb4fef0" + +[[package]] +name = "android_system_properties" +version = "0.1.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "819e7219dbd41043ac279b19830f2efc897156490d7fd6ea916720117ee66311" +dependencies = [ + "libc", +] + +[[package]] +name = "anyhow" +version = "1.0.77" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c9d19de80eff169429ac1e9f48fffb163916b448a44e8e046186232046d9e1f9" + +[[package]] +name = "arrayref" +version = "0.3.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6b4930d2cb77ce62f89ee5d5289b4ac049559b1c45539271f5ed4fdc7db34545" + +[[package]] +name = "arrayvec" +version = "0.7.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "96d30a06541fbafbc7f82ed10c06164cfbd2c401138f6addd8404629c4b16711" + +[[package]] +name = "async-trait" +version = "0.1.76" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "531b97fb4cd3dfdce92c35dedbfdc1f0b9d8091c8ca943d6dae340ef5012d514" +dependencies = [ + "proc-macro2", + "quote", + "syn 2.0.43", +] + +[[package]] +name = "autocfg" +version = "1.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d468802bab17cbc0cc575e9b053f41e72aa36bfa6b7f55e3529ffa43161b97fa" + +[[package]] +name = "axum" +version = "0.7.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d09dbe0e490df5da9d69b36dca48a76635288a82f92eca90024883a56202026d" +dependencies = [ + "async-trait", + "axum-core", + "bytes", + "futures-util", + "http", + "http-body", + "http-body-util", + "hyper", + "hyper-util", + "itoa", + "matchit", + "memchr", + "mime", + "percent-encoding", + "pin-project-lite", + "rustversion", + "serde", + "serde_json", + "serde_path_to_error", + "serde_urlencoded", + "sync_wrapper", + "tokio", + "tower", + "tower-layer", + "tower-service", + "tracing", +] + +[[package]] +name = "axum-core" +version = "0.4.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e87c8503f93e6d144ee5690907ba22db7ba79ab001a932ab99034f0fe836b3df" +dependencies = [ + "async-trait", + "bytes", + "futures-util", + "http", + "http-body", + "http-body-util", + "mime", + "pin-project-lite", + "rustversion", + "sync_wrapper", + "tower-layer", + "tower-service", + "tracing", +] + +[[package]] +name = "backtrace" +version = "0.3.69" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2089b7e3f35b9dd2d0ed921ead4f6d318c27680d4a5bd167b3ee120edb105837" +dependencies = [ + "addr2line", + "cc", + "cfg-if", + "libc", + "miniz_oxide", + "object", + "rustc-demangle", +] + +[[package]] +name = "bitflags" +version = "1.3.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a" + +[[package]] +name = "bitflags" +version = "2.4.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "327762f6e5a765692301e5bb513e0d9fef63be86bbc14528052b1cd3e6f03e07" + +[[package]] +name = "bitvec" +version = "1.0.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1bc2832c24239b0141d5674bb9174f9d68a8b5b3f2753311927c172ca46f7e9c" +dependencies = [ + "funty", + "radium", + "tap", + "wyz", +] + +[[package]] +name = "blake2b_simd" +version = "1.0.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "23285ad32269793932e830392f2fe2f83e26488fd3ec778883a93c8323735780" +dependencies = [ + "arrayref", + "arrayvec", + "constant_time_eq", +] + +[[package]] +name = "bumpalo" +version = "3.14.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7f30e7476521f6f8af1a1c4c0b8cc94f0bee37d91763d0ca2665f299b6cd8aec" + +[[package]] +name = "bytemuck" +version = "1.14.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "374d28ec25809ee0e23827c2ab573d729e293f281dfe393500e7ad618baa61c6" + +[[package]] +name = "byteorder" +version = "1.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1fd0f2584146f6f2ef48085050886acf353beff7305ebd1ae69500e27c67f64b" + +[[package]] +name = "bytes" +version = "1.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a2bd12c1caf447e69cd4528f47f94d203fd2582878ecb9e9465484c4148a8223" + +[[package]] +name = "cc" +version = "1.0.83" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f1174fb0b6ec23863f8b971027804a42614e347eafb0a95bf0b12cdae21fc4d0" +dependencies = [ + "libc", +] + +[[package]] +name = "cfg-if" +version = "1.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd" + +[[package]] +name = "chrono" +version = "0.4.31" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7f2c685bad3eb3d45a01354cedb7d5faa66194d1d58ba6e267a8de788f79db38" +dependencies = [ + "android-tzdata", + "iana-time-zone", + "js-sys", + "num-traits", + "wasm-bindgen", + "windows-targets", +] + +[[package]] +name = "cmake" +version = "0.1.50" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a31c789563b815f77f4250caee12365734369f942439b7defd71e18a48197130" +dependencies = [ + "cc", +] + +[[package]] +name = "color_quant" +version = "1.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3d7b894f5411737b7867f4827955924d7c254fc9f4d91a6aad6b097804b1018b" + +[[package]] +name = "const-cstr" +version = "0.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ed3d0b5ff30645a68f35ece8cea4556ca14ef8a1651455f789a099a0513532a6" + +[[package]] +name = "constant_time_eq" +version = "0.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f7144d30dcf0fafbce74250a3963025d8d52177934239851c917d29f1df280c2" + +[[package]] +name = "core-foundation" +version = "0.9.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "91e195e091a93c46f7102ec7818a2aa394e1e1771c3ab4825963fa03e45afb8f" +dependencies = [ + "core-foundation-sys", + "libc", +] + +[[package]] +name = "core-foundation-sys" +version = "0.8.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "06ea2b9bc92be3c2baa9334a323ebca2d6f074ff852cd1d7b11064035cd3868f" + +[[package]] +name = "core-graphics" +version = "0.22.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2581bbab3b8ffc6fcbd550bf46c355135d16e9ff2a6ea032ad6b9bf1d7efe4fb" +dependencies = [ + "bitflags 1.3.2", + "core-foundation", + "core-graphics-types", + "foreign-types", + "libc", +] + +[[package]] +name = "core-graphics-types" +version = "0.1.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "45390e6114f68f718cc7a830514a96f903cccd70d02a8f6d9f643ac4ba45afaf" +dependencies = [ + "bitflags 1.3.2", + "core-foundation", + "libc", +] + +[[package]] +name = "core-text" +version = "19.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "99d74ada66e07c1cefa18f8abfba765b486f250de2e4a999e5727fc0dd4b4a25" +dependencies = [ + "core-foundation", + "core-graphics", + "foreign-types", + "libc", +] + +[[package]] +name = "crc32fast" +version = "1.3.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b540bd8bc810d3885c6ea91e2018302f68baba2129ab3e88f32389ee9370880d" +dependencies = [ + "cfg-if", +] + +[[package]] +name = "crossbeam-deque" +version = "0.8.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "fca89a0e215bab21874660c67903c5f143333cab1da83d041c7ded6053774751" +dependencies = [ + "cfg-if", + "crossbeam-epoch", + "crossbeam-utils", +] + +[[package]] +name = "crossbeam-epoch" +version = "0.9.17" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0e3681d554572a651dda4186cd47240627c3d0114d45a95f6ad27f2f22e7548d" +dependencies = [ + "autocfg", + "cfg-if", + "crossbeam-utils", +] + +[[package]] +name = "crossbeam-utils" +version = "0.8.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c3a430a770ebd84726f584a90ee7f020d28db52c6d02138900f22341f866d39c" +dependencies = [ + "cfg-if", +] + +[[package]] +name = "darling" +version = "0.10.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0d706e75d87e35569db781a9b5e2416cff1236a47ed380831f959382ccd5f858" +dependencies = [ + "darling_core", + "darling_macro", +] + +[[package]] +name = "darling_core" +version = "0.10.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f0c960ae2da4de88a91b2d920c2a7233b400bc33cb28453a2987822d8392519b" +dependencies = [ + "fnv", + "ident_case", + "proc-macro2", + "quote", + "strsim", + "syn 1.0.109", +] + +[[package]] +name = "darling_macro" +version = "0.10.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d9b5a2f4ac4969822c62224815d069952656cadc7084fdca9751e6d959189b72" +dependencies = [ + "darling_core", + "quote", + "syn 1.0.109", +] + +[[package]] +name = "derive_builder" +version = "0.9.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a2658621297f2cf68762a6f7dc0bb7e1ff2cfd6583daef8ee0fed6f7ec468ec0" +dependencies = [ + "darling", + "derive_builder_core", + "proc-macro2", + "quote", + "syn 1.0.109", +] + +[[package]] +name = "derive_builder_core" +version = "0.9.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2791ea3e372c8495c0bc2033991d76b512cd799d07491fbd6890124db9458bef" +dependencies = [ + "darling", + "proc-macro2", + "quote", + "syn 1.0.109", +] + +[[package]] +name = "dirs-next" +version = "2.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b98cf8ebf19c3d1b223e151f99a4f9f0690dca41414773390fc824184ac833e1" +dependencies = [ + "cfg-if", + "dirs-sys-next", +] + +[[package]] +name = "dirs-sys-next" +version = "0.1.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4ebda144c4fe02d1f7ea1a7d9641b6fc6b580adcfa024ae48797ecdeb6825b4d" +dependencies = [ + "libc", + "redox_users", + "winapi", +] + +[[package]] +name = "dlib" +version = "0.5.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "330c60081dcc4c72131f8eb70510f1ac07223e5d4163db481a04a0befcffa412" +dependencies = [ + "libloading", +] + +[[package]] +name = "dwrote" +version = "0.11.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "439a1c2ba5611ad3ed731280541d36d2e9c4ac5e7fb818a27b604bdc5a6aa65b" +dependencies = [ + "lazy_static", + "libc", + "winapi", + "wio", +] + +[[package]] +name = "either" +version = "1.9.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a26ae43d7bcc3b814de94796a5e736d4029efb0ee900c12e2d54c993ad1a1e07" + +[[package]] +name = "equivalent" +version = "1.0.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5443807d6dff69373d433ab9ef5378ad8df50ca6298caf15de6e52e24aaf54d5" + +[[package]] +name = "extend" +version = "1.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "311a6d2f1f9d60bff73d2c78a0af97ed27f79672f15c238192a5bbb64db56d00" +dependencies = [ + "proc-macro2", + "quote", + "syn 2.0.43", +] + +[[package]] +name = "fdeflate" +version = "0.3.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "209098dd6dfc4445aa6111f0e98653ac323eaa4dfd212c9ca3931bf9955c31bd" +dependencies = [ + "simd-adler32", +] + +[[package]] +name = "ff" +version = "0.12.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d013fc25338cc558c5c2cfbad646908fb23591e2404481826742b651c9af7160" +dependencies = [ + "bitvec", + "rand_core", + "subtle", +] + +[[package]] +name = "flate2" +version = "1.0.28" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "46303f565772937ffe1d394a4fac6f411c6013172fadde9dcdb1e147a086940e" +dependencies = [ + "crc32fast", + "miniz_oxide", +] + +[[package]] +name = "float-ord" +version = "0.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7bad48618fdb549078c333a7a8528acb57af271d0433bdecd523eb620628364e" + +[[package]] +name = "fnv" +version = "1.0.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3f9eec918d3f24069decb9af1554cad7c880e2da24a9afd88aca000531ab82c1" + +[[package]] +name = "font-kit" +version = "0.11.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "21fe28504d371085fae9ac7a3450f0b289ab71e07c8e57baa3fb68b9e57d6ce5" +dependencies = [ + "bitflags 1.3.2", + "byteorder", + "core-foundation", + "core-graphics", + "core-text", + "dirs-next", + "dwrote", + "float-ord", + "freetype", + "lazy_static", + "libc", + "log", + "pathfinder_geometry", + "pathfinder_simd", + "walkdir", + "winapi", + "yeslogic-fontconfig-sys", +] + +[[package]] +name = "foreign-types" +version = "0.3.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f6f339eb8adc052cd2ca78910fda869aefa38d22d5cb648e6485e4d3fc06f3b1" +dependencies = [ + "foreign-types-shared", +] + +[[package]] +name = "foreign-types-shared" +version = "0.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "00b0228411908ca8685dba7fc2cdd70ec9990a6e753e89b6ac91a84c40fbaf4b" + +[[package]] +name = "form_urlencoded" +version = "1.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e13624c2627564efccf4934284bdd98cbaa14e79b0b5a141218e507b3a823456" +dependencies = [ + "percent-encoding", +] + +[[package]] +name = "freetype" +version = "0.7.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "bee38378a9e3db1cc693b4f88d166ae375338a0ff75cb8263e1c601d51f35dc6" +dependencies = [ + "freetype-sys", + "libc", +] + +[[package]] +name = "freetype-sys" +version = "0.13.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a37d4011c0cc628dfa766fcc195454f4b068d7afdc2adfd28861191d866e731a" +dependencies = [ + "cmake", + "libc", + "pkg-config", +] + +[[package]] +name = "funty" +version = "2.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e6d5a32815ae3f33302d95fdcb2ce17862f8c65363dcfd29360480ba1001fc9c" + +[[package]] +name = "futures-channel" +version = "0.3.30" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "eac8f7d7865dcb88bd4373ab671c8cf4508703796caa2b1985a9ca867b3fcb78" +dependencies = [ + "futures-core", +] + +[[package]] +name = "futures-core" +version = "0.3.30" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "dfc6580bb841c5a68e9ef15c77ccc837b40a7504914d52e47b8b0e9bbda25a1d" + +[[package]] +name = "futures-sink" +version = "0.3.30" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9fb8e00e87438d937621c1c6269e53f536c14d3fbd6a042bb24879e57d474fb5" + +[[package]] +name = "futures-task" +version = "0.3.30" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "38d84fa142264698cdce1a9f9172cf383a0c82de1bddcf3092901442c4097004" + +[[package]] +name = "futures-util" +version = "0.3.30" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3d6401deb83407ab3da39eba7e33987a73c3df0c82b4bb5813ee871c19c41d48" +dependencies = [ + "futures-core", + "futures-task", + "pin-project-lite", + "pin-utils", +] + +[[package]] +name = "getrandom" +version = "0.2.11" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "fe9006bed769170c11f845cf00c7c1e9092aeb3f268e007c3e760ac68008070f" +dependencies = [ + "cfg-if", + "js-sys", + "libc", + "wasi", + "wasm-bindgen", +] + +[[package]] +name = "gif" +version = "0.12.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "80792593675e051cf94a4b111980da2ba60d4a83e43e0048c5693baab3977045" +dependencies = [ + "color_quant", + "weezl", +] + +[[package]] +name = "gimli" +version = "0.28.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4271d37baee1b8c7e4b708028c57d816cf9d2434acb33a549475f78c181f6253" + +[[package]] +name = "group" +version = "0.12.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5dfbfb3a6cfbd390d5c9564ab283a0349b9b9fcd46a706c1eb10e0db70bfbac7" +dependencies = [ + "ff", + "rand_core", + "subtle", +] + +[[package]] +name = "h2" +version = "0.4.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e1d308f63daf4181410c242d34c11f928dcb3aa105852019e043c9d1f4e4368a" +dependencies = [ + "bytes", + "fnv", + "futures-core", + "futures-sink", + "futures-util", + "http", + "indexmap", + "slab", + "tokio", + "tokio-util", + "tracing", +] + +[[package]] +name = "halo2_proofs" +version = "0.1.0" +source = "git+https://github.com/quantstamp/halo2.git?rev=a898d65ae3ad3d41987666f6a03cfc15edae01c4#a898d65ae3ad3d41987666f6a03cfc15edae01c4" +dependencies = [ + "blake2b_simd", + "ff", + "group", + "pasta_curves", + "plotters", + "rand_core", + "rayon", + "tabbycat", +] + +[[package]] +name = "hashbrown" +version = "0.14.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "290f1a1d9242c78d09ce40a5e87e7554ee637af1351968159f4952f028f75604" + +[[package]] +name = "hermit-abi" +version = "0.3.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d77f7ec81a6d05a3abb01ab6eb7590f6083d08449fe5a1c8b1e620283546ccb7" + +[[package]] +name = "http" +version = "1.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b32afd38673a8016f7c9ae69e5af41a58f81b1d31689040f2f1959594ce194ea" +dependencies = [ + "bytes", + "fnv", + "itoa", +] + +[[package]] +name = "http-body" +version = "1.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1cac85db508abc24a2e48553ba12a996e87244a0395ce011e62b37158745d643" +dependencies = [ + "bytes", + "http", +] + +[[package]] +name = "http-body-util" +version = "0.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "41cb79eb393015dadd30fc252023adb0b2400a0caee0fa2a077e6e21a551e840" +dependencies = [ + "bytes", + "futures-util", + "http", + "http-body", + "pin-project-lite", +] + +[[package]] +name = "httparse" +version = "1.8.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d897f394bad6a705d5f4104762e116a75639e470d80901eed05a860a95cb1904" + +[[package]] +name = "httpdate" +version = "1.0.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "df3b46402a9d5adb4c86a0cf463f42e19994e3ee891101b1841f30a545cb49a9" + +[[package]] +name = "hyper" +version = "1.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "fb5aa53871fc917b1a9ed87b683a5d86db645e23acb32c2e0785a353e522fb75" +dependencies = [ + "bytes", + "futures-channel", + "futures-util", + "h2", + "http", + "http-body", + "httparse", + "httpdate", + "itoa", + "pin-project-lite", + "tokio", +] + +[[package]] +name = "hyper-util" +version = "0.1.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "bdea9aac0dbe5a9240d68cfd9501e2db94222c6dc06843e06640b9e07f0fdc67" +dependencies = [ + "bytes", + "futures-channel", + "futures-util", + "http", + "http-body", + "hyper", + "pin-project-lite", + "socket2", + "tokio", + "tracing", +] + +[[package]] +name = "iana-time-zone" +version = "0.1.58" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8326b86b6cff230b97d0d312a6c40a60726df3332e721f72a1b035f451663b20" +dependencies = [ + "android_system_properties", + "core-foundation-sys", + "iana-time-zone-haiku", + "js-sys", + "wasm-bindgen", + "windows-core", +] + +[[package]] +name = "iana-time-zone-haiku" +version = "0.1.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f31827a206f56af32e590ba56d5d2d085f558508192593743f16b2306495269f" +dependencies = [ + "cc", +] + +[[package]] +name = "ident_case" +version = "1.0.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b9e0384b61958566e926dc50660321d12159025e767c18e043daf26b70104c39" + +[[package]] +name = "image" +version = "0.24.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6f3dfdbdd72063086ff443e297b61695500514b1e41095b6fb9a5ab48a70a711" +dependencies = [ + "bytemuck", + "byteorder", + "color_quant", + "jpeg-decoder", + "num-rational", + "num-traits", + "png", +] + +[[package]] +name = "indexmap" +version = "2.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d530e1a18b1cb4c484e6e34556a0d948706958449fca0cab753d649f2bce3d1f" +dependencies = [ + "equivalent", + "hashbrown", +] + +[[package]] +name = "itoa" +version = "1.0.10" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b1a46d1a171d865aa5f83f92695765caa047a9b4cbae2cbf37dbd613a793fd4c" + +[[package]] +name = "jpeg-decoder" +version = "0.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "bc0000e42512c92e31c2252315bda326620a4e034105e900c98ec492fa077b3e" + +[[package]] +name = "js-sys" +version = "0.3.66" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cee9c64da59eae3b50095c18d3e74f8b73c0b86d2792824ff01bbce68ba229ca" +dependencies = [ + "wasm-bindgen", +] + +[[package]] +name = "kid" +version = "0.1.0" +dependencies = [ + "axum", + "extend", + "getrandom", + "halo2_proofs", + "once_cell", + "plotters", + "rand", + "rand_core", + "serde", + "serde_json", + "tokio", + "toml", +] + +[[package]] +name = "lazy_static" +version = "1.4.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e2abad23fbc42b3700f2f279844dc832adb2b2eb069b2df918f455c4e18cc646" + +[[package]] +name = "libc" +version = "0.2.151" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "302d7ab3130588088d277783b1e2d2e10c9e9e4a16dd9050e6ec93fb3e7048f4" + +[[package]] +name = "libloading" +version = "0.8.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c571b676ddfc9a8c12f1f3d3085a7b163966a8fd8098a90640953ce5f6170161" +dependencies = [ + "cfg-if", + "windows-sys", +] + +[[package]] +name = "libredox" +version = "0.0.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "85c833ca1e66078851dba29046874e38f08b2c883700aa29a03ddd3b23814ee8" +dependencies = [ + "bitflags 2.4.1", + "libc", + "redox_syscall", +] + +[[package]] +name = "lock_api" +version = "0.4.11" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3c168f8615b12bc01f9c17e2eb0cc07dcae1940121185446edc3744920e8ef45" +dependencies = [ + "autocfg", + "scopeguard", +] + +[[package]] +name = "log" +version = "0.4.20" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b5e6163cb8c49088c2c36f57875e58ccd8c87c7427f7fbd50ea6710b2f3f2e8f" + +[[package]] +name = "matchit" +version = "0.7.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0e7465ac9959cc2b1404e8e2367b43684a6d13790fe23056cc8c6c5a6b7bcb94" + +[[package]] +name = "memchr" +version = "2.6.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f665ee40bc4a3c5590afb1e9677db74a508659dfd71e126420da8274909a0167" + +[[package]] +name = "mime" +version = "0.3.17" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6877bb514081ee2a7ff5ef9de3281f14a4dd4bceac4c09388074a6b5df8a139a" + +[[package]] +name = "miniz_oxide" +version = "0.7.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7810e0be55b428ada41041c41f32c9f1a42817901b4ccf45fa3d4b6561e74c7" +dependencies = [ + "adler", + "simd-adler32", +] + +[[package]] +name = "mio" +version = "0.8.10" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f3d0b296e374a4e6f3c7b0a1f5a51d748a0d34c85e7dc48fc3fa9a87657fe09" +dependencies = [ + "libc", + "wasi", + "windows-sys", +] + +[[package]] +name = "num-integer" +version = "0.1.45" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "225d3389fb3509a24c93f5c29eb6bde2586b98d9f016636dff58d7c6f7569cd9" +dependencies = [ + "autocfg", + "num-traits", +] + +[[package]] +name = "num-rational" +version = "0.4.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0638a1c9d0a3c0914158145bc76cff373a75a627e6ecbfb71cbe6f453a5a19b0" +dependencies = [ + "autocfg", + "num-integer", + "num-traits", +] + +[[package]] +name = "num-traits" +version = "0.2.17" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "39e3200413f237f41ab11ad6d161bc7239c84dcb631773ccd7de3dfe4b5c267c" +dependencies = [ + "autocfg", +] + +[[package]] +name = "num_cpus" +version = "1.16.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4161fcb6d602d4d2081af7c3a45852d875a03dd337a6bfdd6e06407b61342a43" +dependencies = [ + "hermit-abi", + "libc", +] + +[[package]] +name = "object" +version = "0.32.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a6a622008b6e321afc04970976f62ee297fdbaa6f95318ca343e3eebb9648441" +dependencies = [ + "memchr", +] + +[[package]] +name = "once_cell" +version = "1.19.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3fdb12b2476b595f9358c5161aa467c2438859caa136dec86c26fdd2efe17b92" + +[[package]] +name = "parking_lot" +version = "0.12.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3742b2c103b9f06bc9fff0a37ff4912935851bee6d36f3c02bcc755bcfec228f" +dependencies = [ + "lock_api", + "parking_lot_core", +] + +[[package]] +name = "parking_lot_core" +version = "0.9.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4c42a9226546d68acdd9c0a280d17ce19bfe27a46bf68784e4066115788d008e" +dependencies = [ + "cfg-if", + "libc", + "redox_syscall", + "smallvec", + "windows-targets", +] + +[[package]] +name = "pasta_curves" +version = "0.4.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5cc65faf8e7313b4b1fbaa9f7ca917a0eed499a9663be71477f87993604341d8" +dependencies = [ + "blake2b_simd", + "ff", + "group", + "lazy_static", + "rand", + "static_assertions", + "subtle", +] + +[[package]] +name = "pathfinder_geometry" +version = "0.5.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0b7b7e7b4ea703700ce73ebf128e1450eb69c3a8329199ffbfb9b2a0418e5ad3" +dependencies = [ + "log", + "pathfinder_simd", +] + +[[package]] +name = "pathfinder_simd" +version = "0.5.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0444332826c70dc47be74a7c6a5fc44e23a7905ad6858d4162b658320455ef93" +dependencies = [ + "rustc_version", +] + +[[package]] +name = "percent-encoding" +version = "2.3.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e3148f5046208a5d56bcfc03053e3ca6334e51da8dfb19b6cdc8b306fae3283e" + +[[package]] +name = "pin-project" +version = "1.1.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "fda4ed1c6c173e3fc7a83629421152e01d7b1f9b7f65fb301e490e8cfc656422" +dependencies = [ + "pin-project-internal", +] + +[[package]] +name = "pin-project-internal" +version = "1.1.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4359fd9c9171ec6e8c62926d6faaf553a8dc3f64e1507e76da7911b4f6a04405" +dependencies = [ + "proc-macro2", + "quote", + "syn 2.0.43", +] + +[[package]] +name = "pin-project-lite" +version = "0.2.13" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8afb450f006bf6385ca15ef45d71d2288452bc3683ce2e2cacc0d18e4be60b58" + +[[package]] +name = "pin-utils" +version = "0.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8b870d8c151b6f2fb93e84a13146138f05d02ed11c7e7c54f8826aaaf7c9f184" + +[[package]] +name = "pkg-config" +version = "0.3.28" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "69d3587f8a9e599cc7ec2c00e331f71c4e69a5f9a4b8a6efd5b07466b9736f9a" + +[[package]] +name = "plotters" +version = "0.3.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d2c224ba00d7cadd4d5c660deaf2098e5e80e07846537c51f9cfa4be50c1fd45" +dependencies = [ + "chrono", + "font-kit", + "image", + "lazy_static", + "num-traits", + "pathfinder_geometry", + "plotters-backend", + "plotters-bitmap", + "plotters-svg", + "ttf-parser", + "wasm-bindgen", + "web-sys", +] + +[[package]] +name = "plotters-backend" +version = "0.3.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9e76628b4d3a7581389a35d5b6e2139607ad7c75b17aed325f210aa91f4a9609" + +[[package]] +name = "plotters-bitmap" +version = "0.3.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0cebbe1f70205299abc69e8b295035bb52a6a70ee35474ad10011f0a4efb8543" +dependencies = [ + "gif", + "image", + "plotters-backend", +] + +[[package]] +name = "plotters-svg" +version = "0.3.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "38f6d39893cca0701371e3c27294f09797214b86f1fb951b89ade8ec04e2abab" +dependencies = [ + "plotters-backend", +] + +[[package]] +name = "png" +version = "0.17.10" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "dd75bf2d8dd3702b9707cdbc56a5b9ef42cec752eb8b3bafc01234558442aa64" +dependencies = [ + "bitflags 1.3.2", + "crc32fast", + "fdeflate", + "flate2", + "miniz_oxide", +] + +[[package]] +name = "ppv-lite86" +version = "0.2.17" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5b40af805b3121feab8a3c29f04d8ad262fa8e0561883e7653e024ae4479e6de" + +[[package]] +name = "proc-macro2" +version = "1.0.71" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "75cb1540fadbd5b8fbccc4dddad2734eba435053f725621c070711a14bb5f4b8" +dependencies = [ + "unicode-ident", +] + +[[package]] +name = "quote" +version = "1.0.33" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5267fca4496028628a95160fc423a33e8b2e6af8a5302579e322e4b520293cae" +dependencies = [ + "proc-macro2", +] + +[[package]] +name = "radium" +version = "0.7.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "dc33ff2d4973d518d823d61aa239014831e521c75da58e3df4840d3f47749d09" + +[[package]] +name = "rand" +version = "0.8.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "34af8d1a0e25924bc5b7c43c079c942339d8f0a8b57c39049bef581b46327404" +dependencies = [ + "libc", + "rand_chacha", + "rand_core", +] + +[[package]] +name = "rand_chacha" +version = "0.3.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e6c10a63a0fa32252be49d21e7709d4d4baf8d231c2dbce1eaa8141b9b127d88" +dependencies = [ + "ppv-lite86", + "rand_core", +] + +[[package]] +name = "rand_core" +version = "0.6.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ec0be4795e2f6a28069bec0b5ff3e2ac9bafc99e6a9a7dc3547996c5c816922c" +dependencies = [ + "getrandom", +] + +[[package]] +name = "rayon" +version = "1.8.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9c27db03db7734835b3f53954b534c91069375ce6ccaa2e065441e07d9b6cdb1" +dependencies = [ + "either", + "rayon-core", +] + +[[package]] +name = "rayon-core" +version = "1.12.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5ce3fb6ad83f861aac485e76e1985cd109d9a3713802152be56c3b1f0e0658ed" +dependencies = [ + "crossbeam-deque", + "crossbeam-utils", +] + +[[package]] +name = "redox_syscall" +version = "0.4.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4722d768eff46b75989dd134e5c353f0d6296e5aaa3132e776cbdb56be7731aa" +dependencies = [ + "bitflags 1.3.2", +] + +[[package]] +name = "redox_users" +version = "0.4.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a18479200779601e498ada4e8c1e1f50e3ee19deb0259c25825a98b5603b2cb4" +dependencies = [ + "getrandom", + "libredox", + "thiserror", +] + +[[package]] +name = "regex" +version = "1.10.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "380b951a9c5e80ddfd6136919eef32310721aa4aacd4889a8d39124b026ab343" +dependencies = [ + "aho-corasick", + "memchr", + "regex-automata", + "regex-syntax", +] + +[[package]] +name = "regex-automata" +version = "0.4.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5f804c7828047e88b2d32e2d7fe5a105da8ee3264f01902f796c8e067dc2483f" +dependencies = [ + "aho-corasick", + "memchr", + "regex-syntax", +] + +[[package]] +name = "regex-syntax" +version = "0.8.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c08c74e62047bb2de4ff487b251e4a92e24f48745648451635cec7d591162d9f" + +[[package]] +name = "rustc-demangle" +version = "0.1.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d626bb9dae77e28219937af045c257c28bfd3f69333c512553507f5f9798cb76" + +[[package]] +name = "rustc_version" +version = "0.4.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "bfa0f585226d2e68097d4f95d113b15b83a82e819ab25717ec0590d9584ef366" +dependencies = [ + "semver", +] + +[[package]] +name = "rustversion" +version = "1.0.14" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7ffc183a10b4478d04cbbbfc96d0873219d962dd5accaff2ffbd4ceb7df837f4" + +[[package]] +name = "ryu" +version = "1.0.16" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f98d2aa92eebf49b69786be48e4477826b256916e84a57ff2a4f21923b48eb4c" + +[[package]] +name = "same-file" +version = "1.0.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "93fc1dc3aaa9bfed95e02e6eadabb4baf7e3078b0bd1b4d7b6b0b68378900502" +dependencies = [ + "winapi-util", +] + +[[package]] +name = "scopeguard" +version = "1.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "94143f37725109f92c262ed2cf5e59bce7498c01bcc1502d7b9afe439a4e9f49" + +[[package]] +name = "semver" +version = "1.0.20" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "836fa6a3e1e547f9a2c4040802ec865b5d85f4014efe00555d7090a3dcaa1090" + +[[package]] +name = "serde" +version = "1.0.193" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "25dd9975e68d0cb5aa1120c288333fc98731bd1dd12f561e468ea4728c042b89" +dependencies = [ + "serde_derive", +] + +[[package]] +name = "serde_derive" +version = "1.0.193" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "43576ca501357b9b071ac53cdc7da8ef0cbd9493d8df094cd821777ea6e894d3" +dependencies = [ + "proc-macro2", + "quote", + "syn 2.0.43", +] + +[[package]] +name = "serde_json" +version = "1.0.108" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3d1c7e3eac408d115102c4c24ad393e0821bb3a5df4d506a80f85f7a742a526b" +dependencies = [ + "itoa", + "ryu", + "serde", +] + +[[package]] +name = "serde_path_to_error" +version = "0.1.14" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4beec8bce849d58d06238cb50db2e1c417cfeafa4c63f692b15c82b7c80f8335" +dependencies = [ + "itoa", + "serde", +] + +[[package]] +name = "serde_spanned" +version = "0.6.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "eb3622f419d1296904700073ea6cc23ad690adbd66f13ea683df73298736f0c1" +dependencies = [ + "serde", +] + +[[package]] +name = "serde_urlencoded" +version = "0.7.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d3491c14715ca2294c4d6a88f15e84739788c1d030eed8c110436aafdaa2f3fd" +dependencies = [ + "form_urlencoded", + "itoa", + "ryu", + "serde", +] + +[[package]] +name = "signal-hook-registry" +version = "1.4.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d8229b473baa5980ac72ef434c4415e70c4b5e71b423043adb4ba059f89c99a1" +dependencies = [ + "libc", +] + +[[package]] +name = "simd-adler32" +version = "0.3.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d66dc143e6b11c1eddc06d5c423cfc97062865baf299914ab64caa38182078fe" + +[[package]] +name = "slab" +version = "0.4.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f92a496fb766b417c996b9c5e57daf2f7ad3b0bebe1ccfca4856390e3d3bb67" +dependencies = [ + "autocfg", +] + +[[package]] +name = "smallvec" +version = "1.11.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4dccd0940a2dcdf68d092b8cbab7dc0ad8fa938bf95787e1b916b0e3d0e8e970" + +[[package]] +name = "socket2" +version = "0.5.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7b5fac59a5cb5dd637972e5fca70daf0523c9067fcdc4842f053dae04a18f8e9" +dependencies = [ + "libc", + "windows-sys", +] + +[[package]] +name = "static_assertions" +version = "1.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a2eb9349b6444b326872e140eb1cf5e7c522154d69e7a0ffb0fb81c06b37543f" + +[[package]] +name = "strsim" +version = "0.9.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6446ced80d6c486436db5c078dde11a9f73d42b57fb273121e160b84f63d894c" + +[[package]] +name = "subtle" +version = "2.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "81cdd64d312baedb58e21336b31bc043b77e01cc99033ce76ef539f78e965ebc" + +[[package]] +name = "syn" +version = "1.0.109" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "72b64191b275b66ffe2469e8af2c1cfe3bafa67b529ead792a6d0160888b4237" +dependencies = [ + "proc-macro2", + "quote", + "unicode-ident", +] + +[[package]] +name = "syn" +version = "2.0.43" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ee659fb5f3d355364e1f3e5bc10fb82068efbf824a1e9d1c9504244a6469ad53" +dependencies = [ + "proc-macro2", + "quote", + "unicode-ident", +] + +[[package]] +name = "sync_wrapper" +version = "0.1.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2047c6ded9c721764247e62cd3b03c09ffc529b2ba5b10ec482ae507a4a70160" + +[[package]] +name = "tabbycat" +version = "0.1.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c45590f0f859197b4545be1b17b2bc3cc7bb075f7d1cc0ea1dc6521c0bf256a3" +dependencies = [ + "anyhow", + "derive_builder", + "regex", +] + +[[package]] +name = "tap" +version = "1.0.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "55937e1799185b12863d447f42597ed69d9928686b8d88a1df17376a097d8369" + +[[package]] +name = "thiserror" +version = "1.0.52" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "83a48fd946b02c0a526b2e9481c8e2a17755e47039164a86c4070446e3a4614d" +dependencies = [ + "thiserror-impl", +] + +[[package]] +name = "thiserror-impl" +version = "1.0.52" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7fbe9b594d6568a6a1443250a7e67d80b74e1e96f6d1715e1e21cc1888291d3" +dependencies = [ + "proc-macro2", + "quote", + "syn 2.0.43", +] + +[[package]] +name = "tokio" +version = "1.35.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c89b4efa943be685f629b149f53829423f8f5531ea21249408e8e2f8671ec104" +dependencies = [ + "backtrace", + "bytes", + "libc", + "mio", + "num_cpus", + "parking_lot", + "pin-project-lite", + "signal-hook-registry", + "socket2", + "tokio-macros", + "windows-sys", +] + +[[package]] +name = "tokio-macros" +version = "2.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5b8a1e28f2deaa14e508979454cb3a223b10b938b45af148bc0986de36f1923b" +dependencies = [ + "proc-macro2", + "quote", + "syn 2.0.43", +] + +[[package]] +name = "tokio-util" +version = "0.7.10" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5419f34732d9eb6ee4c3578b7989078579b7f039cbbb9ca2c4da015749371e15" +dependencies = [ + "bytes", + "futures-core", + "futures-sink", + "pin-project-lite", + "tokio", + "tracing", +] + +[[package]] +name = "toml" +version = "0.8.8" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a1a195ec8c9da26928f773888e0742ca3ca1040c6cd859c919c9f59c1954ab35" +dependencies = [ + "serde", + "serde_spanned", + "toml_datetime", + "toml_edit", +] + +[[package]] +name = "toml_datetime" +version = "0.6.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3550f4e9685620ac18a50ed434eb3aec30db8ba93b0287467bca5826ea25baf1" +dependencies = [ + "serde", +] + +[[package]] +name = "toml_edit" +version = "0.21.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d34d383cd00a163b4a5b85053df514d45bc330f6de7737edfe0a93311d1eaa03" +dependencies = [ + "indexmap", + "serde", + "serde_spanned", + "toml_datetime", + "winnow", +] + +[[package]] +name = "tower" +version = "0.4.13" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b8fa9be0de6cf49e536ce1851f987bd21a43b771b09473c3549a6c853db37c1c" +dependencies = [ + "futures-core", + "futures-util", + "pin-project", + "pin-project-lite", + "tokio", + "tower-layer", + "tower-service", + "tracing", +] + +[[package]] +name = "tower-layer" +version = "0.3.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c20c8dbed6283a09604c3e69b4b7eeb54e298b8a600d4d5ecb5ad39de609f1d0" + +[[package]] +name = "tower-service" +version = "0.3.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b6bc1c9ce2b5135ac7f93c72918fc37feb872bdc6a5533a8b85eb4b86bfdae52" + +[[package]] +name = "tracing" +version = "0.1.40" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c3523ab5a71916ccf420eebdf5521fcef02141234bbc0b8a49f2fdc4544364ef" +dependencies = [ + "log", + "pin-project-lite", + "tracing-core", +] + +[[package]] +name = "tracing-core" +version = "0.1.32" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c06d3da6113f116aaee68e4d601191614c9053067f9ab7f6edbcb161237daa54" +dependencies = [ + "once_cell", +] + +[[package]] +name = "ttf-parser" +version = "0.17.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "375812fa44dab6df41c195cd2f7fecb488f6c09fbaafb62807488cefab642bff" + +[[package]] +name = "unicode-ident" +version = "1.0.12" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3354b9ac3fae1ff6755cb6db53683adb661634f67557942dea4facebec0fee4b" + +[[package]] +name = "walkdir" +version = "2.4.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d71d857dc86794ca4c280d616f7da00d2dbfd8cd788846559a6813e6aa4b54ee" +dependencies = [ + "same-file", + "winapi-util", +] + +[[package]] +name = "wasi" +version = "0.11.0+wasi-snapshot-preview1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9c8d87e72b64a3b4db28d11ce29237c246188f4f51057d65a7eab63b7987e423" + +[[package]] +name = "wasm-bindgen" +version = "0.2.89" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0ed0d4f68a3015cc185aff4db9506a015f4b96f95303897bfa23f846db54064e" +dependencies = [ + "cfg-if", + "wasm-bindgen-macro", +] + +[[package]] +name = "wasm-bindgen-backend" +version = "0.2.89" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1b56f625e64f3a1084ded111c4d5f477df9f8c92df113852fa5a374dbda78826" +dependencies = [ + "bumpalo", + "log", + "once_cell", + "proc-macro2", + "quote", + "syn 2.0.43", + "wasm-bindgen-shared", +] + +[[package]] +name = "wasm-bindgen-macro" +version = "0.2.89" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0162dbf37223cd2afce98f3d0785506dcb8d266223983e4b5b525859e6e182b2" +dependencies = [ + "quote", + "wasm-bindgen-macro-support", +] + +[[package]] +name = "wasm-bindgen-macro-support" +version = "0.2.89" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f0eb82fcb7930ae6219a7ecfd55b217f5f0893484b7a13022ebb2b2bf20b5283" +dependencies = [ + "proc-macro2", + "quote", + "syn 2.0.43", + "wasm-bindgen-backend", + "wasm-bindgen-shared", +] + +[[package]] +name = "wasm-bindgen-shared" +version = "0.2.89" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7ab9b36309365056cd639da3134bf87fa8f3d86008abf99e612384a6eecd459f" + +[[package]] +name = "web-sys" +version = "0.3.66" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "50c24a44ec86bb68fbecd1b3efed7e85ea5621b39b35ef2766b66cd984f8010f" +dependencies = [ + "js-sys", + "wasm-bindgen", +] + +[[package]] +name = "weezl" +version = "0.1.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9193164d4de03a926d909d3bc7c30543cecb35400c02114792c2cae20d5e2dbb" + +[[package]] +name = "winapi" +version = "0.3.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5c839a674fcd7a98952e593242ea400abe93992746761e38641405d28b00f419" +dependencies = [ + "winapi-i686-pc-windows-gnu", + "winapi-x86_64-pc-windows-gnu", +] + +[[package]] +name = "winapi-i686-pc-windows-gnu" +version = "0.4.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6" + +[[package]] +name = "winapi-util" +version = "0.1.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f29e6f9198ba0d26b4c9f07dbe6f9ed633e1f3d5b8b414090084349e46a52596" +dependencies = [ + "winapi", +] + +[[package]] +name = "winapi-x86_64-pc-windows-gnu" +version = "0.4.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f" + +[[package]] +name = "windows-core" +version = "0.51.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f1f8cf84f35d2db49a46868f947758c7a1138116f7fac3bc844f43ade1292e64" +dependencies = [ + "windows-targets", +] + +[[package]] +name = "windows-sys" +version = "0.48.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "677d2418bec65e3338edb076e806bc1ec15693c5d0104683f2efe857f61056a9" +dependencies = [ + "windows-targets", +] + +[[package]] +name = "windows-targets" +version = "0.48.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9a2fa6e2155d7247be68c096456083145c183cbbbc2764150dda45a87197940c" +dependencies = [ + "windows_aarch64_gnullvm", + "windows_aarch64_msvc", + "windows_i686_gnu", + "windows_i686_msvc", + "windows_x86_64_gnu", + "windows_x86_64_gnullvm", + "windows_x86_64_msvc", +] + +[[package]] +name = "windows_aarch64_gnullvm" +version = "0.48.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2b38e32f0abccf9987a4e3079dfb67dcd799fb61361e53e2882c3cbaf0d905d8" + +[[package]] +name = "windows_aarch64_msvc" +version = "0.48.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "dc35310971f3b2dbbf3f0690a219f40e2d9afcf64f9ab7cc1be722937c26b4bc" + +[[package]] +name = "windows_i686_gnu" +version = "0.48.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a75915e7def60c94dcef72200b9a8e58e5091744960da64ec734a6c6e9b3743e" + +[[package]] +name = "windows_i686_msvc" +version = "0.48.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f55c233f70c4b27f66c523580f78f1004e8b5a8b659e05a4eb49d4166cca406" + +[[package]] +name = "windows_x86_64_gnu" +version = "0.48.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "53d40abd2583d23e4718fddf1ebec84dbff8381c07cae67ff7768bbf19c6718e" + +[[package]] +name = "windows_x86_64_gnullvm" +version = "0.48.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0b7b52767868a23d5bab768e390dc5f5c55825b6d30b86c844ff2dc7414044cc" + +[[package]] +name = "windows_x86_64_msvc" +version = "0.48.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ed94fce61571a4006852b7389a063ab983c02eb1bb37b47f8272ce92d06d9538" + +[[package]] +name = "winnow" +version = "0.5.31" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "97a4882e6b134d6c28953a387571f1acdd3496830d5e36c5e3a1075580ea641c" +dependencies = [ + "memchr", +] + +[[package]] +name = "wio" +version = "0.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5d129932f4644ac2396cb456385cbf9e63b5b30c6e8dc4820bdca4eb082037a5" +dependencies = [ + "winapi", +] + +[[package]] +name = "wyz" +version = "0.5.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "05f360fc0b24296329c78fda852a1e9ae82de9cf7b27dae4b7f62f118f77b9ed" +dependencies = [ + "tap", +] + +[[package]] +name = "yeslogic-fontconfig-sys" +version = "3.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f2bbd69036d397ebbff671b1b8e4d918610c181c5a16073b96f984a38d08c386" +dependencies = [ + "const-cstr", + "dlib", + "once_cell", + "pkg-config", +] diff --git a/docs/crypto/zkCTF/day1/Kid Math/Cargo.toml b/docs/crypto/zkCTF/day1/Kid Math/Cargo.toml new file mode 100644 index 0000000..23b3a7f --- /dev/null +++ b/docs/crypto/zkCTF/day1/Kid Math/Cargo.toml @@ -0,0 +1,22 @@ +[package] +name = "kid" +version = "0.1.0" +edition = "2021" + +# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html + +[dependencies] +extend = "1.2.0" +halo2_proofs = { features = [ + "dev-graph", +], git = "https://github.com/quantstamp/halo2.git", rev = "a898d65ae3ad3d41987666f6a03cfc15edae01c4" } +plotters = "0.3.4" +rand_core = { version = "*", features = ["getrandom"] } +serde = { version = "1", features = ["derive"] } +serde_json = "1" +getrandom = { version = "0.2", features = ["js"] } +toml = "0.8" +axum = "0.7" +tokio = { version = "1", features = ["full"] } +once_cell = "1" +rand = "0.8" diff --git a/docs/crypto/zkCTF/day1/Kid Math/description.md b/docs/crypto/zkCTF/day1/Kid Math/description.md new file mode 100644 index 0000000..4fa0791 --- /dev/null +++ b/docs/crypto/zkCTF/day1/Kid Math/description.md @@ -0,0 +1,15 @@ +# ZK CFT - Halo2 - Kid's Math + +## Overview +1. This is a quiz about Halo2 usage. The standard answer would not be given to participants +2. Instead, a file would be given, with all necessary structs and missing logics. Participants are required to fill in the blanks, compile the program and run tests +3. Multiple test cases would be given, the prover program shall be tested against them + +## Problem description +After a hard time on the CTF, you finally find something that seemed very simple to solve. It requires you to forge the proof that you know the value of the term "x": "[1,2,3,5,x]" using the halo2 proof system. Unfortunately, when you write down your answer, you find your proof just can't be verified! Would you try again with incomplete source code, and see how to break through the verifier? + +## Comand +cargo test + +## Test and Solve +You may only test your circuit by upload the fib.rs diff --git a/docs/crypto/zkCTF/day1/Kid Math/src/fib.rs b/docs/crypto/zkCTF/day1/Kid Math/src/fib.rs new file mode 100644 index 0000000..fc1742d --- /dev/null +++ b/docs/crypto/zkCTF/day1/Kid Math/src/fib.rs @@ -0,0 +1,271 @@ +use halo2_proofs::arithmetic::FieldExt; +use halo2_proofs::{ + arithmetic::Field, + circuit::{AssignedCell, Chip, Layouter, Region, SimpleFloorPlanner, Value}, + dev::MockProver, + pasta::{EqAffine, Fp}, + plonk::{ + create_proof, keygen_pk, keygen_vk, verify_proof, Advice, Circuit, Column, + ConstraintSystem, Error, Expression, Fixed, Instance, ProvingKey, Selector, SingleVerifier, + VerifyingKey, + }, + poly::{commitment::Params, Rotation}, + transcript::{Blake2bRead, Blake2bWrite, Challenge255}, +}; +use serde::{Deserialize, Serialize}; +use std::marker::PhantomData; + +#[derive(Debug, Clone)] +pub struct FibonacciConfig { + pub col_a: Column, + pub col_b: Column, + pub col_c: Column, + pub col_pa: Column, + pub col_pb: Column, + pub col_pc: Column, + pub selector: Selector, + pub instance: Column, +} + +#[derive(Debug, Clone)] +struct FibonacciChip { + config: FibonacciConfig, + _marker: PhantomData, +} + +impl FibonacciChip { + pub fn construct(config: FibonacciConfig) -> Self { + Self { + config, + _marker: PhantomData, + } + } + + pub fn configure(meta: &mut ConstraintSystem) -> FibonacciConfig { + let col_a = meta.advice_column(); + let col_b = meta.advice_column(); + let col_c = meta.advice_column(); + let col_pa = meta.fixed_column(); + let col_pb = meta.fixed_column(); + let col_pc = meta.fixed_column(); + let selector = meta.selector(); + let instance = meta.instance_column(); + + meta.enable_equality(col_a); + meta.enable_equality(col_b); + meta.enable_equality(col_c); + meta.enable_equality(instance); + + ///////////////////////// Please implement code here ///////////////////////// + // unimplemented!(); + meta.create_gate("fibonacci", |meta| { + let a = meta.query_advice(col_a, Rotation::cur()); + let b = meta.query_advice(col_b, Rotation::cur()); + let c = meta.query_advice(col_c, Rotation::cur()); + let pa = meta.query_fixed(col_pa, Rotation::cur()); + let pb = meta.query_fixed(col_pb, Rotation::cur()); + let pc = meta.query_fixed(col_pc, Rotation::cur()); + let s = meta.query_selector(selector); + vec![s * (-a * pa + b * pb - c - pc)] + }); + ///////////////////////// End implement ///////////////////////// + + FibonacciConfig { + col_a, + col_b, + col_c, + col_pa, + col_pb, + col_pc, + selector, + instance, + } + } + + #[allow(clippy::type_complexity)] + pub fn assign_first_row( + &self, + mut layouter: impl Layouter, + ) -> Result<(AssignedCell, AssignedCell, AssignedCell), Error> { + layouter.assign_region( + || "first row", + |mut region| { + self.config.selector.enable(&mut region, 0)?; + + let a_cell = region.assign_advice_from_instance( + || "f(0)", + self.config.instance, + 0, + self.config.col_a, + 0, + )?; + + let b_cell = region.assign_advice_from_instance( + || "f(1)", + self.config.instance, + 1, + self.config.col_b, + 0, + )?; + + let c_cell = region.assign_advice( + || "a + b", + self.config.col_c, + 0, + || a_cell.value().copied() + b_cell.value(), + )?; + + // Assign pa here! + ///////////////////////// Please implement code here ///////////////////////// + region.assign_fixed( + || "pa", + self.config.col_pa, + 0, + || Value::known(F::from(125)), + )?; + ///////////////////////// End implement ///////////////////////// + // Assign pb here! + ///////////////////////// Please implement code here ///////////////////////// + region.assign_fixed( + || "pb", + self.config.col_pb, + 0, + || Value::known(F::from(127)), + )?; + ///////////////////////// End implement ///////////////////////// + // Assign pc here! + ///////////////////////// Please implement code here ///////////////////////// + region.assign_fixed( + || "pc", + self.config.col_pc, + 0, + || Value::known(F::from(126)), + )?; + ///////////////////////// End implement ///////////////////////// + Ok((a_cell, b_cell, c_cell)) + }, + ) + } + + pub fn assign_row( + &self, + mut layouter: impl Layouter, + prev_b: &AssignedCell, + prev_c: &AssignedCell, + ) -> Result, Error> { + layouter.assign_region( + || "next row", + |mut region| { + self.config.selector.enable(&mut region, 0)?; + prev_b.copy_advice(|| "a", &mut region, self.config.col_a, 0)?; + prev_c.copy_advice(|| "b", &mut region, self.config.col_b, 0)?; + + let c_cell = region.assign_advice( + || "c", + self.config.col_c, + 0, + || { + -prev_b.value().copied() * Value::known(F::from(125)) + + prev_c.value().copied() * Value::known(F::from(127)) + - Value::known(F::from(126)) + }, + )?; + + region.assign_fixed( + || "pa", + self.config.col_pa, + 0, + || Value::known(F::from(125)), + )?; + // Assign pb here! + ///////////////////////// Please implement code here ///////////////////////// + region.assign_fixed( + || "pb", + self.config.col_pb, + 0, + || Value::known(F::from(127)), + )?; + ///////////////////////// End implement ///////////////////////// + // Assign pc here! + ///////////////////////// Please implement code here ///////////////////////// + region.assign_fixed( + || "pc", + self.config.col_pc, + 0, + || Value::known(F::from(126)), + )?; + ///////////////////////// End implement ///////////////////////// + Ok(c_cell) + }, + ) + } + + pub fn expose_public( + &self, + mut layouter: impl Layouter, + cell: &AssignedCell, + row: usize, + ) -> Result<(), Error> { + layouter.constrain_instance(cell.cell(), self.config.instance, row) + } +} + +#[derive(Default, Serialize, Deserialize)] +pub struct FibonacciCircuit(pub PhantomData); + +impl Circuit for FibonacciCircuit { + type Config = FibonacciConfig; + type FloorPlanner = SimpleFloorPlanner; + + fn without_witnesses(&self) -> Self { + Self::default() + } + + fn configure(meta: &mut ConstraintSystem) -> Self::Config { + FibonacciChip::configure(meta) + } + + fn synthesize( + &self, + config: Self::Config, + mut layouter: impl Layouter, + ) -> Result<(), Error> { + let chip = FibonacciChip::construct(config); + + let (_, mut prev_b, mut prev_c) = + chip.assign_first_row(layouter.namespace(|| "first row"))?; + + for _i in 3..5 { + let c_cell = chip.assign_row(layouter.namespace(|| "next row"), &prev_b, &prev_c)?; + prev_b = prev_c; + prev_c = c_cell; + } + + chip.expose_public(layouter.namespace(|| "out"), &prev_c, 2)?; + Ok(()) + } +} + +#[cfg(test)] +mod tests { + use super::FibonacciCircuit; + use halo2_proofs::{dev::MockProver, pasta::Fp}; + use std::marker::PhantomData; + + #[test] + fn fibonacci_example1() { + let k = 4; + //1,2,3,5,? + let quiz = 134; + let a = Fp::from(1); // F[0] + let b = Fp::from(2); // F[1] + let out = Fp::from(quiz); // F[5] + + let circuit = FibonacciCircuit(PhantomData); + + let public_input = vec![a, b, out]; + + let prover = MockProver::run(k, &circuit, vec![public_input.clone()]).unwrap(); + prover.assert_satisfied(); + } +} diff --git a/docs/crypto/zkCTF/day1/Kid Math/src/lib.rs b/docs/crypto/zkCTF/day1/Kid Math/src/lib.rs new file mode 100644 index 0000000..2478b7d --- /dev/null +++ b/docs/crypto/zkCTF/day1/Kid Math/src/lib.rs @@ -0,0 +1 @@ +pub mod fib; diff --git a/docs/crypto/zkCTF/day1/Roundabout/Circom/Roundabout.circom b/docs/crypto/zkCTF/day1/Roundabout/Circom/Roundabout.circom new file mode 100644 index 0000000..721c4e3 --- /dev/null +++ b/docs/crypto/zkCTF/day1/Roundabout/Circom/Roundabout.circom @@ -0,0 +1,319 @@ +pragma circom 2.0.0; + +// implements MiMC-2n/n as hash using a sponge construction. +// log_5(21888242871839275222246405745257275088548364400416034343698204186575808495617) ~= 110 +// => nRounds should be 220 +template MiMCSponge(nInputs, nRounds, nOutputs) { + signal input ins[nInputs]; + signal input k; + signal output outs[nOutputs]; + + var i; + + // S = R||C + component S[nInputs + nOutputs - 1]; + + for (i = 0; i < nInputs; i++) { + S[i] = MiMCFeistel(nRounds); + S[i].k <== k; + if (i == 0) { + S[i].xL_in <== ins[0]; + S[i].xR_in <== 0; + } else { + S[i].xL_in <== S[i-1].xL_out + ins[i]; + S[i].xR_in <== S[i-1].xR_out; + } + } + + outs[0] <== S[nInputs - 1].xL_out; + + for (i = 0; i < nOutputs - 1; i++) { + S[nInputs + i] = MiMCFeistel(nRounds); + S[nInputs + i].k <== k; + S[nInputs + i].xL_in <== S[nInputs + i - 1].xL_out; + S[nInputs + i].xR_in <== S[nInputs + i - 1].xR_out; + outs[i + 1] <== S[nInputs + i].xL_out; + } +} + +template MiMCFeistel(nrounds) { + signal input xL_in; + signal input xR_in; + signal input k; + signal output xL_out; + signal output xR_out; + + // doesn't contain the first and last round constants, which are always zero + var c_partial[218] = [ + 7120861356467848435263064379192047478074060781135320967663101236819528304084, + 5024705281721889198577876690145313457398658950011302225525409148828000436681, + 17980351014018068290387269214713820287804403312720763401943303895585469787384, + 19886576439381707240399940949310933992335779767309383709787331470398675714258, + 1213715278223786725806155661738676903520350859678319590331207960381534602599, + 18162138253399958831050545255414688239130588254891200470934232514682584734511, + 7667462281466170157858259197976388676420847047604921256361474169980037581876, + 7207551498477838452286210989212982851118089401128156132319807392460388436957, + 9864183311657946807255900203841777810810224615118629957816193727554621093838, + 4798196928559910300796064665904583125427459076060519468052008159779219347957, + 17387238494588145257484818061490088963673275521250153686214197573695921400950, + 10005334761930299057035055370088813230849810566234116771751925093634136574742, + 11897542014760736209670863723231849628230383119798486487899539017466261308762, + 16771780563523793011283273687253985566177232886900511371656074413362142152543, + 749264854018824809464168489785113337925400687349357088413132714480582918506, + 3683645737503705042628598550438395339383572464204988015434959428676652575331, + 7556750851783822914673316211129907782679509728346361368978891584375551186255, + 20391289379084797414557439284689954098721219201171527383291525676334308303023, + 18146517657445423462330854383025300323335289319277199154920964274562014376193, + 8080173465267536232534446836148661251987053305394647905212781979099916615292, + 10796443006899450245502071131975731672911747129805343722228413358507805531141, + 5404287610364961067658660283245291234008692303120470305032076412056764726509, + 4623894483395123520243967718315330178025957095502546813929290333264120223168, + 16845753148201777192406958674202574751725237939980634861948953189320362207797, + 4622170486584704769521001011395820886029808520586507873417553166762370293671, + 16688277490485052681847773549197928630624828392248424077804829676011512392564, + 11878652861183667748838188993669912629573713271883125458838494308957689090959, + 2436445725746972287496138382764643208791713986676129260589667864467010129482, + 1888098689545151571063267806606510032698677328923740058080630641742325067877, + 148924106504065664829055598316821983869409581623245780505601526786791681102, + 18875020877782404439294079398043479420415331640996249745272087358069018086569, + 15189693413320228845990326214136820307649565437237093707846682797649429515840, + 19669450123472657781282985229369348220906547335081730205028099210442632534079, + 5521922218264623411380547905210139511350706092570900075727555783240701821773, + 4144769320246558352780591737261172907511489963810975650573703217887429086546, + 10097732913112662248360143041019433907849917041759137293018029019134392559350, + 1720059427972723034107765345743336447947522473310069975142483982753181038321, + 6302388219880227251325608388535181451187131054211388356563634768253301290116, + 6745410632962119604799318394592010194450845483518862700079921360015766217097, + 10858157235265583624235850660462324469799552996870780238992046963007491306222, + 20241898894740093733047052816576694435372877719072347814065227797906130857593, + 10165780782761211520836029617746977303303335603838343292431760011576528327409, + 2832093654883670345969792724123161241696170611611744759675180839473215203706, + 153011722355526826233082383360057587249818749719433916258246100068258954737, + 20196970640587451358539129330170636295243141659030208529338914906436009086943, + 3180973917010545328313139835982464870638521890385603025657430208141494469656, + 17198004293191777441573635123110935015228014028618868252989374962722329283022, + 7642160509228669138628515458941659189680509753651629476399516332224325757132, + 19346204940546791021518535594447257347218878114049998691060016493806845179755, + 11501810868606870391127866188394535330696206817602260610801897042898616817272, + 3113973447392053821824427670386252797811804954746053461397972968381571297505, + 6545064306297957002139416752334741502722251869537551068239642131448768236585, + 5203908808704813498389265425172875593837960384349653691918590736979872578408, + 2246692432011290582160062129070762007374502637007107318105405626910313810224, + 11760570435432189127645691249600821064883781677693087773459065574359292849137, + 5543749482491340532547407723464609328207990784853381797689466144924198391839, + 8837549193990558762776520822018694066937602576881497343584903902880277769302, + 12855514863299373699594410385788943772765811961581749194183533625311486462501, + 5363660674689121676875069134269386492382220935599781121306637800261912519729, + 13162342403579303950549728848130828093497701266240457479693991108217307949435, + 916941639326869583414469202910306428966657806899788970948781207501251816730, + 15618589556584434434009868216186115416835494805174158488636000580759692174228, + 8959562060028569701043973060670353733575345393653685776974948916988033453971, + 16390754464333401712265575949874369157699293840516802426621216808905079127650, + 168282396747788514908709091757591226095443902501365500003618183905496160435, + 8327443473179334761744301768309008451162322941906921742120510244986704677004, + 17213012626801210615058753489149961717422101711567228037597150941152495100640, + 10394369641533736715250242399198097296122982486516256408681925424076248952280, + 17784386835392322654196171115293700800825771210400152504776806618892170162248, + 16533189939837087893364000390641148516479148564190420358849587959161226782982, + 18725396114211370207078434315900726338547621160475533496863298091023511945076, + 7132325028834551397904855671244375895110341505383911719294705267624034122405, + 148317947440800089795933930720822493695520852448386394775371401743494965187, + 19001050671757720352890779127693793630251266879994702723636759889378387053056, + 18824274411769830274877839365728651108434404855803844568234862945613766611460, + 12771414330193951156383998390424063470766226667986423961689712557338777174205, + 11332046574800279729678603488745295198038913503395629790213378101166488244657, + 9607550223176946388146938069307456967842408600269548190739947540821716354749, + 8756385288462344550200229174435953103162307705310807828651304665320046782583, + 176061952957067086877570020242717222844908281373122372938833890096257042779, + 12200212977482648306758992405065921724409841940671166017620928947866825250857, + 10868453624107875516866146499877130701929063632959660262366632833504750028858, + 2016095394399807253596787752134573207202567875457560571095586743878953450738, + 21815578223768330433802113452339488275704145896544481092014911825656390567514, + 4923772847693564777744725640710197015181591950368494148029046443433103381621, + 1813584943682214789802230765734821149202472893379265320098816901270224589984, + 10810123816265612772922113403831964815724109728287572256602010709288980656498, + 1153669123397255702524721206511185557982017410156956216465120456256288427021, + 5007518659266430200134478928344522649876467369278722765097865662497773767152, + 2511432546938591792036639990606464315121646668029252285288323664350666551637, + 32883284540320451295484135704808083452381176816565850047310272290579727564, + 10484856914279112612610993418405543310546746652738541161791501150994088679557, + 2026733759645519472558796412979210009170379159866522399881566309631434814953, + 14731806221235869882801331463708736361296174006732553130708107037190460654379, + 14740327483193277147065845135561988641238516852487657117813536909482068950652, + 18787428285295558781869865751953016580493190547148386433580291216673009884554, + 3804047064713122820157099453648459188816376755739202017447862327783289895072, + 16709604795697901641948603019242067672006293290826991671766611326262532802914, + 11061717085931490100602849654034280576915102867237101935487893025907907250695, + 2821730726367472966906149684046356272806484545281639696873240305052362149654, + 17467794879902895769410571945152708684493991588672014763135370927880883292655, + 1571520786233540988201616650622796363168031165456869481368085474420849243232, + 10041051776251223165849354194892664881051125330236567356945669006147134614302, + 3981753758468103976812813304477670033098707002886030847251581853700311567551, + 4365864398105436789177703571412645548020537580493599380018290523813331678900, + 2391801327305361293476178683853802679507598622000359948432171562543560193350, + 214219368547551689972421167733597094823289857206402800635962137077096090722, + 18192064100315141084242006659317257023098826945893371479835220462302399655674, + 15487549757142039139328911515400805508248576685795694919457041092150651939253, + 10142447197759703415402259672441315777933858467700579946665223821199077641122, + 11246573086260753259993971254725613211193686683988426513880826148090811891866, + 6574066859860991369704567902211886840188702386542112593710271426704432301235, + 11311085442652291634822798307831431035776248927202286895207125867542470350078, + 20977948360215259915441258687649465618185769343138135384346964466965010873779, + 792781492853909872425531014397300057232399608769451037135936617996830018501, + 5027602491523497423798779154966735896562099398367163998686335127580757861872, + 14595204575654316237672764823862241845410365278802914304953002937313300553572, + 13973538843621261113924259058427434053808430378163734641175100160836376897004, + 16395063164993626722686882727042150241125309409717445381854913964674649318585, + 8465768840047024550750516678171433288207841931251654898809033371655109266663, + 21345603324471810861925019445720576814602636473739003852898308205213912255830, + 21171984405852590343970239018692870799717057961108910523876770029017785940991, + 10761027113757988230637066281488532903174559953630210849190212601991063767647, + 6678298831065390834922566306988418588227382406175769592902974103663687992230, + 4993662582188632374202316265508850988596880036291765531885657575099537176757, + 18364168158495573675698600238443218434246806358811328083953887470513967121206, + 3506345610354615013737144848471391553141006285964325596214723571988011984829, + 248732676202643792226973868626360612151424823368345645514532870586234380100, + 10090204501612803176317709245679152331057882187411777688746797044706063410969, + 21297149835078365363970699581821844234354988617890041296044775371855432973500, + 16729368143229828574342820060716366330476985824952922184463387490091156065099, + 4467191506765339364971058668792642195242197133011672559453028147641428433293, + 8677548159358013363291014307402600830078662555833653517843708051504582990832, + 1022951765127126818581466247360193856197472064872288389992480993218645055345, + 1888195070251580606973417065636430294417895423429240431595054184472931224452, + 4221265384902749246920810956363310125115516771964522748896154428740238579824, + 2825393571154632139467378429077438870179957021959813965940638905853993971879, + 19171031072692942278056619599721228021635671304612437350119663236604712493093, + 10780807212297131186617505517708903709488273075252405602261683478333331220733, + 18230936781133176044598070768084230333433368654744509969087239465125979720995, + 16901065971871379877929280081392692752968612240624985552337779093292740763381, + 146494141603558321291767829522948454429758543710648402457451799015963102253, + 2492729278659146790410698334997955258248120870028541691998279257260289595548, + 2204224910006646535594933495262085193210692406133533679934843341237521233504, + 16062117410185840274616925297332331018523844434907012275592638570193234893570, + 5894928453677122829055071981254202951712129328678534592916926069506935491729, + 4947482739415078212217504789923078546034438919537985740403824517728200332286, + 16143265650645676880461646123844627780378251900510645261875867423498913438066, + 397690828254561723549349897112473766901585444153303054845160673059519614409, + 11272653598912269895509621181205395118899451234151664604248382803490621227687, + 15566927854306879444693061574322104423426072650522411176731130806720753591030, + 14222898219492484180162096141564251903058269177856173968147960855133048449557, + 16690275395485630428127725067513114066329712673106153451801968992299636791385, + 3667030990325966886479548860429670833692690972701471494757671819017808678584, + 21280039024501430842616328642522421302481259067470872421086939673482530783142, + 15895485136902450169492923978042129726601461603404514670348703312850236146328, + 7733050956302327984762132317027414325566202380840692458138724610131603812560, + 438123800976401478772659663183448617575635636575786782566035096946820525816, + 814913922521637742587885320797606426167962526342166512693085292151314976633, + 12368712287081330853637674140264759478736012797026621876924395982504369598764, + 2494806857395134874309386694756263421445039103814920780777601708371037591569, + 16101132301514338989512946061786320637179843435886825102406248183507106312877, + 6252650284989960032925831409804233477770646333900692286731621844532438095656, + 9277135875276787021836189566799935097400042171346561246305113339462708861695, + 10493603554686607050979497281838644324893776154179810893893660722522945589063, + 8673089750662709235894359384294076697329948991010184356091130382437645649279, + 9558393272910366944245875920138649617479779893610128634419086981339060613250, + 19012287860122586147374214541764572282814469237161122489573881644994964647218, + 9783723818270121678386992630754842961728702994964214799008457449989291229500, + 15550788416669474113213749561488122552422887538676036667630838378023479382689, + 15016165746156232864069722572047169071786333815661109750860165034341572904221, + 6506225705710197163670556961299945987488979904603689017479840649664564978574, + 10796631184889302076168355684722130903785890709107732067446714470783437829037, + 19871836214837460419845806980869387567383718044439891735114283113359312279540, + 20871081766843466343749609089986071784031203517506781251203251608363835140622, + 5100105771517691442278432864090229416166996183792075307747582375962855820797, + 8777887112076272395250620301071581171386440850451972412060638225741125310886, + 5300440870136391278944213332144327695659161151625757537632832724102670898756, + 1205448543652932944633962232545707633928124666868453915721030884663332604536, + 5542499997310181530432302492142574333860449305424174466698068685590909336771, + 11028094245762332275225364962905938096659249161369092798505554939952525894293, + 19187314764836593118404597958543112407224947638377479622725713735224279297009, + 17047263688548829001253658727764731047114098556534482052135734487985276987385, + 19914849528178967155534624144358541535306360577227460456855821557421213606310, + 2929658084700714257515872921366736697080475676508114973627124569375444665664, + 15092262360719700162343163278648422751610766427236295023221516498310468956361, + 21578580340755653236050830649990190843552802306886938815497471545814130084980, + 1258781501221760320019859066036073675029057285507345332959539295621677296991, + 3819598418157732134449049289585680301176983019643974929528867686268702720163, + 8653175945487997845203439345797943132543211416447757110963967501177317426221, + 6614652990340435611114076169697104582524566019034036680161902142028967568142, + 19212515502973904821995111796203064175854996071497099383090983975618035391558, + 18664315914479294273286016871365663486061896605232511201418576829062292269769, + 11498264615058604317482574216318586415670903094838791165247179252175768794889, + 10814026414212439999107945133852431304483604215416531759535467355316227331774, + 17566185590731088197064706533119299946752127014428399631467913813769853431107, + 14016139747289624978792446847000951708158212463304817001882956166752906714332, + 8242601581342441750402731523736202888792436665415852106196418942315563860366, + 9244680976345080074252591214216060854998619670381671198295645618515047080988, + 12216779172735125538689875667307129262237123728082657485828359100719208190116, + 10702811721859145441471328511968332847175733707711670171718794132331147396634, + 6479667912792222539919362076122453947926362746906450079329453150607427372979, + 15117544653571553820496948522381772148324367479772362833334593000535648316185, + 6842203153996907264167856337497139692895299874139131328642472698663046726780, + 12732823292801537626009139514048596316076834307941224506504666470961250728055, + 6936272626871035740815028148058841877090860312517423346335878088297448888663, + 17297554111853491139852678417579991271009602631577069694853813331124433680030, + 16641596134749940573104316021365063031319260205559553673368334842484345864859, + 7400481189785154329569470986896455371037813715804007747228648863919991399081, + 2273205422216987330510475127669563545720586464429614439716564154166712854048, + 15162538063742142685306302282127534305212832649282186184583465569986719234456, + 5628039096440332922248578319648483863204530861778160259559031331287721255522, + 16085392195894691829567913404182676871326863890140775376809129785155092531260, + 14227467863135365427954093998621993651369686288941275436795622973781503444257, + 18224457394066545825553407391290108485121649197258948320896164404518684305122, + 274945154732293792784580363548970818611304339008964723447672490026510689427, + 11050822248291117548220126630860474473945266276626263036056336623671308219529, + 2119542016932434047340813757208803962484943912710204325088879681995922344971 + ]; + + var t; + signal t2[nrounds]; + signal t4[nrounds]; + signal xL[nrounds-1]; + signal xR[nrounds-1]; + + var c; + for (var i=0; iv4)rWUa_KZq*c8H34VuXGQ%T=28x5OP`Vs`UZQ`V;q zlKtvJP3M*6{~N>P|8V{nG~e)5XbS4aVxH$t;X;F|Gh1Py z?!j(_J5iwZaLE8LCg`(*gU(;QIEf);@w-br9x#@kW>3+vSvg(*W+FELnbZeUO%_@z zjPXev;5&D0C63`Q_f2J^Tc9g{eEQVA;v0d&DyAF7m$~J{iUO~_V(31p+w8;2#ydJ9 z*1GyjSm)Xl4oNivU)IDV_yY)LD9F+TeP2|%$)TrPn&`B0J+;#i-Sa1k!UC$xJ4S&H zm`Q_kvB+E-26}v$`YnWx?y(oo{!}hh*ifrw>K!?1YKSy6nsO4%W{pTMFNn zU$z(Pw#Rbd8nnWW%50vV2;xI2H=#D|qH)_Pv$^@)w--gI#pAQ%4xlP(3iO18J7cn@ zkEd?r-FrHza>W^GFx|4ej)2@dSrApiujU(>SKHRZ+0oU^A(J6+_PQ+liHDflu#2w; zBhxggkuS42KE7@u7hk8SmkDFsboPjgeD@Pf(Q)1IJRqWgItzjn>f2Of8v4!5!Wk$14 z#oszQy{**PIYo?YIHet97GGd!8BsYX@?#pA_}}GaVwp+5!~1j8e+$bzpUM5dc-eL_ zKY+Wz8C7X>l#Or+E6dYyxLTFhA*s_ty-<~{(VO3qgN_D3TVEAD4=(oL&qjIf{R{3y zn8;Z@zbzRGdS4=nlOgU^=Ye>#el~J>)FKp=2K>iAH(T%t9 zi&J{tPWzCZdU-oL8H?C5?4hx1=b`4lRG*V$mhvY?ObJ^76;XCd1Krjf)Q$#L(Gl8sja(d1 zt(6WguvN5x^1oAP0ahY~KdhOZa6xl&CZLn$cW@(a(uZu9HyAY*Qr>*dqAh33oJ(Zv z)4NYbuv+W{zrFG?c1iiz^PT)RzTciTb@T6G-r<+v{)PMeKU2U;Hm1}|dh>P4XD1T+ z$rAM%g(t3?!*$=-l#t1B4>KZ{)j>9bibb;2St^324?)z0d)<1+R6IrW2b0Jmy zJ+bD4sMD}5Qk zVmYLSQl}U^+rFx!b4h54cO5VJL^|U6+?7;wI<#pF#=hIU$e#^#;$oL6sKlwi8-GIO zJAnRV>N#-NykU}bNd=xMniT})>Y7PYq%r&*@<;JS`c?saW<9hXF^h`H0;^icLy~Ay zTFyMAG+Qmu-e=$r)$R)*&H{f6Vhp!Cl3nLiuzz%GuV6^yCAMn>mtPaG6!SD2dd zKCk+)+KH(BDpnnBXGWB+@q&Z)m^9}Zvm~u?i@2EN)pbhnMb`yq&unW$e3z}|v^qYF zy>N{z=K-(^@70fpb4_FrYRJcf!q!%jGw@cDt9S%2DUiCnf1e4!9WLh?2Van(1<6%R%c7$B5`2MZG8$HG*`XxsI z`cPWC_p9bh`z{T+BZq<>yb)m$3#?g$=G}&(y05D<%X#WV?X;o|68U zKX#VK%=GBl$kO{-#bdTp9@lP1$jwH(){tA^i$v)}P}Zi#WJA(?X=4N_BGHzAw%!VD znC+Z$x~E=__pvgs*M?aNWNrf5eJ;GeZ!qdrw3L8w?$p. +*/ + +pragma solidity >=0.7.0 <0.9.0; + +contract Roundabout{ + bool flag = false; + + Groth16Verifier public verifier; + + constructor() { + verifier= new Groth16Verifier(); + } + + function verify(uint[2] calldata _pA, uint[2][2] calldata _pB, uint[2] calldata _pC, uint[1] calldata _pubSignals) external returns(bool) { + + flag = verifier.verifyProof(_pA, _pB,_pC,_pubSignals); + return flag; + } + + function isSolved()external view returns (bool){ + return flag; + } + +} + +contract Groth16Verifier { + // Scalar field size + uint256 constant r = 21888242871839275222246405745257275088548364400416034343698204186575808495617; + // Base field size + uint256 constant q = 21888242871839275222246405745257275088696311157297823662689037894645226208583; + + // Verification Key data + uint256 constant alphax = 20491192805390485299153009773594534940189261866228447918068658471970481763042; + uint256 constant alphay = 9383485363053290200918347156157836566562967994039712273449902621266178545958; + uint256 constant betax1 = 4252822878758300859123897981450591353533073413197771768651442665752259397132; + uint256 constant betax2 = 6375614351688725206403948262868962793625744043794305715222011528459656738731; + uint256 constant betay1 = 21847035105528745403288232691147584728191162732299865338377159692350059136679; + uint256 constant betay2 = 10505242626370262277552901082094356697409835680220590971873171140371331206856; + uint256 constant gammax1 = 11559732032986387107991004021392285783925812861821192530917403151452391805634; + uint256 constant gammax2 = 10857046999023057135944570762232829481370756359578518086990519993285655852781; + uint256 constant gammay1 = 4082367875863433681332203403145435568316851327593401208105741076214120093531; + uint256 constant gammay2 = 8495653923123431417604973247489272438418190587263600148770280649306958101930; + uint256 constant deltax1 = 12146284314782868113433554710431633809045399478542263288421391814005310612244; + uint256 constant deltax2 = 21728013437513872625556762238517331092223856425739271864641998996982333907092; + uint256 constant deltay1 = 363574526751910392811347335952729501875319026382322946447817665177326094816; + uint256 constant deltay2 = 17198675488733232971841890931572977045377778709292301764093990711105796986493; + + + uint256 constant IC0x = 13419792952126840478673638963141122302587014622622604932857287263326639616934; + uint256 constant IC0y = 19551168072322013827838902144881159056853371311431373500839405163352846399976; + + uint256 constant IC1x = 20307339771029451491474674032727372515507048888836318967504414849042064633937; + uint256 constant IC1y = 9401931764668861050170218745300289496263152524845401471688659460238598401815; + + + // Memory data + uint16 constant pVk = 0; + uint16 constant pPairing = 128; + + uint16 constant pLastMem = 896; + + function verifyProof(uint[2] calldata _pA, uint[2][2] calldata _pB, uint[2] calldata _pC, uint[1] calldata _pubSignals) public view returns (bool) { + assembly { + function checkField(v) { + if iszero(lt(v, q)) { + mstore(0, 0) + return(0, 0x20) + } + } + + // G1 function to multiply a G1 value(x,y) to value in an address + function g1_mulAccC(pR, x, y, s) { + let success + let mIn := mload(0x40) + mstore(mIn, x) + mstore(add(mIn, 32), y) + mstore(add(mIn, 64), s) + + success := staticcall(sub(gas(), 2000), 7, mIn, 96, mIn, 64) + + if iszero(success) { + mstore(0, 0) + return(0, 0x20) + } + + mstore(add(mIn, 64), mload(pR)) + mstore(add(mIn, 96), mload(add(pR, 32))) + + success := staticcall(sub(gas(), 2000), 6, mIn, 128, pR, 64) + + if iszero(success) { + mstore(0, 0) + return(0, 0x20) + } + } + + function checkPairing(pA, pB, pC, pubSignals, pMem) -> isOk { + let _pPairing := add(pMem, pPairing) + let _pVk := add(pMem, pVk) + + mstore(_pVk, IC0x) + mstore(add(_pVk, 32), IC0y) + + // Compute the linear combination vk_x + + g1_mulAccC(_pVk, IC1x, IC1y, calldataload(add(pubSignals, 0))) + + + // -A + mstore(_pPairing, calldataload(pA)) + mstore(add(_pPairing, 32), mod(sub(q, calldataload(add(pA, 32))), q)) + + // B + mstore(add(_pPairing, 64), calldataload(pB)) + mstore(add(_pPairing, 96), calldataload(add(pB, 32))) + mstore(add(_pPairing, 128), calldataload(add(pB, 64))) + mstore(add(_pPairing, 160), calldataload(add(pB, 96))) + + // alpha1 + mstore(add(_pPairing, 192), alphax) + mstore(add(_pPairing, 224), alphay) + + // beta2 + mstore(add(_pPairing, 256), betax1) + mstore(add(_pPairing, 288), betax2) + mstore(add(_pPairing, 320), betay1) + mstore(add(_pPairing, 352), betay2) + + // vk_x + mstore(add(_pPairing, 384), mload(add(pMem, pVk))) + mstore(add(_pPairing, 416), mload(add(pMem, add(pVk, 32)))) + + + // gamma2 + mstore(add(_pPairing, 448), gammax1) + mstore(add(_pPairing, 480), gammax2) + mstore(add(_pPairing, 512), gammay1) + mstore(add(_pPairing, 544), gammay2) + + // C + mstore(add(_pPairing, 576), calldataload(pC)) + mstore(add(_pPairing, 608), calldataload(add(pC, 32))) + + // delta2 + mstore(add(_pPairing, 640), deltax1) + mstore(add(_pPairing, 672), deltax2) + mstore(add(_pPairing, 704), deltay1) + mstore(add(_pPairing, 736), deltay2) + + + let success := staticcall(sub(gas(), 2000), 8, _pPairing, 768, _pPairing, 0x20) + + isOk := and(success, mload(_pPairing)) + } + + let pMem := mload(0x40) + mstore(0x40, add(pMem, pLastMem)) + + // Validate that all evaluations 鈭?F + + checkField(calldataload(add(_pubSignals, 0))) + + checkField(calldataload(add(_pubSignals, 32))) + + + // Validate all evaluations + let isValid := checkPairing(_pA, _pB, _pC, _pubSignals, pMem) + + mstore(0, isValid) + return(0, 0x20) + } + } + } diff --git a/docs/crypto/zkCTF/day1/Roundabout/description.md b/docs/crypto/zkCTF/day1/Roundabout/description.md new file mode 100644 index 0000000..9e32e5e --- /dev/null +++ b/docs/crypto/zkCTF/day1/Roundabout/description.md @@ -0,0 +1,3 @@ +Roundabout + +Your girlfriend gives you a surprise for your 10th anniversary, contained in a box that guarded by a Circom circuit. She told you the key to open it is her birthday. But you just can't remember. Hope you find a way to see this gift (spoiler, it's the flag). \ No newline at end of file diff --git a/docs/crypto/zkCTF/day2/Is Zero/.gitignore b/docs/crypto/zkCTF/day2/Is Zero/.gitignore new file mode 100644 index 0000000..5a580a2 --- /dev/null +++ b/docs/crypto/zkCTF/day2/Is Zero/.gitignore @@ -0,0 +1,5 @@ +/target +Cargo.lock +param +proof +vk \ No newline at end of file diff --git a/docs/crypto/zkCTF/day2/Is Zero/Cargo.toml b/docs/crypto/zkCTF/day2/Is Zero/Cargo.toml new file mode 100644 index 0000000..71f7430 --- /dev/null +++ b/docs/crypto/zkCTF/day2/Is Zero/Cargo.toml @@ -0,0 +1,14 @@ +[package] +name = "iszero" +version = "0.1.0" +edition = "2021" + +# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html + +[dependencies] +backtrace = { version = "0.3", optional = true } +ff = "0.13" +halo2_proofs = { git = "https://github.com/privacy-scaling-explorations/halo2.git", default-features = true } +clap = "3.0" +halo2curves = { version = "0.6.0", default-features = false } +rand = "0.8" diff --git a/docs/crypto/zkCTF/day2/Is Zero/description.md b/docs/crypto/zkCTF/day2/Is Zero/description.md new file mode 100644 index 0000000..a0f4e3c --- /dev/null +++ b/docs/crypto/zkCTF/day2/Is Zero/description.md @@ -0,0 +1,22 @@ +# ZK CFT - Halo2 - Is Zero + +## Overview +1. This is a quiz about Halo2 usage. The standard answer would not be given to participants +2. Instead, a file would be given, with all necessary structs and missing logics. Participants are required to fill in the blanks, compile the program and run tests +3. Multiple test cases would be given, the prover program shall be tested against them + +## Problem description + +The is_zero circuit is an important component within the Halo2 zero-knowledge proof (ZKP) system, a common requirement is to prove that a certain value is zero without revealing the value itself. The is_zero circuit is designed to facilitate this need. It's a gadget or a sub-circuit that can be used within a larger circuit to prove that a given value is zero, which is crucial in various computations and conditional checks within a zero-knowledge proof system. + +Now you are required to simulate an is_zero checking in Halo2. When the input is zero, it should output 1, otherwise, it should output 0. + +## Comand +cargo run + +## Example +input == 0 and output == 1 +input == 2 and output == 0 + +## Solve +Sumbit is_zero.rs to solve the puzzle. diff --git a/docs/crypto/zkCTF/day2/Is Zero/src/is_zero.rs b/docs/crypto/zkCTF/day2/Is Zero/src/is_zero.rs new file mode 100644 index 0000000..37b3dd9 --- /dev/null +++ b/docs/crypto/zkCTF/day2/Is Zero/src/is_zero.rs @@ -0,0 +1,229 @@ +use std::marker::PhantomData; + +use halo2_proofs::halo2curves::ff::PrimeField; +use halo2_proofs::{ + arithmetic::Field, + circuit::{AssignedCell, Chip, Layouter, Region, SimpleFloorPlanner, Value}, + plonk::{Advice, Circuit, Column, ConstraintSystem, Error, Expression, Selector}, + poly::Rotation, +}; + +trait NumericInstructions: Chip { + /// Variable representing a number. + type Num; + + fn load_private( + &self, + layouter: impl Layouter, + v: &[Value], + ) -> Result, Error>; + + fn is_zero( + &self, + layouter: impl Layouter, + a: &[Self::Num], + b: &[Self::Num], + ) -> Result, Error>; +} + +/// The chip that will implement our instructions! Chips store their own +/// config, as well as type markers if necessary. +pub struct FieldChip { + config: FieldConfig, + _marker: PhantomData, +} + +/// Chip state is stored in a config struct. This is generated by the chip +/// during configuration, and then stored inside the chip. +#[derive(Clone, Debug)] +pub struct FieldConfig { + advice: [Column; 3], + s_is_zero: Selector, +} + +impl FieldChip { + fn construct(config: >::Config) -> Self { + Self { + config, + _marker: PhantomData, + } + } + + fn configure( + meta: &mut ConstraintSystem, + advice: [Column; 3], + ) -> >::Config { + for column in &advice { + meta.enable_equality(*column); + } + let s_is_zero = meta.selector(); + ///////////////////////// Please implement code here ///////////////////////// + // a | 1/a | 1 - a * 1/a + // #check 1: 1 - a * 1/a == 0 + // #check 2: a * 1/a == b + meta.create_gate("is zero", |meta| { + let a = meta.query_advice(advice[0], Rotation::cur()); + let a_inv = meta.query_advice(advice[1], Rotation::cur()); + let b = meta.query_advice(advice[2], Rotation::cur()); + let is_zero = meta.query_selector(s_is_zero); + + // 1 - a * 1/a + let one = Expression::Constant(F::one()); + let is_zero_expr = one - a * a_inv; + vec![ + is_zero.clone() * is_zero_expr.clone(), + is_zero.clone() * (b - is_zero_expr.clone()), + ] + }); + ///////////////////////// End implement ///////////////////////// + FieldConfig { advice, s_is_zero } + } +} + +impl Chip for FieldChip { + type Config = FieldConfig; + type Loaded = (); + + fn config(&self) -> &Self::Config { + &self.config + } + + fn loaded(&self) -> &Self::Loaded { + &() + } +} + +/// A variable representing a number. +#[derive(Clone)] +struct Number(AssignedCell); + +impl NumericInstructions for FieldChip { + type Num = Number; + + // load a set of private values into the circuit + fn load_private( + &self, + mut layouter: impl Layouter, + values: &[Value], + ) -> Result, Error> { + let config = self.config(); + + layouter.assign_region( + || "load private", + |mut region| { + values + .iter() + .enumerate() + .map(|(i, value)| { + region + .assign_advice(|| "private input", config.advice[0], i, || *value) + .map(Number) + }) + .collect() + }, + ) + } + + // return a set of AssignedCell + fn is_zero( + &self, + mut layouter: impl Layouter, + a: &[Self::Num], + b: &[Self::Num], + ) -> Result, Error> { + let config = self.config(); + assert_eq!(a.len(), b.len()); + + layouter.assign_region( + || "is_zero", + |mut region: Region<'_, F>| { + a.iter() + .zip(b.iter()) + .enumerate() + .map(|(i, (a, b))| { + ///////////////////////// Please implement code here ///////////////////////// + config.s_is_zero.enable(&mut region, i)?; + a.0.copy_advice(|| "copy constrain a", &mut region, config.advice[0], i); + let a_inv = a.0.value().map(|v| v.invert().unwrap_or(F::zero())); // 1/a if a != 0 else 0 + region.assign_advice(|| "a_inv", config.advice[1], i, || a_inv)?; + b.0.copy_advice(|| "copy constrain b", &mut region, config.advice[2], i) + .map(Number) + }) + .collect() + ///////////////////////// End implement ///////////////////////// + }, + ) + } +} + +#[derive(Default)] +pub struct MyCircuit { + pub a: Vec>, + pub b: Vec>, +} + +impl Circuit for MyCircuit { + // Since we are using a single chip for everything, we can just reuse its config. + type Config = FieldConfig; + type FloorPlanner = SimpleFloorPlanner; + + fn without_witnesses(&self) -> Self { + Self::default() + } + + fn configure(meta: &mut ConstraintSystem) -> Self::Config { + // We create the three advice columns that FieldChip uses for I/O. + let advice = [ + meta.advice_column(), + meta.advice_column(), + meta.advice_column(), + ]; + FieldChip::configure(meta, advice) + } + + fn synthesize( + &self, + config: Self::Config, + mut layouter: impl Layouter, + ) -> Result<(), Error> { + let field_chip = FieldChip::::construct(config); + + // Load our private values into the circuit. + let a = field_chip.load_private(layouter.namespace(|| "load a"), &self.a)?; + let b = field_chip.load_private(layouter.namespace(|| "load b"), &self.b)?; + + field_chip.is_zero(layouter.namespace(|| "is_zero"), &a, &b)?; + + Ok(()) + } +} + +pub fn get_example_circuit() -> MyCircuit { + let a = [F::from(0), F::from(2)]; + let b = [F::from(1), F::from(0)]; + + // Instantiate the circuit with private inputs. + MyCircuit { + a: a.iter().map(|&x| Value::known(x)).collect(), + b: b.iter().map(|&x| Value::known(x)).collect(), + } +} + +#[test] +fn is_zero_circuit_test() { + use halo2_proofs::dev::MockProver; + use halo2curves::pasta::Fp; + + let k = 4; + + // good case 0 : input == 0 and output ==1 + // good case 1 : (input == 2 and output == 0) + let a = [Fp::from(0), Fp::from(2)]; + let b = [Fp::from(1), Fp::from(0)]; + let circuit = MyCircuit { + a: a.iter().map(|&x| Value::known(x)).collect(), + b: b.iter().map(|&x| Value::known(x)).collect(), + }; + let prover = MockProver::run(k, &circuit, vec![]).unwrap(); + assert_eq!(prover.verify(), Ok(())); +} diff --git a/docs/crypto/zkCTF/day2/Is Zero/src/lib.rs b/docs/crypto/zkCTF/day2/Is Zero/src/lib.rs new file mode 100644 index 0000000..b12a1ca --- /dev/null +++ b/docs/crypto/zkCTF/day2/Is Zero/src/lib.rs @@ -0,0 +1 @@ +pub mod is_zero; diff --git a/docs/crypto/zkCTF/day2/Mixer/Challenge.sol b/docs/crypto/zkCTF/day2/Mixer/Challenge.sol new file mode 100644 index 0000000..57ad867 --- /dev/null +++ b/docs/crypto/zkCTF/day2/Mixer/Challenge.sol @@ -0,0 +1,16 @@ +// SPDX-License-Identifier: UNLICENSED +pragma solidity ^0.8.20; + +import {IMixer} from "./interfaces/IMixer.sol"; + +contract Challenge { + IMixer public immutable MIXER; + + constructor(IMixer mixer) { + MIXER = mixer; + } + + function isSolved() external view returns (bool) { + return address(MIXER).balance == 0; + } +} diff --git a/docs/crypto/zkCTF/day2/Mixer/MerkleTreeLib.sol b/docs/crypto/zkCTF/day2/Mixer/MerkleTreeLib.sol new file mode 100644 index 0000000..1ad5dc3 --- /dev/null +++ b/docs/crypto/zkCTF/day2/Mixer/MerkleTreeLib.sol @@ -0,0 +1,119 @@ +// SPDX-License-Identifier: UNLICENSED +pragma solidity ^0.8.20; + +import {PoseidonT3} from "./PoseidonT3.sol"; + +struct MerkleTreeStruct { + uint256 depth; + uint256 root; + uint256 numberOfLeaves; + mapping(uint256 => uint256[2]) lastSubtrees; +} + +library MerkleTreeLib { + uint256 constant SNARK_SCALAR_FIELD = 21888242871839275222246405745257275088548364400416034343698204186575808495617; + uint256 constant MAX_DEPTH = 32; + + error TreeIsFull(); + error InvalidFieldValue(uint256 value); + error InvalidTreeDepth(uint256 depth); + + // default zero values for each tree depth + uint256 internal constant Z_0 = 0; + uint256 internal constant Z_1 = 14744269619966411208579211824598458697587494354926760081771325075741142829156; + uint256 internal constant Z_2 = 7423237065226347324353380772367382631490014989348495481811164164159255474657; + uint256 internal constant Z_3 = 11286972368698509976183087595462810875513684078608517520839298933882497716792; + uint256 internal constant Z_4 = 3607627140608796879659380071776844901612302623152076817094415224584923813162; + uint256 internal constant Z_5 = 19712377064642672829441595136074946683621277828620209496774504837737984048981; + uint256 internal constant Z_6 = 20775607673010627194014556968476266066927294572720319469184847051418138353016; + uint256 internal constant Z_7 = 3396914609616007258851405644437304192397291162432396347162513310381425243293; + uint256 internal constant Z_8 = 21551820661461729022865262380882070649935529853313286572328683688269863701601; + uint256 internal constant Z_9 = 6573136701248752079028194407151022595060682063033565181951145966236778420039; + uint256 internal constant Z_10 = 12413880268183407374852357075976609371175688755676981206018884971008854919922; + uint256 internal constant Z_11 = 14271763308400718165336499097156975241954733520325982997864342600795471836726; + uint256 internal constant Z_12 = 20066985985293572387227381049700832219069292839614107140851619262827735677018; + uint256 internal constant Z_13 = 9394776414966240069580838672673694685292165040808226440647796406499139370960; + uint256 internal constant Z_14 = 11331146992410411304059858900317123658895005918277453009197229807340014528524; + uint256 internal constant Z_15 = 15819538789928229930262697811477882737253464456578333862691129291651619515538; + uint256 internal constant Z_16 = 19217088683336594659449020493828377907203207941212636669271704950158751593251; + uint256 internal constant Z_17 = 21035245323335827719745544373081896983162834604456827698288649288827293579666; + uint256 internal constant Z_18 = 6939770416153240137322503476966641397417391950902474480970945462551409848591; + uint256 internal constant Z_19 = 10941962436777715901943463195175331263348098796018438960955633645115732864202; + uint256 internal constant Z_20 = 15019797232609675441998260052101280400536945603062888308240081994073687793470; + uint256 internal constant Z_21 = 11702828337982203149177882813338547876343922920234831094975924378932809409969; + uint256 internal constant Z_22 = 11217067736778784455593535811108456786943573747466706329920902520905755780395; + uint256 internal constant Z_23 = 16072238744996205792852194127671441602062027943016727953216607508365787157389; + uint256 internal constant Z_24 = 17681057402012993898104192736393849603097507831571622013521167331642182653248; + uint256 internal constant Z_25 = 21694045479371014653083846597424257852691458318143380497809004364947786214945; + uint256 internal constant Z_26 = 8163447297445169709687354538480474434591144168767135863541048304198280615192; + uint256 internal constant Z_27 = 14081762237856300239452543304351251708585712948734528663957353575674639038357; + uint256 internal constant Z_28 = 16619959921569409661790279042024627172199214148318086837362003702249041851090; + uint256 internal constant Z_29 = 7022159125197495734384997711896547675021391130223237843255817587255104160365; + uint256 internal constant Z_30 = 4114686047564160449611603615418567457008101555090703535405891656262658644463; + uint256 internal constant Z_31 = 12549363297364877722388257367377629555213421373705596078299904496781819142130; + uint256 internal constant Z_32 = 21443572485391568159800782191812935835534334817699172242223315142338162256601; + + function defaultZeroVal(uint256 index) internal pure returns (uint256) { + if (index == 0) return Z_0; + if (index == 1) return Z_1; + if (index == 2) return Z_2; + if (index == 3) return Z_3; + if (index == 4) return Z_4; + if (index == 5) return Z_5; + if (index == 6) return Z_6; + if (index == 7) return Z_7; + if (index == 8) return Z_8; + if (index == 9) return Z_9; + if (index == 10) return Z_10; + if (index == 11) return Z_11; + if (index == 12) return Z_12; + if (index == 13) return Z_13; + if (index == 14) return Z_14; + if (index == 15) return Z_15; + if (index == 16) return Z_16; + if (index == 17) return Z_17; + if (index == 18) return Z_18; + if (index == 19) return Z_19; + if (index == 20) return Z_20; + if (index == 21) return Z_21; + if (index == 22) return Z_22; + if (index == 23) return Z_23; + if (index == 24) return Z_24; + revert InvalidTreeDepth(index); + } + + function init(MerkleTreeStruct storage tree, uint256 depth) internal { + if (depth <= 0 || depth > MAX_DEPTH) revert InvalidTreeDepth(depth); + + tree.depth = depth; + tree.root = defaultZeroVal(depth); + } + + function insert(MerkleTreeStruct storage tree, uint256 leaf) internal returns (uint256) { + if (leaf >= SNARK_SCALAR_FIELD) revert InvalidFieldValue(leaf); + + uint256 depth = tree.depth; + uint256 leafIndex = tree.numberOfLeaves; + if (leafIndex >= 2 ** depth) revert TreeIsFull(); + + uint256 hash = leaf; + for (uint8 i; i < depth;) { + if (leafIndex & 1 == 0) { + tree.lastSubtrees[i] = [hash, defaultZeroVal(i)]; + } else { + tree.lastSubtrees[i][1] = hash; + } + + hash = PoseidonT3.hash(tree.lastSubtrees[i]); + leafIndex >>= 1; + + unchecked { + ++i; + } + } + + tree.root = hash; + tree.numberOfLeaves += 1; + return hash; + } +} diff --git a/docs/crypto/zkCTF/day2/Mixer/Mixer.sol b/docs/crypto/zkCTF/day2/Mixer/Mixer.sol new file mode 100644 index 0000000..a4d9a6a --- /dev/null +++ b/docs/crypto/zkCTF/day2/Mixer/Mixer.sol @@ -0,0 +1,84 @@ +// SPDX-License-Identifier: UNLICENSED +pragma solidity ^0.8.20; + +import {IVerifier} from "./interfaces/IVerifier.sol"; +import {IMixer} from "./interfaces/IMixer.sol"; +import {Verifier} from "./Verifier.sol"; +import {MerkleTreeLib, MerkleTreeStruct} from "./MerkleTreeLib.sol"; + +contract Mixer is IMixer { + using MerkleTreeLib for MerkleTreeStruct; + + uint256 public constant TREE_DEPTH = 20; + uint256 public constant AMOUNT = 1 ether; + Verifier public immutable VERIFIER; + + MerkleTreeStruct public tree; + mapping(uint256 => bool) public commitments; + mapping(uint256 => bool) public nullifiers; + + error InvalidAmount(uint256 amount); + error CommitmentExists(uint256 commitment); + error NullifierExists(uint256 nullifier); + error InvalidRoot(uint256 root); + error InvalidProof(); + error TransferFailed(); + + event Deposit(uint256 commitment, uint256 root); + event Withdraw(uint256 nullifier, address sender, address recipient); + + constructor() { + VERIFIER = new Verifier(); + tree.init(TREE_DEPTH); + } + + function deposit(uint256 commitment) external payable { + if (msg.value != AMOUNT) revert InvalidAmount(msg.value); + if (commitments[commitment]) revert CommitmentExists(commitment); + + uint256 root = tree.insert(commitment); + commitments[commitment] = true; + + emit Deposit(commitment, root); + } + + function withdraw( + uint256[2] calldata pA, + uint256[2][2] calldata pB, + uint256[2] calldata pC, + uint256 nullifier, + uint256 root, + address recipient + ) external { + if (tree.root != root) revert InvalidRoot(root); + if (nullifiers[nullifier]) revert NullifierExists(nullifier); + + if (!verifyProof(pA, pB, pC, nullifier, root, recipient)) revert InvalidProof(); + + nullifiers[nullifier] = true; + + (bool success,) = recipient.call{value: AMOUNT}(""); + if (!success) revert TransferFailed(); + + emit Withdraw(nullifier, msg.sender, recipient); + } + + function getRoot() external view returns (uint256) { + return tree.root; + } + + function getNumberOfLeaves() external view returns (uint256) { + return tree.numberOfLeaves; + } + + function verifyProof( + uint256[2] calldata pA, + uint256[2][2] calldata pB, + uint256[2] calldata pC, + uint256 nullifier, + uint256 root, + address recipient + ) public view returns (bool) { + return VERIFIER.verifyProof(pA, pB, pC, nullifier, root, uint256(uint160(recipient))); + } +} diff --git a/docs/crypto/zkCTF/day2/Mixer/PoseidonT3.sol b/docs/crypto/zkCTF/day2/Mixer/PoseidonT3.sol new file mode 100644 index 0000000..fd0b967 --- /dev/null +++ b/docs/crypto/zkCTF/day2/Mixer/PoseidonT3.sol @@ -0,0 +1,1372 @@ +/// SPDX-License-Identifier: MIT +pragma solidity ^0.8.20; + +library PoseidonT3 { + uint256 constant M00 = 0x109b7f411ba0e4c9b2b70caf5c36a7b194be7c11ad24378bfedb68592ba8118b; + uint256 constant M01 = 0x2969f27eed31a480b9c36c764379dbca2cc8fdd1415c3dded62940bcde0bd771; + uint256 constant M02 = 0x143021ec686a3f330d5f9e654638065ce6cd79e28c5b3753326244ee65a1b1a7; + uint256 constant M10 = 0x16ed41e13bb9c0c66ae119424fddbcbc9314dc9fdbdeea55d6c64543dc4903e0; + uint256 constant M11 = 0x2e2419f9ec02ec394c9871c832963dc1b89d743c8c7b964029b2311687b1fe23; + uint256 constant M12 = 0x176cc029695ad02582a70eff08a6fd99d057e12e58e7d7b6b16cdfabc8ee2911; + + // See here for a simplified implementation: https://github.com/vimwitch/poseidon-solidity/blob/e57becdabb65d99fdc586fe1e1e09e7108202d53/contracts/Poseidon.sol#L40 + // Based on: https://github.com/iden3/circomlibjs/blob/v0.0.8/src/poseidon_slow.js + function hash(uint256[2] memory) public pure returns (uint256) { + assembly { + let F := 21888242871839275222246405745257275088548364400416034343698204186575808495617 + let M20 := 0x2b90bba00fca0589f617e7dcbfe82e0df706ab640ceb247b791a93b74e36736d + let M21 := 0x101071f0032379b697315876690f053d148d4e109f5fb065c8aacc55a0f89bfa + let M22 := 0x19a3fc0a56702bf417ba7fee3802593fa644470307043f7773279cd71d25d5e0 + // load the inputs from memory + let state0 + let scratch0 + let state1 + let scratch1 + let state2 + let scratch2 + + state1 := addmod(mload(0x80), 0x00f1445235f2148c5986587169fc1bcd887b08d4d00868df5696fff40956e864, F) + state2 := addmod(mload(0xa0), 0x08dff3487e8ac99e1f29a058d0fa80b930c728730b7ab36ce879f3890ecf73f5, F) + scratch0 := mulmod(state1, state1, F) + state1 := mulmod(mulmod(scratch0, scratch0, F), state1, F) + scratch0 := mulmod(state2, state2, F) + state2 := mulmod(mulmod(scratch0, scratch0, F), state2, F) + scratch0 := + addmod( + 0x2f27be690fdaee46c3ce28f7532b13c856c35342c84bda6e20966310fadc01d0, + addmod( + addmod( + 15452833169820924772166449970675545095234312153403844297388521437673434406763, + mulmod(state1, M10, F), + F + ), + mulmod(state2, M20, F), + F + ), + F + ) + scratch1 := + addmod( + 0x2b2ae1acf68b7b8d2416bebf3d4f6234b763fe04b8043ee48b8327bebca16cf2, + addmod( + addmod( + 18674271267752038776579386132900109523609358935013267566297499497165104279117, + mulmod(state1, M11, F), + F + ), + mulmod(state2, M21, F), + F + ), + F + ) + scratch2 := + addmod( + 0x0319d062072bef7ecca5eac06f97d4d55952c175ab6b03eae64b44c7dbf11cfa, + addmod( + addmod( + 14817777843080276494683266178512808687156649753153012854386334860566696099579, + mulmod(state1, M12, F), + F + ), + mulmod(state2, M22, F), + F + ), + F + ) + state0 := mulmod(scratch0, scratch0, F) + scratch0 := mulmod(mulmod(state0, state0, F), scratch0, F) + state0 := mulmod(scratch1, scratch1, F) + scratch1 := mulmod(mulmod(state0, state0, F), scratch1, F) + state0 := mulmod(scratch2, scratch2, F) + scratch2 := mulmod(mulmod(state0, state0, F), scratch2, F) + state0 := + addmod( + 0x28813dcaebaeaa828a376df87af4a63bc8b7bf27ad49c6298ef7b387bf28526d, + addmod(addmod(mulmod(scratch0, M00, F), mulmod(scratch1, M10, F), F), mulmod(scratch2, M20, F), F), + F + ) + state1 := + addmod( + 0x2727673b2ccbc903f181bf38e1c1d40d2033865200c352bc150928adddf9cb78, + addmod(addmod(mulmod(scratch0, M01, F), mulmod(scratch1, M11, F), F), mulmod(scratch2, M21, F), F), + F + ) + state2 := + addmod( + 0x234ec45ca27727c2e74abd2b2a1494cd6efbd43e340587d6b8fb9e31e65cc632, + addmod(addmod(mulmod(scratch0, M02, F), mulmod(scratch1, M12, F), F), mulmod(scratch2, M22, F), F), + F + ) + scratch0 := mulmod(state0, state0, F) + state0 := mulmod(mulmod(scratch0, scratch0, F), state0, F) + scratch0 := mulmod(state1, state1, F) + state1 := mulmod(mulmod(scratch0, scratch0, F), state1, F) + scratch0 := mulmod(state2, state2, F) + state2 := mulmod(mulmod(scratch0, scratch0, F), state2, F) + scratch0 := + addmod( + 0x15b52534031ae18f7f862cb2cf7cf760ab10a8150a337b1ccd99ff6e8797d428, + addmod(addmod(mulmod(state0, M00, F), mulmod(state1, M10, F), F), mulmod(state2, M20, F), F), + F + ) + scratch1 := + addmod( + 0x0dc8fad6d9e4b35f5ed9a3d186b79ce38e0e8a8d1b58b132d701d4eecf68d1f6, + addmod(addmod(mulmod(state0, M01, F), mulmod(state1, M11, F), F), mulmod(state2, M21, F), F), + F + ) + scratch2 := + addmod( + 0x1bcd95ffc211fbca600f705fad3fb567ea4eb378f62e1fec97805518a47e4d9c, + addmod(addmod(mulmod(state0, M02, F), mulmod(state1, M12, F), F), mulmod(state2, M22, F), F), + F + ) + state0 := mulmod(scratch0, scratch0, F) + scratch0 := mulmod(mulmod(state0, state0, F), scratch0, F) + state0 := mulmod(scratch1, scratch1, F) + scratch1 := mulmod(mulmod(state0, state0, F), scratch1, F) + state0 := mulmod(scratch2, scratch2, F) + scratch2 := mulmod(mulmod(state0, state0, F), scratch2, F) + state0 := + addmod( + 0x10520b0ab721cadfe9eff81b016fc34dc76da36c2578937817cb978d069de559, + addmod(addmod(mulmod(scratch0, M00, F), mulmod(scratch1, M10, F), F), mulmod(scratch2, M20, F), F), + F + ) + state1 := + addmod( + 0x1f6d48149b8e7f7d9b257d8ed5fbbaf42932498075fed0ace88a9eb81f5627f6, + addmod(addmod(mulmod(scratch0, M01, F), mulmod(scratch1, M11, F), F), mulmod(scratch2, M21, F), F), + F + ) + state2 := + addmod( + 0x1d9655f652309014d29e00ef35a2089bfff8dc1c816f0dc9ca34bdb5460c8705, + addmod(addmod(mulmod(scratch0, M02, F), mulmod(scratch1, M12, F), F), mulmod(scratch2, M22, F), F), + F + ) + scratch0 := mulmod(state0, state0, F) + state0 := mulmod(mulmod(scratch0, scratch0, F), state0, F) + scratch0 := + addmod( + 0x04df5a56ff95bcafb051f7b1cd43a99ba731ff67e47032058fe3d4185697cc7d, + addmod(addmod(mulmod(state0, M00, F), mulmod(state1, M10, F), F), mulmod(state2, M20, F), F), + F + ) + scratch1 := + addmod( + 0x0672d995f8fff640151b3d290cedaf148690a10a8c8424a7f6ec282b6e4be828, + addmod(addmod(mulmod(state0, M01, F), mulmod(state1, M11, F), F), mulmod(state2, M21, F), F), + F + ) + scratch2 := + addmod( + 0x099952b414884454b21200d7ffafdd5f0c9a9dcc06f2708e9fc1d8209b5c75b9, + addmod(addmod(mulmod(state0, M02, F), mulmod(state1, M12, F), F), mulmod(state2, M22, F), F), + F + ) + state0 := mulmod(scratch0, scratch0, F) + scratch0 := mulmod(mulmod(state0, state0, F), scratch0, F) + state0 := + addmod( + 0x052cba2255dfd00c7c483143ba8d469448e43586a9b4cd9183fd0e843a6b9fa6, + addmod(addmod(mulmod(scratch0, M00, F), mulmod(scratch1, M10, F), F), mulmod(scratch2, M20, F), F), + F + ) + state1 := + addmod( + 0x0b8badee690adb8eb0bd74712b7999af82de55707251ad7716077cb93c464ddc, + addmod(addmod(mulmod(scratch0, M01, F), mulmod(scratch1, M11, F), F), mulmod(scratch2, M21, F), F), + F + ) + state2 := + addmod( + 0x119b1590f13307af5a1ee651020c07c749c15d60683a8050b963d0a8e4b2bdd1, + addmod(addmod(mulmod(scratch0, M02, F), mulmod(scratch1, M12, F), F), mulmod(scratch2, M22, F), F), + F + ) + scratch0 := mulmod(state0, state0, F) + state0 := mulmod(mulmod(scratch0, scratch0, F), state0, F) + scratch0 := + addmod( + 0x03150b7cd6d5d17b2529d36be0f67b832c4acfc884ef4ee5ce15be0bfb4a8d09, + addmod(addmod(mulmod(state0, M00, F), mulmod(state1, M10, F), F), mulmod(state2, M20, F), F), + F + ) + scratch1 := + addmod( + 0x2cc6182c5e14546e3cf1951f173912355374efb83d80898abe69cb317c9ea565, + addmod(addmod(mulmod(state0, M01, F), mulmod(state1, M11, F), F), mulmod(state2, M21, F), F), + F + ) + scratch2 := + addmod( + 0x005032551e6378c450cfe129a404b3764218cadedac14e2b92d2cd73111bf0f9, + addmod(addmod(mulmod(state0, M02, F), mulmod(state1, M12, F), F), mulmod(state2, M22, F), F), + F + ) + state0 := mulmod(scratch0, scratch0, F) + scratch0 := mulmod(mulmod(state0, state0, F), scratch0, F) + state0 := + addmod( + 0x233237e3289baa34bb147e972ebcb9516469c399fcc069fb88f9da2cc28276b5, + addmod(addmod(mulmod(scratch0, M00, F), mulmod(scratch1, M10, F), F), mulmod(scratch2, M20, F), F), + F + ) + state1 := + addmod( + 0x05c8f4f4ebd4a6e3c980d31674bfbe6323037f21b34ae5a4e80c2d4c24d60280, + addmod(addmod(mulmod(scratch0, M01, F), mulmod(scratch1, M11, F), F), mulmod(scratch2, M21, F), F), + F + ) + state2 := + addmod( + 0x0a7b1db13042d396ba05d818a319f25252bcf35ef3aeed91ee1f09b2590fc65b, + addmod(addmod(mulmod(scratch0, M02, F), mulmod(scratch1, M12, F), F), mulmod(scratch2, M22, F), F), + F + ) + scratch0 := mulmod(state0, state0, F) + state0 := mulmod(mulmod(scratch0, scratch0, F), state0, F) + scratch0 := + addmod( + 0x2a73b71f9b210cf5b14296572c9d32dbf156e2b086ff47dc5df542365a404ec0, + addmod(addmod(mulmod(state0, M00, F), mulmod(state1, M10, F), F), mulmod(state2, M20, F), F), + F + ) + scratch1 := + addmod( + 0x1ac9b0417abcc9a1935107e9ffc91dc3ec18f2c4dbe7f22976a760bb5c50c460, + addmod(addmod(mulmod(state0, M01, F), mulmod(state1, M11, F), F), mulmod(state2, M21, F), F), + F + ) + scratch2 := + addmod( + 0x12c0339ae08374823fabb076707ef479269f3e4d6cb104349015ee046dc93fc0, + addmod(addmod(mulmod(state0, M02, F), mulmod(state1, M12, F), F), mulmod(state2, M22, F), F), + F + ) + state0 := mulmod(scratch0, scratch0, F) + scratch0 := mulmod(mulmod(state0, state0, F), scratch0, F) + state0 := + addmod( + 0x0b7475b102a165ad7f5b18db4e1e704f52900aa3253baac68246682e56e9a28e, + addmod(addmod(mulmod(scratch0, M00, F), mulmod(scratch1, M10, F), F), mulmod(scratch2, M20, F), F), + F + ) + state1 := + addmod( + 0x037c2849e191ca3edb1c5e49f6e8b8917c843e379366f2ea32ab3aa88d7f8448, + addmod(addmod(mulmod(scratch0, M01, F), mulmod(scratch1, M11, F), F), mulmod(scratch2, M21, F), F), + F + ) + state2 := + addmod( + 0x05a6811f8556f014e92674661e217e9bd5206c5c93a07dc145fdb176a716346f, + addmod(addmod(mulmod(scratch0, M02, F), mulmod(scratch1, M12, F), F), mulmod(scratch2, M22, F), F), + F + ) + scratch0 := mulmod(state0, state0, F) + state0 := mulmod(mulmod(scratch0, scratch0, F), state0, F) + scratch0 := + addmod( + 0x29a795e7d98028946e947b75d54e9f044076e87a7b2883b47b675ef5f38bd66e, + addmod(addmod(mulmod(state0, M00, F), mulmod(state1, M10, F), F), mulmod(state2, M20, F), F), + F + ) + scratch1 := + addmod( + 0x20439a0c84b322eb45a3857afc18f5826e8c7382c8a1585c507be199981fd22f, + addmod(addmod(mulmod(state0, M01, F), mulmod(state1, M11, F), F), mulmod(state2, M21, F), F), + F + ) + scratch2 := + addmod( + 0x2e0ba8d94d9ecf4a94ec2050c7371ff1bb50f27799a84b6d4a2a6f2a0982c887, + addmod(addmod(mulmod(state0, M02, F), mulmod(state1, M12, F), F), mulmod(state2, M22, F), F), + F + ) + state0 := mulmod(scratch0, scratch0, F) + scratch0 := mulmod(mulmod(state0, state0, F), scratch0, F) + state0 := + addmod( + 0x143fd115ce08fb27ca38eb7cce822b4517822cd2109048d2e6d0ddcca17d71c8, + addmod(addmod(mulmod(scratch0, M00, F), mulmod(scratch1, M10, F), F), mulmod(scratch2, M20, F), F), + F + ) + state1 := + addmod( + 0x0c64cbecb1c734b857968dbbdcf813cdf8611659323dbcbfc84323623be9caf1, + addmod(addmod(mulmod(scratch0, M01, F), mulmod(scratch1, M11, F), F), mulmod(scratch2, M21, F), F), + F + ) + state2 := + addmod( + 0x028a305847c683f646fca925c163ff5ae74f348d62c2b670f1426cef9403da53, + addmod(addmod(mulmod(scratch0, M02, F), mulmod(scratch1, M12, F), F), mulmod(scratch2, M22, F), F), + F + ) + scratch0 := mulmod(state0, state0, F) + state0 := mulmod(mulmod(scratch0, scratch0, F), state0, F) + scratch0 := + addmod( + 0x2e4ef510ff0b6fda5fa940ab4c4380f26a6bcb64d89427b824d6755b5db9e30c, + addmod(addmod(mulmod(state0, M00, F), mulmod(state1, M10, F), F), mulmod(state2, M20, F), F), + F + ) + scratch1 := + addmod( + 0x0081c95bc43384e663d79270c956ce3b8925b4f6d033b078b96384f50579400e, + addmod(addmod(mulmod(state0, M01, F), mulmod(state1, M11, F), F), mulmod(state2, M21, F), F), + F + ) + scratch2 := + addmod( + 0x2ed5f0c91cbd9749187e2fade687e05ee2491b349c039a0bba8a9f4023a0bb38, + addmod(addmod(mulmod(state0, M02, F), mulmod(state1, M12, F), F), mulmod(state2, M22, F), F), + F + ) + state0 := mulmod(scratch0, scratch0, F) + scratch0 := mulmod(mulmod(state0, state0, F), scratch0, F) + state0 := + addmod( + 0x30509991f88da3504bbf374ed5aae2f03448a22c76234c8c990f01f33a735206, + addmod(addmod(mulmod(scratch0, M00, F), mulmod(scratch1, M10, F), F), mulmod(scratch2, M20, F), F), + F + ) + state1 := + addmod( + 0x1c3f20fd55409a53221b7c4d49a356b9f0a1119fb2067b41a7529094424ec6ad, + addmod(addmod(mulmod(scratch0, M01, F), mulmod(scratch1, M11, F), F), mulmod(scratch2, M21, F), F), + F + ) + state2 := + addmod( + 0x10b4e7f3ab5df003049514459b6e18eec46bb2213e8e131e170887b47ddcb96c, + addmod(addmod(mulmod(scratch0, M02, F), mulmod(scratch1, M12, F), F), mulmod(scratch2, M22, F), F), + F + ) + scratch0 := mulmod(state0, state0, F) + state0 := mulmod(mulmod(scratch0, scratch0, F), state0, F) + scratch0 := + addmod( + 0x2a1982979c3ff7f43ddd543d891c2abddd80f804c077d775039aa3502e43adef, + addmod(addmod(mulmod(state0, M00, F), mulmod(state1, M10, F), F), mulmod(state2, M20, F), F), + F + ) + scratch1 := + addmod( + 0x1c74ee64f15e1db6feddbead56d6d55dba431ebc396c9af95cad0f1315bd5c91, + addmod(addmod(mulmod(state0, M01, F), mulmod(state1, M11, F), F), mulmod(state2, M21, F), F), + F + ) + scratch2 := + addmod( + 0x07533ec850ba7f98eab9303cace01b4b9e4f2e8b82708cfa9c2fe45a0ae146a0, + addmod(addmod(mulmod(state0, M02, F), mulmod(state1, M12, F), F), mulmod(state2, M22, F), F), + F + ) + state0 := mulmod(scratch0, scratch0, F) + scratch0 := mulmod(mulmod(state0, state0, F), scratch0, F) + state0 := + addmod( + 0x21576b438e500449a151e4eeaf17b154285c68f42d42c1808a11abf3764c0750, + addmod(addmod(mulmod(scratch0, M00, F), mulmod(scratch1, M10, F), F), mulmod(scratch2, M20, F), F), + F + ) + state1 := + addmod( + 0x2f17c0559b8fe79608ad5ca193d62f10bce8384c815f0906743d6930836d4a9e, + addmod(addmod(mulmod(scratch0, M01, F), mulmod(scratch1, M11, F), F), mulmod(scratch2, M21, F), F), + F + ) + state2 := + addmod( + 0x2d477e3862d07708a79e8aae946170bc9775a4201318474ae665b0b1b7e2730e, + addmod(addmod(mulmod(scratch0, M02, F), mulmod(scratch1, M12, F), F), mulmod(scratch2, M22, F), F), + F + ) + scratch0 := mulmod(state0, state0, F) + state0 := mulmod(mulmod(scratch0, scratch0, F), state0, F) + scratch0 := + addmod( + 0x162f5243967064c390e095577984f291afba2266c38f5abcd89be0f5b2747eab, + addmod(addmod(mulmod(state0, M00, F), mulmod(state1, M10, F), F), mulmod(state2, M20, F), F), + F + ) + scratch1 := + addmod( + 0x2b4cb233ede9ba48264ecd2c8ae50d1ad7a8596a87f29f8a7777a70092393311, + addmod(addmod(mulmod(state0, M01, F), mulmod(state1, M11, F), F), mulmod(state2, M21, F), F), + F + ) + scratch2 := + addmod( + 0x2c8fbcb2dd8573dc1dbaf8f4622854776db2eece6d85c4cf4254e7c35e03b07a, + addmod(addmod(mulmod(state0, M02, F), mulmod(state1, M12, F), F), mulmod(state2, M22, F), F), + F + ) + state0 := mulmod(scratch0, scratch0, F) + scratch0 := mulmod(mulmod(state0, state0, F), scratch0, F) + state0 := + addmod( + 0x1d6f347725e4816af2ff453f0cd56b199e1b61e9f601e9ade5e88db870949da9, + addmod(addmod(mulmod(scratch0, M00, F), mulmod(scratch1, M10, F), F), mulmod(scratch2, M20, F), F), + F + ) + state1 := + addmod( + 0x204b0c397f4ebe71ebc2d8b3df5b913df9e6ac02b68d31324cd49af5c4565529, + addmod(addmod(mulmod(scratch0, M01, F), mulmod(scratch1, M11, F), F), mulmod(scratch2, M21, F), F), + F + ) + state2 := + addmod( + 0x0c4cb9dc3c4fd8174f1149b3c63c3c2f9ecb827cd7dc25534ff8fb75bc79c502, + addmod(addmod(mulmod(scratch0, M02, F), mulmod(scratch1, M12, F), F), mulmod(scratch2, M22, F), F), + F + ) + scratch0 := mulmod(state0, state0, F) + state0 := mulmod(mulmod(scratch0, scratch0, F), state0, F) + scratch0 := + addmod( + 0x174ad61a1448c899a25416474f4930301e5c49475279e0639a616ddc45bc7b54, + addmod(addmod(mulmod(state0, M00, F), mulmod(state1, M10, F), F), mulmod(state2, M20, F), F), + F + ) + scratch1 := + addmod( + 0x1a96177bcf4d8d89f759df4ec2f3cde2eaaa28c177cc0fa13a9816d49a38d2ef, + addmod(addmod(mulmod(state0, M01, F), mulmod(state1, M11, F), F), mulmod(state2, M21, F), F), + F + ) + scratch2 := + addmod( + 0x066d04b24331d71cd0ef8054bc60c4ff05202c126a233c1a8242ace360b8a30a, + addmod(addmod(mulmod(state0, M02, F), mulmod(state1, M12, F), F), mulmod(state2, M22, F), F), + F + ) + state0 := mulmod(scratch0, scratch0, F) + scratch0 := mulmod(mulmod(state0, state0, F), scratch0, F) + state0 := + addmod( + 0x2a4c4fc6ec0b0cf52195782871c6dd3b381cc65f72e02ad527037a62aa1bd804, + addmod(addmod(mulmod(scratch0, M00, F), mulmod(scratch1, M10, F), F), mulmod(scratch2, M20, F), F), + F + ) + state1 := + addmod( + 0x13ab2d136ccf37d447e9f2e14a7cedc95e727f8446f6d9d7e55afc01219fd649, + addmod(addmod(mulmod(scratch0, M01, F), mulmod(scratch1, M11, F), F), mulmod(scratch2, M21, F), F), + F + ) + state2 := + addmod( + 0x1121552fca26061619d24d843dc82769c1b04fcec26f55194c2e3e869acc6a9a, + addmod(addmod(mulmod(scratch0, M02, F), mulmod(scratch1, M12, F), F), mulmod(scratch2, M22, F), F), + F + ) + scratch0 := mulmod(state0, state0, F) + state0 := mulmod(mulmod(scratch0, scratch0, F), state0, F) + scratch0 := + addmod( + 0x00ef653322b13d6c889bc81715c37d77a6cd267d595c4a8909a5546c7c97cff1, + addmod(addmod(mulmod(state0, M00, F), mulmod(state1, M10, F), F), mulmod(state2, M20, F), F), + F + ) + scratch1 := + addmod( + 0x0e25483e45a665208b261d8ba74051e6400c776d652595d9845aca35d8a397d3, + addmod(addmod(mulmod(state0, M01, F), mulmod(state1, M11, F), F), mulmod(state2, M21, F), F), + F + ) + scratch2 := + addmod( + 0x29f536dcb9dd7682245264659e15d88e395ac3d4dde92d8c46448db979eeba89, + addmod(addmod(mulmod(state0, M02, F), mulmod(state1, M12, F), F), mulmod(state2, M22, F), F), + F + ) + state0 := mulmod(scratch0, scratch0, F) + scratch0 := mulmod(mulmod(state0, state0, F), scratch0, F) + state0 := + addmod( + 0x2a56ef9f2c53febadfda33575dbdbd885a124e2780bbea170e456baace0fa5be, + addmod(addmod(mulmod(scratch0, M00, F), mulmod(scratch1, M10, F), F), mulmod(scratch2, M20, F), F), + F + ) + state1 := + addmod( + 0x1c8361c78eb5cf5decfb7a2d17b5c409f2ae2999a46762e8ee416240a8cb9af1, + addmod(addmod(mulmod(scratch0, M01, F), mulmod(scratch1, M11, F), F), mulmod(scratch2, M21, F), F), + F + ) + state2 := + addmod( + 0x151aff5f38b20a0fc0473089aaf0206b83e8e68a764507bfd3d0ab4be74319c5, + addmod(addmod(mulmod(scratch0, M02, F), mulmod(scratch1, M12, F), F), mulmod(scratch2, M22, F), F), + F + ) + scratch0 := mulmod(state0, state0, F) + state0 := mulmod(mulmod(scratch0, scratch0, F), state0, F) + scratch0 := + addmod( + 0x04c6187e41ed881dc1b239c88f7f9d43a9f52fc8c8b6cdd1e76e47615b51f100, + addmod(addmod(mulmod(state0, M00, F), mulmod(state1, M10, F), F), mulmod(state2, M20, F), F), + F + ) + scratch1 := + addmod( + 0x13b37bd80f4d27fb10d84331f6fb6d534b81c61ed15776449e801b7ddc9c2967, + addmod(addmod(mulmod(state0, M01, F), mulmod(state1, M11, F), F), mulmod(state2, M21, F), F), + F + ) + scratch2 := + addmod( + 0x01a5c536273c2d9df578bfbd32c17b7a2ce3664c2a52032c9321ceb1c4e8a8e4, + addmod(addmod(mulmod(state0, M02, F), mulmod(state1, M12, F), F), mulmod(state2, M22, F), F), + F + ) + state0 := mulmod(scratch0, scratch0, F) + scratch0 := mulmod(mulmod(state0, state0, F), scratch0, F) + state0 := + addmod( + 0x2ab3561834ca73835ad05f5d7acb950b4a9a2c666b9726da832239065b7c3b02, + addmod(addmod(mulmod(scratch0, M00, F), mulmod(scratch1, M10, F), F), mulmod(scratch2, M20, F), F), + F + ) + state1 := + addmod( + 0x1d4d8ec291e720db200fe6d686c0d613acaf6af4e95d3bf69f7ed516a597b646, + addmod(addmod(mulmod(scratch0, M01, F), mulmod(scratch1, M11, F), F), mulmod(scratch2, M21, F), F), + F + ) + state2 := + addmod( + 0x041294d2cc484d228f5784fe7919fd2bb925351240a04b711514c9c80b65af1d, + addmod(addmod(mulmod(scratch0, M02, F), mulmod(scratch1, M12, F), F), mulmod(scratch2, M22, F), F), + F + ) + scratch0 := mulmod(state0, state0, F) + state0 := mulmod(mulmod(scratch0, scratch0, F), state0, F) + scratch0 := + addmod( + 0x154ac98e01708c611c4fa715991f004898f57939d126e392042971dd90e81fc6, + addmod(addmod(mulmod(state0, M00, F), mulmod(state1, M10, F), F), mulmod(state2, M20, F), F), + F + ) + scratch1 := + addmod( + 0x0b339d8acca7d4f83eedd84093aef51050b3684c88f8b0b04524563bc6ea4da4, + addmod(addmod(mulmod(state0, M01, F), mulmod(state1, M11, F), F), mulmod(state2, M21, F), F), + F + ) + scratch2 := + addmod( + 0x0955e49e6610c94254a4f84cfbab344598f0e71eaff4a7dd81ed95b50839c82e, + addmod(addmod(mulmod(state0, M02, F), mulmod(state1, M12, F), F), mulmod(state2, M22, F), F), + F + ) + state0 := mulmod(scratch0, scratch0, F) + scratch0 := mulmod(mulmod(state0, state0, F), scratch0, F) + state0 := + addmod( + 0x06746a6156eba54426b9e22206f15abca9a6f41e6f535c6f3525401ea0654626, + addmod(addmod(mulmod(scratch0, M00, F), mulmod(scratch1, M10, F), F), mulmod(scratch2, M20, F), F), + F + ) + state1 := + addmod( + 0x0f18f5a0ecd1423c496f3820c549c27838e5790e2bd0a196ac917c7ff32077fb, + addmod(addmod(mulmod(scratch0, M01, F), mulmod(scratch1, M11, F), F), mulmod(scratch2, M21, F), F), + F + ) + state2 := + addmod( + 0x04f6eeca1751f7308ac59eff5beb261e4bb563583ede7bc92a738223d6f76e13, + addmod(addmod(mulmod(scratch0, M02, F), mulmod(scratch1, M12, F), F), mulmod(scratch2, M22, F), F), + F + ) + scratch0 := mulmod(state0, state0, F) + state0 := mulmod(mulmod(scratch0, scratch0, F), state0, F) + scratch0 := + addmod( + 0x2b56973364c4c4f5c1a3ec4da3cdce038811eb116fb3e45bc1768d26fc0b3758, + addmod(addmod(mulmod(state0, M00, F), mulmod(state1, M10, F), F), mulmod(state2, M20, F), F), + F + ) + scratch1 := + addmod( + 0x123769dd49d5b054dcd76b89804b1bcb8e1392b385716a5d83feb65d437f29ef, + addmod(addmod(mulmod(state0, M01, F), mulmod(state1, M11, F), F), mulmod(state2, M21, F), F), + F + ) + scratch2 := + addmod( + 0x2147b424fc48c80a88ee52b91169aacea989f6446471150994257b2fb01c63e9, + addmod(addmod(mulmod(state0, M02, F), mulmod(state1, M12, F), F), mulmod(state2, M22, F), F), + F + ) + state0 := mulmod(scratch0, scratch0, F) + scratch0 := mulmod(mulmod(state0, state0, F), scratch0, F) + state0 := + addmod( + 0x0fdc1f58548b85701a6c5505ea332a29647e6f34ad4243c2ea54ad897cebe54d, + addmod(addmod(mulmod(scratch0, M00, F), mulmod(scratch1, M10, F), F), mulmod(scratch2, M20, F), F), + F + ) + state1 := + addmod( + 0x12373a8251fea004df68abcf0f7786d4bceff28c5dbbe0c3944f685cc0a0b1f2, + addmod(addmod(mulmod(scratch0, M01, F), mulmod(scratch1, M11, F), F), mulmod(scratch2, M21, F), F), + F + ) + state2 := + addmod( + 0x21e4f4ea5f35f85bad7ea52ff742c9e8a642756b6af44203dd8a1f35c1a90035, + addmod(addmod(mulmod(scratch0, M02, F), mulmod(scratch1, M12, F), F), mulmod(scratch2, M22, F), F), + F + ) + scratch0 := mulmod(state0, state0, F) + state0 := mulmod(mulmod(scratch0, scratch0, F), state0, F) + scratch0 := + addmod( + 0x16243916d69d2ca3dfb4722224d4c462b57366492f45e90d8a81934f1bc3b147, + addmod(addmod(mulmod(state0, M00, F), mulmod(state1, M10, F), F), mulmod(state2, M20, F), F), + F + ) + scratch1 := + addmod( + 0x1efbe46dd7a578b4f66f9adbc88b4378abc21566e1a0453ca13a4159cac04ac2, + addmod(addmod(mulmod(state0, M01, F), mulmod(state1, M11, F), F), mulmod(state2, M21, F), F), + F + ) + scratch2 := + addmod( + 0x07ea5e8537cf5dd08886020e23a7f387d468d5525be66f853b672cc96a88969a, + addmod(addmod(mulmod(state0, M02, F), mulmod(state1, M12, F), F), mulmod(state2, M22, F), F), + F + ) + state0 := mulmod(scratch0, scratch0, F) + scratch0 := mulmod(mulmod(state0, state0, F), scratch0, F) + state0 := + addmod( + 0x05a8c4f9968b8aa3b7b478a30f9a5b63650f19a75e7ce11ca9fe16c0b76c00bc, + addmod(addmod(mulmod(scratch0, M00, F), mulmod(scratch1, M10, F), F), mulmod(scratch2, M20, F), F), + F + ) + state1 := + addmod( + 0x20f057712cc21654fbfe59bd345e8dac3f7818c701b9c7882d9d57b72a32e83f, + addmod(addmod(mulmod(scratch0, M01, F), mulmod(scratch1, M11, F), F), mulmod(scratch2, M21, F), F), + F + ) + state2 := + addmod( + 0x04a12ededa9dfd689672f8c67fee31636dcd8e88d01d49019bd90b33eb33db69, + addmod(addmod(mulmod(scratch0, M02, F), mulmod(scratch1, M12, F), F), mulmod(scratch2, M22, F), F), + F + ) + scratch0 := mulmod(state0, state0, F) + state0 := mulmod(mulmod(scratch0, scratch0, F), state0, F) + scratch0 := + addmod( + 0x27e88d8c15f37dcee44f1e5425a51decbd136ce5091a6767e49ec9544ccd101a, + addmod(addmod(mulmod(state0, M00, F), mulmod(state1, M10, F), F), mulmod(state2, M20, F), F), + F + ) + scratch1 := + addmod( + 0x2feed17b84285ed9b8a5c8c5e95a41f66e096619a7703223176c41ee433de4d1, + addmod(addmod(mulmod(state0, M01, F), mulmod(state1, M11, F), F), mulmod(state2, M21, F), F), + F + ) + scratch2 := + addmod( + 0x1ed7cc76edf45c7c404241420f729cf394e5942911312a0d6972b8bd53aff2b8, + addmod(addmod(mulmod(state0, M02, F), mulmod(state1, M12, F), F), mulmod(state2, M22, F), F), + F + ) + state0 := mulmod(scratch0, scratch0, F) + scratch0 := mulmod(mulmod(state0, state0, F), scratch0, F) + state0 := + addmod( + 0x15742e99b9bfa323157ff8c586f5660eac6783476144cdcadf2874be45466b1a, + addmod(addmod(mulmod(scratch0, M00, F), mulmod(scratch1, M10, F), F), mulmod(scratch2, M20, F), F), + F + ) + state1 := + addmod( + 0x1aac285387f65e82c895fc6887ddf40577107454c6ec0317284f033f27d0c785, + addmod(addmod(mulmod(scratch0, M01, F), mulmod(scratch1, M11, F), F), mulmod(scratch2, M21, F), F), + F + ) + state2 := + addmod( + 0x25851c3c845d4790f9ddadbdb6057357832e2e7a49775f71ec75a96554d67c77, + addmod(addmod(mulmod(scratch0, M02, F), mulmod(scratch1, M12, F), F), mulmod(scratch2, M22, F), F), + F + ) + scratch0 := mulmod(state0, state0, F) + state0 := mulmod(mulmod(scratch0, scratch0, F), state0, F) + scratch0 := + addmod( + 0x15a5821565cc2ec2ce78457db197edf353b7ebba2c5523370ddccc3d9f146a67, + addmod(addmod(mulmod(state0, M00, F), mulmod(state1, M10, F), F), mulmod(state2, M20, F), F), + F + ) + scratch1 := + addmod( + 0x2411d57a4813b9980efa7e31a1db5966dcf64f36044277502f15485f28c71727, + addmod(addmod(mulmod(state0, M01, F), mulmod(state1, M11, F), F), mulmod(state2, M21, F), F), + F + ) + scratch2 := + addmod( + 0x002e6f8d6520cd4713e335b8c0b6d2e647e9a98e12f4cd2558828b5ef6cb4c9b, + addmod(addmod(mulmod(state0, M02, F), mulmod(state1, M12, F), F), mulmod(state2, M22, F), F), + F + ) + state0 := mulmod(scratch0, scratch0, F) + scratch0 := mulmod(mulmod(state0, state0, F), scratch0, F) + state0 := + addmod( + 0x2ff7bc8f4380cde997da00b616b0fcd1af8f0e91e2fe1ed7398834609e0315d2, + addmod(addmod(mulmod(scratch0, M00, F), mulmod(scratch1, M10, F), F), mulmod(scratch2, M20, F), F), + F + ) + state1 := + addmod( + 0x00b9831b948525595ee02724471bcd182e9521f6b7bb68f1e93be4febb0d3cbe, + addmod(addmod(mulmod(scratch0, M01, F), mulmod(scratch1, M11, F), F), mulmod(scratch2, M21, F), F), + F + ) + state2 := + addmod( + 0x0a2f53768b8ebf6a86913b0e57c04e011ca408648a4743a87d77adbf0c9c3512, + addmod(addmod(mulmod(scratch0, M02, F), mulmod(scratch1, M12, F), F), mulmod(scratch2, M22, F), F), + F + ) + scratch0 := mulmod(state0, state0, F) + state0 := mulmod(mulmod(scratch0, scratch0, F), state0, F) + scratch0 := + addmod( + 0x00248156142fd0373a479f91ff239e960f599ff7e94be69b7f2a290305e1198d, + addmod(addmod(mulmod(state0, M00, F), mulmod(state1, M10, F), F), mulmod(state2, M20, F), F), + F + ) + scratch1 := + addmod( + 0x171d5620b87bfb1328cf8c02ab3f0c9a397196aa6a542c2350eb512a2b2bcda9, + addmod(addmod(mulmod(state0, M01, F), mulmod(state1, M11, F), F), mulmod(state2, M21, F), F), + F + ) + scratch2 := + addmod( + 0x170a4f55536f7dc970087c7c10d6fad760c952172dd54dd99d1045e4ec34a808, + addmod(addmod(mulmod(state0, M02, F), mulmod(state1, M12, F), F), mulmod(state2, M22, F), F), + F + ) + state0 := mulmod(scratch0, scratch0, F) + scratch0 := mulmod(mulmod(state0, state0, F), scratch0, F) + state0 := + addmod( + 0x29aba33f799fe66c2ef3134aea04336ecc37e38c1cd211ba482eca17e2dbfae1, + addmod(addmod(mulmod(scratch0, M00, F), mulmod(scratch1, M10, F), F), mulmod(scratch2, M20, F), F), + F + ) + state1 := + addmod( + 0x1e9bc179a4fdd758fdd1bb1945088d47e70d114a03f6a0e8b5ba650369e64973, + addmod(addmod(mulmod(scratch0, M01, F), mulmod(scratch1, M11, F), F), mulmod(scratch2, M21, F), F), + F + ) + state2 := + addmod( + 0x1dd269799b660fad58f7f4892dfb0b5afeaad869a9c4b44f9c9e1c43bdaf8f09, + addmod(addmod(mulmod(scratch0, M02, F), mulmod(scratch1, M12, F), F), mulmod(scratch2, M22, F), F), + F + ) + scratch0 := mulmod(state0, state0, F) + state0 := mulmod(mulmod(scratch0, scratch0, F), state0, F) + scratch0 := + addmod( + 0x22cdbc8b70117ad1401181d02e15459e7ccd426fe869c7c95d1dd2cb0f24af38, + addmod(addmod(mulmod(state0, M00, F), mulmod(state1, M10, F), F), mulmod(state2, M20, F), F), + F + ) + scratch1 := + addmod( + 0x0ef042e454771c533a9f57a55c503fcefd3150f52ed94a7cd5ba93b9c7dacefd, + addmod(addmod(mulmod(state0, M01, F), mulmod(state1, M11, F), F), mulmod(state2, M21, F), F), + F + ) + scratch2 := + addmod( + 0x11609e06ad6c8fe2f287f3036037e8851318e8b08a0359a03b304ffca62e8284, + addmod(addmod(mulmod(state0, M02, F), mulmod(state1, M12, F), F), mulmod(state2, M22, F), F), + F + ) + state0 := mulmod(scratch0, scratch0, F) + scratch0 := mulmod(mulmod(state0, state0, F), scratch0, F) + state0 := + addmod( + 0x1166d9e554616dba9e753eea427c17b7fecd58c076dfe42708b08f5b783aa9af, + addmod(addmod(mulmod(scratch0, M00, F), mulmod(scratch1, M10, F), F), mulmod(scratch2, M20, F), F), + F + ) + state1 := + addmod( + 0x2de52989431a859593413026354413db177fbf4cd2ac0b56f855a888357ee466, + addmod(addmod(mulmod(scratch0, M01, F), mulmod(scratch1, M11, F), F), mulmod(scratch2, M21, F), F), + F + ) + state2 := + addmod( + 0x3006eb4ffc7a85819a6da492f3a8ac1df51aee5b17b8e89d74bf01cf5f71e9ad, + addmod(addmod(mulmod(scratch0, M02, F), mulmod(scratch1, M12, F), F), mulmod(scratch2, M22, F), F), + F + ) + scratch0 := mulmod(state0, state0, F) + state0 := mulmod(mulmod(scratch0, scratch0, F), state0, F) + scratch0 := + addmod( + 0x2af41fbb61ba8a80fdcf6fff9e3f6f422993fe8f0a4639f962344c8225145086, + addmod(addmod(mulmod(state0, M00, F), mulmod(state1, M10, F), F), mulmod(state2, M20, F), F), + F + ) + scratch1 := + addmod( + 0x119e684de476155fe5a6b41a8ebc85db8718ab27889e85e781b214bace4827c3, + addmod(addmod(mulmod(state0, M01, F), mulmod(state1, M11, F), F), mulmod(state2, M21, F), F), + F + ) + scratch2 := + addmod( + 0x1835b786e2e8925e188bea59ae363537b51248c23828f047cff784b97b3fd800, + addmod(addmod(mulmod(state0, M02, F), mulmod(state1, M12, F), F), mulmod(state2, M22, F), F), + F + ) + state0 := mulmod(scratch0, scratch0, F) + scratch0 := mulmod(mulmod(state0, state0, F), scratch0, F) + state0 := + addmod( + 0x28201a34c594dfa34d794996c6433a20d152bac2a7905c926c40e285ab32eeb6, + addmod(addmod(mulmod(scratch0, M00, F), mulmod(scratch1, M10, F), F), mulmod(scratch2, M20, F), F), + F + ) + state1 := + addmod( + 0x083efd7a27d1751094e80fefaf78b000864c82eb571187724a761f88c22cc4e7, + addmod(addmod(mulmod(scratch0, M01, F), mulmod(scratch1, M11, F), F), mulmod(scratch2, M21, F), F), + F + ) + state2 := + addmod( + 0x0b6f88a3577199526158e61ceea27be811c16df7774dd8519e079564f61fd13b, + addmod(addmod(mulmod(scratch0, M02, F), mulmod(scratch1, M12, F), F), mulmod(scratch2, M22, F), F), + F + ) + scratch0 := mulmod(state0, state0, F) + state0 := mulmod(mulmod(scratch0, scratch0, F), state0, F) + scratch0 := + addmod( + 0x0ec868e6d15e51d9644f66e1d6471a94589511ca00d29e1014390e6ee4254f5b, + addmod(addmod(mulmod(state0, M00, F), mulmod(state1, M10, F), F), mulmod(state2, M20, F), F), + F + ) + scratch1 := + addmod( + 0x2af33e3f866771271ac0c9b3ed2e1142ecd3e74b939cd40d00d937ab84c98591, + addmod(addmod(mulmod(state0, M01, F), mulmod(state1, M11, F), F), mulmod(state2, M21, F), F), + F + ) + scratch2 := + addmod( + 0x0b520211f904b5e7d09b5d961c6ace7734568c547dd6858b364ce5e47951f178, + addmod(addmod(mulmod(state0, M02, F), mulmod(state1, M12, F), F), mulmod(state2, M22, F), F), + F + ) + state0 := mulmod(scratch0, scratch0, F) + scratch0 := mulmod(mulmod(state0, state0, F), scratch0, F) + state0 := + addmod( + 0x0b2d722d0919a1aad8db58f10062a92ea0c56ac4270e822cca228620188a1d40, + addmod(addmod(mulmod(scratch0, M00, F), mulmod(scratch1, M10, F), F), mulmod(scratch2, M20, F), F), + F + ) + state1 := + addmod( + 0x1f790d4d7f8cf094d980ceb37c2453e957b54a9991ca38bbe0061d1ed6e562d4, + addmod(addmod(mulmod(scratch0, M01, F), mulmod(scratch1, M11, F), F), mulmod(scratch2, M21, F), F), + F + ) + state2 := + addmod( + 0x0171eb95dfbf7d1eaea97cd385f780150885c16235a2a6a8da92ceb01e504233, + addmod(addmod(mulmod(scratch0, M02, F), mulmod(scratch1, M12, F), F), mulmod(scratch2, M22, F), F), + F + ) + scratch0 := mulmod(state0, state0, F) + state0 := mulmod(mulmod(scratch0, scratch0, F), state0, F) + scratch0 := + addmod( + 0x0c2d0e3b5fd57549329bf6885da66b9b790b40defd2c8650762305381b168873, + addmod(addmod(mulmod(state0, M00, F), mulmod(state1, M10, F), F), mulmod(state2, M20, F), F), + F + ) + scratch1 := + addmod( + 0x1162fb28689c27154e5a8228b4e72b377cbcafa589e283c35d3803054407a18d, + addmod(addmod(mulmod(state0, M01, F), mulmod(state1, M11, F), F), mulmod(state2, M21, F), F), + F + ) + scratch2 := + addmod( + 0x2f1459b65dee441b64ad386a91e8310f282c5a92a89e19921623ef8249711bc0, + addmod(addmod(mulmod(state0, M02, F), mulmod(state1, M12, F), F), mulmod(state2, M22, F), F), + F + ) + state0 := mulmod(scratch0, scratch0, F) + scratch0 := mulmod(mulmod(state0, state0, F), scratch0, F) + state0 := + addmod( + 0x1e6ff3216b688c3d996d74367d5cd4c1bc489d46754eb712c243f70d1b53cfbb, + addmod(addmod(mulmod(scratch0, M00, F), mulmod(scratch1, M10, F), F), mulmod(scratch2, M20, F), F), + F + ) + state1 := + addmod( + 0x01ca8be73832b8d0681487d27d157802d741a6f36cdc2a0576881f9326478875, + addmod(addmod(mulmod(scratch0, M01, F), mulmod(scratch1, M11, F), F), mulmod(scratch2, M21, F), F), + F + ) + state2 := + addmod( + 0x1f7735706ffe9fc586f976d5bdf223dc680286080b10cea00b9b5de315f9650e, + addmod(addmod(mulmod(scratch0, M02, F), mulmod(scratch1, M12, F), F), mulmod(scratch2, M22, F), F), + F + ) + scratch0 := mulmod(state0, state0, F) + state0 := mulmod(mulmod(scratch0, scratch0, F), state0, F) + scratch0 := + addmod( + 0x2522b60f4ea3307640a0c2dce041fba921ac10a3d5f096ef4745ca838285f019, + addmod(addmod(mulmod(state0, M00, F), mulmod(state1, M10, F), F), mulmod(state2, M20, F), F), + F + ) + scratch1 := + addmod( + 0x23f0bee001b1029d5255075ddc957f833418cad4f52b6c3f8ce16c235572575b, + addmod(addmod(mulmod(state0, M01, F), mulmod(state1, M11, F), F), mulmod(state2, M21, F), F), + F + ) + scratch2 := + addmod( + 0x2bc1ae8b8ddbb81fcaac2d44555ed5685d142633e9df905f66d9401093082d59, + addmod(addmod(mulmod(state0, M02, F), mulmod(state1, M12, F), F), mulmod(state2, M22, F), F), + F + ) + state0 := mulmod(scratch0, scratch0, F) + scratch0 := mulmod(mulmod(state0, state0, F), scratch0, F) + state0 := + addmod( + 0x0f9406b8296564a37304507b8dba3ed162371273a07b1fc98011fcd6ad72205f, + addmod(addmod(mulmod(scratch0, M00, F), mulmod(scratch1, M10, F), F), mulmod(scratch2, M20, F), F), + F + ) + state1 := + addmod( + 0x2360a8eb0cc7defa67b72998de90714e17e75b174a52ee4acb126c8cd995f0a8, + addmod(addmod(mulmod(scratch0, M01, F), mulmod(scratch1, M11, F), F), mulmod(scratch2, M21, F), F), + F + ) + state2 := + addmod( + 0x15871a5cddead976804c803cbaef255eb4815a5e96df8b006dcbbc2767f88948, + addmod(addmod(mulmod(scratch0, M02, F), mulmod(scratch1, M12, F), F), mulmod(scratch2, M22, F), F), + F + ) + scratch0 := mulmod(state0, state0, F) + state0 := mulmod(mulmod(scratch0, scratch0, F), state0, F) + scratch0 := + addmod( + 0x193a56766998ee9e0a8652dd2f3b1da0362f4f54f72379544f957ccdeefb420f, + addmod(addmod(mulmod(state0, M00, F), mulmod(state1, M10, F), F), mulmod(state2, M20, F), F), + F + ) + scratch1 := + addmod( + 0x2a394a43934f86982f9be56ff4fab1703b2e63c8ad334834e4309805e777ae0f, + addmod(addmod(mulmod(state0, M01, F), mulmod(state1, M11, F), F), mulmod(state2, M21, F), F), + F + ) + scratch2 := + addmod( + 0x1859954cfeb8695f3e8b635dcb345192892cd11223443ba7b4166e8876c0d142, + addmod(addmod(mulmod(state0, M02, F), mulmod(state1, M12, F), F), mulmod(state2, M22, F), F), + F + ) + state0 := mulmod(scratch0, scratch0, F) + scratch0 := mulmod(mulmod(state0, state0, F), scratch0, F) + state0 := + addmod( + 0x04e1181763050e58013444dbcb99f1902b11bc25d90bbdca408d3819f4fed32b, + addmod(addmod(mulmod(scratch0, M00, F), mulmod(scratch1, M10, F), F), mulmod(scratch2, M20, F), F), + F + ) + state1 := + addmod( + 0x0fdb253dee83869d40c335ea64de8c5bb10eb82db08b5e8b1f5e5552bfd05f23, + addmod(addmod(mulmod(scratch0, M01, F), mulmod(scratch1, M11, F), F), mulmod(scratch2, M21, F), F), + F + ) + state2 := + addmod( + 0x058cbe8a9a5027bdaa4efb623adead6275f08686f1c08984a9d7c5bae9b4f1c0, + addmod(addmod(mulmod(scratch0, M02, F), mulmod(scratch1, M12, F), F), mulmod(scratch2, M22, F), F), + F + ) + scratch0 := mulmod(state0, state0, F) + state0 := mulmod(mulmod(scratch0, scratch0, F), state0, F) + scratch0 := + addmod( + 0x1382edce9971e186497eadb1aeb1f52b23b4b83bef023ab0d15228b4cceca59a, + addmod(addmod(mulmod(state0, M00, F), mulmod(state1, M10, F), F), mulmod(state2, M20, F), F), + F + ) + scratch1 := + addmod( + 0x03464990f045c6ee0819ca51fd11b0be7f61b8eb99f14b77e1e6634601d9e8b5, + addmod(addmod(mulmod(state0, M01, F), mulmod(state1, M11, F), F), mulmod(state2, M21, F), F), + F + ) + scratch2 := + addmod( + 0x23f7bfc8720dc296fff33b41f98ff83c6fcab4605db2eb5aaa5bc137aeb70a58, + addmod(addmod(mulmod(state0, M02, F), mulmod(state1, M12, F), F), mulmod(state2, M22, F), F), + F + ) + state0 := mulmod(scratch0, scratch0, F) + scratch0 := mulmod(mulmod(state0, state0, F), scratch0, F) + state0 := + addmod( + 0x0a59a158e3eec2117e6e94e7f0e9decf18c3ffd5e1531a9219636158bbaf62f2, + addmod(addmod(mulmod(scratch0, M00, F), mulmod(scratch1, M10, F), F), mulmod(scratch2, M20, F), F), + F + ) + state1 := + addmod( + 0x06ec54c80381c052b58bf23b312ffd3ce2c4eba065420af8f4c23ed0075fd07b, + addmod(addmod(mulmod(scratch0, M01, F), mulmod(scratch1, M11, F), F), mulmod(scratch2, M21, F), F), + F + ) + state2 := + addmod( + 0x118872dc832e0eb5476b56648e867ec8b09340f7a7bcb1b4962f0ff9ed1f9d01, + addmod(addmod(mulmod(scratch0, M02, F), mulmod(scratch1, M12, F), F), mulmod(scratch2, M22, F), F), + F + ) + scratch0 := mulmod(state0, state0, F) + state0 := mulmod(mulmod(scratch0, scratch0, F), state0, F) + scratch0 := + addmod( + 0x13d69fa127d834165ad5c7cba7ad59ed52e0b0f0e42d7fea95e1906b520921b1, + addmod(addmod(mulmod(state0, M00, F), mulmod(state1, M10, F), F), mulmod(state2, M20, F), F), + F + ) + scratch1 := + addmod( + 0x169a177f63ea681270b1c6877a73d21bde143942fb71dc55fd8a49f19f10c77b, + addmod(addmod(mulmod(state0, M01, F), mulmod(state1, M11, F), F), mulmod(state2, M21, F), F), + F + ) + scratch2 := + addmod( + 0x04ef51591c6ead97ef42f287adce40d93abeb032b922f66ffb7e9a5a7450544d, + addmod(addmod(mulmod(state0, M02, F), mulmod(state1, M12, F), F), mulmod(state2, M22, F), F), + F + ) + state0 := mulmod(scratch0, scratch0, F) + scratch0 := mulmod(mulmod(state0, state0, F), scratch0, F) + state0 := + addmod( + 0x256e175a1dc079390ecd7ca703fb2e3b19ec61805d4f03ced5f45ee6dd0f69ec, + addmod(addmod(mulmod(scratch0, M00, F), mulmod(scratch1, M10, F), F), mulmod(scratch2, M20, F), F), + F + ) + state1 := + addmod( + 0x30102d28636abd5fe5f2af412ff6004f75cc360d3205dd2da002813d3e2ceeb2, + addmod(addmod(mulmod(scratch0, M01, F), mulmod(scratch1, M11, F), F), mulmod(scratch2, M21, F), F), + F + ) + state2 := + addmod( + 0x10998e42dfcd3bbf1c0714bc73eb1bf40443a3fa99bef4a31fd31be182fcc792, + addmod(addmod(mulmod(scratch0, M02, F), mulmod(scratch1, M12, F), F), mulmod(scratch2, M22, F), F), + F + ) + scratch0 := mulmod(state0, state0, F) + state0 := mulmod(mulmod(scratch0, scratch0, F), state0, F) + scratch0 := + addmod( + 0x193edd8e9fcf3d7625fa7d24b598a1d89f3362eaf4d582efecad76f879e36860, + addmod(addmod(mulmod(state0, M00, F), mulmod(state1, M10, F), F), mulmod(state2, M20, F), F), + F + ) + scratch1 := + addmod( + 0x18168afd34f2d915d0368ce80b7b3347d1c7a561ce611425f2664d7aa51f0b5d, + addmod(addmod(mulmod(state0, M01, F), mulmod(state1, M11, F), F), mulmod(state2, M21, F), F), + F + ) + scratch2 := + addmod( + 0x29383c01ebd3b6ab0c017656ebe658b6a328ec77bc33626e29e2e95b33ea6111, + addmod(addmod(mulmod(state0, M02, F), mulmod(state1, M12, F), F), mulmod(state2, M22, F), F), + F + ) + state0 := mulmod(scratch0, scratch0, F) + scratch0 := mulmod(mulmod(state0, state0, F), scratch0, F) + state0 := + addmod( + 0x10646d2f2603de39a1f4ae5e7771a64a702db6e86fb76ab600bf573f9010c711, + addmod(addmod(mulmod(scratch0, M00, F), mulmod(scratch1, M10, F), F), mulmod(scratch2, M20, F), F), + F + ) + state1 := + addmod( + 0x0beb5e07d1b27145f575f1395a55bf132f90c25b40da7b3864d0242dcb1117fb, + addmod(addmod(mulmod(scratch0, M01, F), mulmod(scratch1, M11, F), F), mulmod(scratch2, M21, F), F), + F + ) + state2 := + addmod( + 0x16d685252078c133dc0d3ecad62b5c8830f95bb2e54b59abdffbf018d96fa336, + addmod(addmod(mulmod(scratch0, M02, F), mulmod(scratch1, M12, F), F), mulmod(scratch2, M22, F), F), + F + ) + scratch0 := mulmod(state0, state0, F) + state0 := mulmod(mulmod(scratch0, scratch0, F), state0, F) + scratch0 := + addmod( + 0x0a6abd1d833938f33c74154e0404b4b40a555bbbec21ddfafd672dd62047f01a, + addmod(addmod(mulmod(state0, M00, F), mulmod(state1, M10, F), F), mulmod(state2, M20, F), F), + F + ) + scratch1 := + addmod( + 0x1a679f5d36eb7b5c8ea12a4c2dedc8feb12dffeec450317270a6f19b34cf1860, + addmod(addmod(mulmod(state0, M01, F), mulmod(state1, M11, F), F), mulmod(state2, M21, F), F), + F + ) + scratch2 := + addmod( + 0x0980fb233bd456c23974d50e0ebfde4726a423eada4e8f6ffbc7592e3f1b93d6, + addmod(addmod(mulmod(state0, M02, F), mulmod(state1, M12, F), F), mulmod(state2, M22, F), F), + F + ) + state0 := mulmod(scratch0, scratch0, F) + scratch0 := mulmod(mulmod(state0, state0, F), scratch0, F) + state0 := + addmod( + 0x161b42232e61b84cbf1810af93a38fc0cece3d5628c9282003ebacb5c312c72b, + addmod(addmod(mulmod(scratch0, M00, F), mulmod(scratch1, M10, F), F), mulmod(scratch2, M20, F), F), + F + ) + state1 := + addmod( + 0x0ada10a90c7f0520950f7d47a60d5e6a493f09787f1564e5d09203db47de1a0b, + addmod(addmod(mulmod(scratch0, M01, F), mulmod(scratch1, M11, F), F), mulmod(scratch2, M21, F), F), + F + ) + state2 := + addmod( + 0x1a730d372310ba82320345a29ac4238ed3f07a8a2b4e121bb50ddb9af407f451, + addmod(addmod(mulmod(scratch0, M02, F), mulmod(scratch1, M12, F), F), mulmod(scratch2, M22, F), F), + F + ) + scratch0 := mulmod(state0, state0, F) + state0 := mulmod(mulmod(scratch0, scratch0, F), state0, F) + scratch0 := + addmod( + 0x2c8120f268ef054f817064c369dda7ea908377feaba5c4dffbda10ef58e8c556, + addmod(addmod(mulmod(state0, M00, F), mulmod(state1, M10, F), F), mulmod(state2, M20, F), F), + F + ) + scratch1 := + addmod( + 0x1c7c8824f758753fa57c00789c684217b930e95313bcb73e6e7b8649a4968f70, + addmod(addmod(mulmod(state0, M01, F), mulmod(state1, M11, F), F), mulmod(state2, M21, F), F), + F + ) + scratch2 := + addmod( + 0x2cd9ed31f5f8691c8e39e4077a74faa0f400ad8b491eb3f7b47b27fa3fd1cf77, + addmod(addmod(mulmod(state0, M02, F), mulmod(state1, M12, F), F), mulmod(state2, M22, F), F), + F + ) + state0 := mulmod(scratch0, scratch0, F) + scratch0 := mulmod(mulmod(state0, state0, F), scratch0, F) + state0 := + addmod( + 0x23ff4f9d46813457cf60d92f57618399a5e022ac321ca550854ae23918a22eea, + addmod(addmod(mulmod(scratch0, M00, F), mulmod(scratch1, M10, F), F), mulmod(scratch2, M20, F), F), + F + ) + state1 := + addmod( + 0x09945a5d147a4f66ceece6405dddd9d0af5a2c5103529407dff1ea58f180426d, + addmod(addmod(mulmod(scratch0, M01, F), mulmod(scratch1, M11, F), F), mulmod(scratch2, M21, F), F), + F + ) + state2 := + addmod( + 0x188d9c528025d4c2b67660c6b771b90f7c7da6eaa29d3f268a6dd223ec6fc630, + addmod(addmod(mulmod(scratch0, M02, F), mulmod(scratch1, M12, F), F), mulmod(scratch2, M22, F), F), + F + ) + scratch0 := mulmod(state0, state0, F) + state0 := mulmod(mulmod(scratch0, scratch0, F), state0, F) + scratch0 := + addmod( + 0x3050e37996596b7f81f68311431d8734dba7d926d3633595e0c0d8ddf4f0f47f, + addmod(addmod(mulmod(state0, M00, F), mulmod(state1, M10, F), F), mulmod(state2, M20, F), F), + F + ) + scratch1 := + addmod( + 0x15af1169396830a91600ca8102c35c426ceae5461e3f95d89d829518d30afd78, + addmod(addmod(mulmod(state0, M01, F), mulmod(state1, M11, F), F), mulmod(state2, M21, F), F), + F + ) + scratch2 := + addmod( + 0x1da6d09885432ea9a06d9f37f873d985dae933e351466b2904284da3320d8acc, + addmod(addmod(mulmod(state0, M02, F), mulmod(state1, M12, F), F), mulmod(state2, M22, F), F), + F + ) + state0 := mulmod(scratch0, scratch0, F) + scratch0 := mulmod(mulmod(state0, state0, F), scratch0, F) + state0 := + addmod( + 0x2796ea90d269af29f5f8acf33921124e4e4fad3dbe658945e546ee411ddaa9cb, + addmod(addmod(mulmod(scratch0, M00, F), mulmod(scratch1, M10, F), F), mulmod(scratch2, M20, F), F), + F + ) + state1 := + addmod( + 0x202d7dd1da0f6b4b0325c8b3307742f01e15612ec8e9304a7cb0319e01d32d60, + addmod(addmod(mulmod(scratch0, M01, F), mulmod(scratch1, M11, F), F), mulmod(scratch2, M21, F), F), + F + ) + state2 := + addmod( + 0x096d6790d05bb759156a952ba263d672a2d7f9c788f4c831a29dace4c0f8be5f, + addmod(addmod(mulmod(scratch0, M02, F), mulmod(scratch1, M12, F), F), mulmod(scratch2, M22, F), F), + F + ) + scratch0 := mulmod(state0, state0, F) + state0 := mulmod(mulmod(scratch0, scratch0, F), state0, F) + scratch0 := + addmod( + 0x054efa1f65b0fce283808965275d877b438da23ce5b13e1963798cb1447d25a4, + addmod(addmod(mulmod(state0, M00, F), mulmod(state1, M10, F), F), mulmod(state2, M20, F), F), + F + ) + scratch1 := + addmod( + 0x1b162f83d917e93edb3308c29802deb9d8aa690113b2e14864ccf6e18e4165f1, + addmod(addmod(mulmod(state0, M01, F), mulmod(state1, M11, F), F), mulmod(state2, M21, F), F), + F + ) + scratch2 := + addmod( + 0x21e5241e12564dd6fd9f1cdd2a0de39eedfefc1466cc568ec5ceb745a0506edc, + addmod(addmod(mulmod(state0, M02, F), mulmod(state1, M12, F), F), mulmod(state2, M22, F), F), + F + ) + state0 := mulmod(scratch0, scratch0, F) + scratch0 := mulmod(mulmod(state0, state0, F), scratch0, F) + state0 := mulmod(scratch1, scratch1, F) + scratch1 := mulmod(mulmod(state0, state0, F), scratch1, F) + state0 := mulmod(scratch2, scratch2, F) + scratch2 := mulmod(mulmod(state0, state0, F), scratch2, F) + state0 := + addmod( + 0x1cfb5662e8cf5ac9226a80ee17b36abecb73ab5f87e161927b4349e10e4bdf08, + addmod(addmod(mulmod(scratch0, M00, F), mulmod(scratch1, M10, F), F), mulmod(scratch2, M20, F), F), + F + ) + state1 := + addmod( + 0x0f21177e302a771bbae6d8d1ecb373b62c99af346220ac0129c53f666eb24100, + addmod(addmod(mulmod(scratch0, M01, F), mulmod(scratch1, M11, F), F), mulmod(scratch2, M21, F), F), + F + ) + state2 := + addmod( + 0x1671522374606992affb0dd7f71b12bec4236aede6290546bcef7e1f515c2320, + addmod(addmod(mulmod(scratch0, M02, F), mulmod(scratch1, M12, F), F), mulmod(scratch2, M22, F), F), + F + ) + scratch0 := mulmod(state0, state0, F) + state0 := mulmod(mulmod(scratch0, scratch0, F), state0, F) + scratch0 := mulmod(state1, state1, F) + state1 := mulmod(mulmod(scratch0, scratch0, F), state1, F) + scratch0 := mulmod(state2, state2, F) + state2 := mulmod(mulmod(scratch0, scratch0, F), state2, F) + scratch0 := + addmod( + 0x0fa3ec5b9488259c2eb4cf24501bfad9be2ec9e42c5cc8ccd419d2a692cad870, + addmod(addmod(mulmod(state0, M00, F), mulmod(state1, M10, F), F), mulmod(state2, M20, F), F), + F + ) + scratch1 := + addmod( + 0x193c0e04e0bd298357cb266c1506080ed36edce85c648cc085e8c57b1ab54bba, + addmod(addmod(mulmod(state0, M01, F), mulmod(state1, M11, F), F), mulmod(state2, M21, F), F), + F + ) + scratch2 := + addmod( + 0x102adf8ef74735a27e9128306dcbc3c99f6f7291cd406578ce14ea2adaba68f8, + addmod(addmod(mulmod(state0, M02, F), mulmod(state1, M12, F), F), mulmod(state2, M22, F), F), + F + ) + state0 := mulmod(scratch0, scratch0, F) + scratch0 := mulmod(mulmod(state0, state0, F), scratch0, F) + state0 := mulmod(scratch1, scratch1, F) + scratch1 := mulmod(mulmod(state0, state0, F), scratch1, F) + state0 := mulmod(scratch2, scratch2, F) + scratch2 := mulmod(mulmod(state0, state0, F), scratch2, F) + state0 := + addmod( + 0x0fe0af7858e49859e2a54d6f1ad945b1316aa24bfbdd23ae40a6d0cb70c3eab1, + addmod(addmod(mulmod(scratch0, M00, F), mulmod(scratch1, M10, F), F), mulmod(scratch2, M20, F), F), + F + ) + state1 := + addmod( + 0x216f6717bbc7dedb08536a2220843f4e2da5f1daa9ebdefde8a5ea7344798d22, + addmod(addmod(mulmod(scratch0, M01, F), mulmod(scratch1, M11, F), F), mulmod(scratch2, M21, F), F), + F + ) + state2 := + addmod( + 0x1da55cc900f0d21f4a3e694391918a1b3c23b2ac773c6b3ef88e2e4228325161, + addmod(addmod(mulmod(scratch0, M02, F), mulmod(scratch1, M12, F), F), mulmod(scratch2, M22, F), F), + F + ) + scratch0 := mulmod(state0, state0, F) + state0 := mulmod(mulmod(scratch0, scratch0, F), state0, F) + scratch0 := mulmod(state1, state1, F) + state1 := mulmod(mulmod(scratch0, scratch0, F), state1, F) + scratch0 := mulmod(state2, state2, F) + state2 := mulmod(mulmod(scratch0, scratch0, F), state2, F) + + mstore(0x0, addmod(addmod(mulmod(state0, M00, F), mulmod(state1, M10, F), F), mulmod(state2, M20, F), F)) + + return(0, 0x20) + } + } +} diff --git a/docs/crypto/zkCTF/day2/Mixer/Verifier.sol b/docs/crypto/zkCTF/day2/Mixer/Verifier.sol new file mode 100644 index 0000000..f2578ad --- /dev/null +++ b/docs/crypto/zkCTF/day2/Mixer/Verifier.sol @@ -0,0 +1,132 @@ +// SPDX-License-Identifier: UNLICENSED +pragma solidity ^0.8.20; + +contract Verifier { + uint256 constant SNARK_SCALAR_FIELD = 21888242871839275222246405745257275088548364400416034343698204186575808495617; + uint256 constant BASE_FIELD_SIZE = 21888242871839275222246405745257275088696311157297823662689037894645226208583; + + uint256 constant alphax = 20491192805390485299153009773594534940189261866228447918068658471970481763042; + uint256 constant alphay = 9383485363053290200918347156157836566562967994039712273449902621266178545958; + uint256 constant betax1 = 4252822878758300859123897981450591353533073413197771768651442665752259397132; + uint256 constant betax2 = 6375614351688725206403948262868962793625744043794305715222011528459656738731; + uint256 constant betay1 = 21847035105528745403288232691147584728191162732299865338377159692350059136679; + uint256 constant betay2 = 10505242626370262277552901082094356697409835680220590971873171140371331206856; + uint256 constant gammax1 = 11559732032986387107991004021392285783925812861821192530917403151452391805634; + uint256 constant gammax2 = 10857046999023057135944570762232829481370756359578518086990519993285655852781; + uint256 constant gammay1 = 4082367875863433681332203403145435568316851327593401208105741076214120093531; + uint256 constant gammay2 = 8495653923123431417604973247489272438418190587263600148770280649306958101930; + uint256 constant deltax1 = 1893257561357868370260620802160628499038076628340156004049542934310548166862; + uint256 constant deltax2 = 10489075187655236775721986824288233299183301829630866606042761077606943146308; + uint256 constant deltay1 = 12504842008468429161202146863287084230633299328812164135297844449146824318504; + uint256 constant deltay2 = 14239973756419086511503790618697697401079144895837674192870076639656643076809; + + uint256 constant IC0x = 11503083501441611266545726262417971001701991945128791695533054256120951755515; + uint256 constant IC0y = 14335483785630316103133843915311259368554842716745530414369443218412464064610; + uint256 constant IC1x = 4399221846099326031411049105172762446336048291478926186933903202129622257762; + uint256 constant IC1y = 9813853500236483147791820189570352567568695786717571896696996249816412776577; + uint256 constant IC2x = 8344160263894222173412566195248254861871258344381344764391908115117881694051; + uint256 constant IC2y = 18661182062623195357034645654072988084614539276223976323581310090550301745035; + uint256 constant IC3x = 12147167103171622477714718512746997601594522831591129322340558873443330009236; + uint256 constant IC3y = 21422504353954571190287634590627574924818746965781749641640417451354192042819; + + function verifyProof( + uint256[2] calldata pA, + uint256[2][2] calldata pB, + uint256[2] calldata pC, + uint256 nullifier, + uint256 root, + uint256 recipient + ) external view returns (bool) { + uint256[2] memory h; + uint256[2] memory vk = [IC0x, IC0y]; + + h = _ecMul([IC1x, IC1y, _checkField(nullifier)]); + vk = _ecAdd([vk[0], vk[1], h[0], h[1]]); + + h = _ecMul([IC2x, IC2y, _checkField(root)]); + vk = _ecAdd([vk[0], vk[1], h[0], h[1]]); + + h = _ecMul([IC3x, IC3y, _checkField(recipient)]); + vk = _ecAdd([vk[0], vk[1], h[0], h[1]]); + + uint256[2] memory negA = _negate(pA); + uint256[24] memory input = [ + negA[0], + negA[1], + pB[0][0], + pB[0][1], + pB[1][0], + pB[1][1], + alphax, + alphay, + betax1, + betax2, + betay1, + betay2, + vk[0], + vk[1], + gammax1, + gammax2, + gammay1, + gammay2, + pC[0], + pC[1], + deltax1, + deltax2, + deltay1, + deltay2 + ]; + + return _ecPairing(input); + } + + function _ecMul(uint256[3] memory input) internal view returns (uint256[2] memory output) { + assembly { + let success := staticcall(sub(gas(), 2000), 7, input, 0x60, output, 0x40) + if iszero(success) { + mstore(0, 0) + return(0, 0x20) + } + } + } + + function _ecAdd(uint256[4] memory input) internal view returns (uint256[2] memory output) { + assembly { + let success := staticcall(sub(gas(), 2000), 6, input, 0x80, output, 0x40) + if iszero(success) { + mstore(0, 0) + return(0, 0x20) + } + } + } + + function _ecPairing(uint256[24] memory input) internal view returns (bool) { + uint256[1] memory output; + + assembly { + let success := staticcall(sub(gas(), 2000), 8, input, 768, output, 0x20) + if iszero(success) { + mstore(0, 0) + return(0, 0x20) + } + } + + return output[0] != 0; + } + + function _negate(uint256[2] memory input) internal pure returns (uint256[2] memory output) { + assembly { + mstore(output, mload(input)) + mstore( + add(output, 32), mod(sub(BASE_FIELD_SIZE, mod(mload(add(input, 32)), BASE_FIELD_SIZE)), BASE_FIELD_SIZE) + ) + } + } + + function _checkField(uint256 x) internal pure returns (uint256) { + assembly { + if iszero(lt(x, BASE_FIELD_SIZE)) { x := mod(x, BASE_FIELD_SIZE) } + } + return x; + } +} diff --git a/docs/crypto/zkCTF/day2/Mixer/interfaces/IMixer.sol b/docs/crypto/zkCTF/day2/Mixer/interfaces/IMixer.sol new file mode 100644 index 0000000..cc5383c --- /dev/null +++ b/docs/crypto/zkCTF/day2/Mixer/interfaces/IMixer.sol @@ -0,0 +1,34 @@ +// SPDX-License-Identifier: UNLICENSED +pragma solidity ^0.8.20; + +import {IVerifier} from "./IVerifier.sol"; + +interface IMixer { + function commitments(uint256) external view returns (bool); + + function nullifiers(uint256) external view returns (bool); + + function deposit(uint256 commitment) external payable; + + function withdraw( + uint256[2] calldata pA, + uint256[2][2] calldata pB, + uint256[2] calldata pC, + uint256 nullifier, + uint256 root, + address recipient + ) external; + + function getRoot() external view returns (uint256); + + function getNumberOfLeaves() external view returns (uint256); + + function verifyProof( + uint256[2] calldata pA, + uint256[2][2] calldata pB, + uint256[2] calldata pC, + uint256 nullifier, + uint256 root, + address recipient + ) external view returns (bool); +} diff --git a/docs/crypto/zkCTF/day2/Mixer/interfaces/IPoseidonT3.sol b/docs/crypto/zkCTF/day2/Mixer/interfaces/IPoseidonT3.sol new file mode 100644 index 0000000..35d8d38 --- /dev/null +++ b/docs/crypto/zkCTF/day2/Mixer/interfaces/IPoseidonT3.sol @@ -0,0 +1,6 @@ +// SPDX-License-Identifier: UNLICENSED +pragma solidity ^0.8.20; + +interface IPoseidonT3 { + function hash(uint256[2] memory) external pure returns (uint256); +} diff --git a/docs/crypto/zkCTF/day2/Mixer/interfaces/IVerifier.sol b/docs/crypto/zkCTF/day2/Mixer/interfaces/IVerifier.sol new file mode 100644 index 0000000..3103029 --- /dev/null +++ b/docs/crypto/zkCTF/day2/Mixer/interfaces/IVerifier.sol @@ -0,0 +1,13 @@ +// SPDX-License-Identifier: UNLICENSED +pragma solidity ^0.8.20; + +interface IVerifier { + function verifyProof( + uint256[2] calldata pA, + uint256[2][2] calldata pB, + uint256[2] calldata pC, + uint256 nullifier, + uint256 root, + uint256 recipient + ) external view returns (bool); +} diff --git a/docs/crypto/zkCTF/day2/What a Waste/Circuit/Round 2 Seed.txt b/docs/crypto/zkCTF/day2/What a Waste/Circuit/Round 2 Seed.txt new file mode 100644 index 0000000..fc8806f --- /dev/null +++ b/docs/crypto/zkCTF/day2/What a Waste/Circuit/Round 2 Seed.txt @@ -0,0 +1 @@ +8371895283519 \ No newline at end of file diff --git a/docs/crypto/zkCTF/day2/What a Waste/Circuit/locker.circom b/docs/crypto/zkCTF/day2/What a Waste/Circuit/locker.circom new file mode 100644 index 0000000..c9678e1 --- /dev/null +++ b/docs/crypto/zkCTF/day2/What a Waste/Circuit/locker.circom @@ -0,0 +1,13 @@ +pragma circom 2.1.6; + +template locker () { +signal input a; +signal input b; +signal input c; +signal output d; + +// We just don't know the rest of the circuit + +} + +component main = locker(); \ No newline at end of file diff --git a/docs/crypto/zkCTF/day2/What a Waste/Circuit/locker_plonk_or_groth16.zkey b/docs/crypto/zkCTF/day2/What a Waste/Circuit/locker_plonk_or_groth16.zkey new file mode 100644 index 0000000000000000000000000000000000000000..a3cb412740c6aa95171fdd0febb98c4155fc8ff9 GIT binary patch literal 2624 zcmc&$eK?c*8%mm z35ktj0$EB-0Kl`Pn0Y`D10|-b@Z2EcGRiiSeexJBnoJJ~B$FGR4>WCOn2pAJ;dTNw z;yyv{;wXj|_u$OFNppk$tpW7^KF62kqh3^7Uo}d~u+iP!&nesgtn#()>uG6^^40Wb zrf^rMAdVgK)#!_nxmUfiJsqkmZ-)a<_;OEh5?|(i{G(j9 z&sFfgv^P=5!L0jZS_a7*cJhpI3w2lZF^;Yq9ZgPQKhaG7H! zvDG+Pb^jj}D_ErdRqLvW=kYrypB?V_$#LiX?3U8Tq@j)~vgqL$#7Ua*;e_TyZJv~_ z3sGyx=ZNBrHM%twbUosRY}O`=yDw7n!gtAjzOZeDpM24FaczTc-yg}R2R{t)I8$>< z)I@lF<*%zIhB_}l0wGT=L1`T1t(@Yt@s|Tha1mb&Zsz3x^nj&NruM{6iDlA!~_mV`SWOePM zY9(vZdrE4jQ-lU{hg3Qb{RqJ|+a~{@wH&}rR6v_QL@)bOaKc7OB1aK0mNaBVqyoe@kB@u(I9x4^MdJt&;9}fs0ip*_+7R7&OP*r4Yfh#%+l-QUG=k z0FYxk$TJsV12e+(H|C4Y87Bw2MkV3Qvk$uiXY_5;-Tqtq^*-!Q0YTnv49J}vcJ?!_ zZaklLBc=4}>*Wwv=LeRZs;Iv;fm{)@t=5^}q&{{yc{9K!B|tfCrMVXhMIe*rNEfEa-PwH_)plh*GLvQ)WdK7& zKGtNvy38EB+w1fZs(WikruHg^scb24fQ={q8$zd0fzW);F-6%O%Vb2 z8KAc+CmZS3!5X!sPEUyu$3(uI{cxF`{P54LPrJerMHh>Bn8(=z%;$?SPBZ2D8qx`O zaO0-}k=qlEyYBZ{HG|(lnvVC|!#*pb-KcxrYoN|Cqc4WG83`a!jbM|!@SL3)tUt?q zNu{@(_BB6^HA<*`DaB+Y=-|@ml4?1q<(sN%3Np{_DNb2%=sAmk^daA zx}S9()FeZf_bp>8GW#;q;|#vuf$#6-HC(2yNmvY#3O*IF7`2wmLytGY=VPpr8IIDs z2qzUC_R$86cAPJ8!}*PFG2+`RZ;Z!BgFF1?Zok}3DuvlE#*uvlcx#J9yG_s4w><=e8TixHw8-^ zWPcgcMt*bj-$!Yn^}84UUgcY-V6V-@M)9VH6ct?iy^^svLm5VQIC}8obt$|H1oWt}U9hEYP%}EckYG=5Aj&Bi zZV#=Jw22N54YXJY*S(U|gw-bWEvdwJIU`9L#KR87cGCO1Ib~L7#_wWV)ppdRSs~YZ zet}L%Y__05xVU90i0l}+yWZbLIq2PIs+9xOd*!Nx9M>R?Ro?byE39@2=KB;wgJ)I@ zrSuTM9m9x*j!t8x^*gve1>iq#?{|r2h?AOk-Yj`TnrGkaIZFW@`Z?j$Yn?rq@#*O& pbrVk|DAh-^i)7AbG;`*uFW0D. +*/ + +pragma solidity >=0.7.0 <0.9.0; + + +contract Waste{ + bool flag = false; + + Groth16Verifier public verifier; + + constructor() { + verifier= new Groth16Verifier(); + } + + function verify(uint[2] calldata _pA, uint[2][2] calldata _pB, uint[2] calldata _pC, uint[1] calldata _pubSignals) external returns(bool) { + + flag = verifier.verifyProof(_pA,_pB,_pC,_pubSignals); + return flag; + } + + function isSolved()external view returns (bool){ + return flag; + } + +} + +contract Groth16Verifier { + // Scalar field size + uint256 constant r = 21888242871839275222246405745257275088548364400416034343698204186575808495617; + // Base field size + uint256 constant q = 21888242871839275222246405745257275088696311157297823662689037894645226208583; + + // Verification Key data + uint256 constant alphax = 17945768553367054851330385785132129858307888874016287943932996517243480712132; + uint256 constant alphay = 2576364696983067761823149400827866804016497737261856810178714118503133039112; + uint256 constant betax1 = 21131130829420261072333873768111037102937737530693798061737132844777022179762; + uint256 constant betax2 = 16469162301071911176450342688334754623322329302889450246016490671300640454083; + uint256 constant betay1 = 11667160591855196540432777148222063754954535934020508430253254524246751492551; + uint256 constant betay2 = 17212565253524811702382836900906460391074497613217933366548828578614214861724; + uint256 constant gammax1 = 11559732032986387107991004021392285783925812861821192530917403151452391805634; + uint256 constant gammax2 = 10857046999023057135944570762232829481370756359578518086990519993285655852781; + uint256 constant gammay1 = 4082367875863433681332203403145435568316851327593401208105741076214120093531; + uint256 constant gammay2 = 8495653923123431417604973247489272438418190587263600148770280649306958101930; + uint256 constant deltax1 = 11559732032986387107991004021392285783925812861821192530917403151452391805634; + uint256 constant deltax2 = 10857046999023057135944570762232829481370756359578518086990519993285655852781; + uint256 constant deltay1 = 4082367875863433681332203403145435568316851327593401208105741076214120093531; + uint256 constant deltay2 = 8495653923123431417604973247489272438418190587263600148770280649306958101930; + + + uint256 constant IC0x = 9184629189521976879166955388819003880728702652593719832110016033969351836999; + uint256 constant IC0y = 8961595000831010991773638404821557673089040096575770156958147106527291841012; + + uint256 constant IC1x = 16509053466476158776848967114400799109094740228195910883227218154160520826028; + uint256 constant IC1y = 21256108931467971193836918546861651965437902451323554774565617383340236207465; + + + // Memory data + uint16 constant pVk = 0; + uint16 constant pPairing = 128; + + uint16 constant pLastMem = 896; + + function verifyProof(uint[2] calldata _pA, uint[2][2] calldata _pB, uint[2] calldata _pC, uint[1] calldata _pubSignals) public view returns (bool) { + assembly { + function checkField(v) { + if iszero(lt(v, q)) { + mstore(0, 0) + return(0, 0x20) + } + } + + // G1 function to multiply a G1 value(x,y) to value in an address + function g1_mulAccC(pR, x, y, s) { + let success + let mIn := mload(0x40) + mstore(mIn, x) + mstore(add(mIn, 32), y) + mstore(add(mIn, 64), s) + + success := staticcall(sub(gas(), 2000), 7, mIn, 96, mIn, 64) + + if iszero(success) { + mstore(0, 0) + return(0, 0x20) + } + + mstore(add(mIn, 64), mload(pR)) + mstore(add(mIn, 96), mload(add(pR, 32))) + + success := staticcall(sub(gas(), 2000), 6, mIn, 128, pR, 64) + + if iszero(success) { + mstore(0, 0) + return(0, 0x20) + } + } + + function checkPairing(pA, pB, pC, pubSignals, pMem) -> isOk { + let _pPairing := add(pMem, pPairing) + let _pVk := add(pMem, pVk) + + mstore(_pVk, IC0x) + mstore(add(_pVk, 32), IC0y) + + // Compute the linear combination vk_x + + g1_mulAccC(_pVk, IC1x, IC1y, calldataload(add(pubSignals, 0))) + + + // -A + mstore(_pPairing, calldataload(pA)) + mstore(add(_pPairing, 32), mod(sub(q, calldataload(add(pA, 32))), q)) + + // B + mstore(add(_pPairing, 64), calldataload(pB)) + mstore(add(_pPairing, 96), calldataload(add(pB, 32))) + mstore(add(_pPairing, 128), calldataload(add(pB, 64))) + mstore(add(_pPairing, 160), calldataload(add(pB, 96))) + + // alpha1 + mstore(add(_pPairing, 192), alphax) + mstore(add(_pPairing, 224), alphay) + + // beta2 + mstore(add(_pPairing, 256), betax1) + mstore(add(_pPairing, 288), betax2) + mstore(add(_pPairing, 320), betay1) + mstore(add(_pPairing, 352), betay2) + + // vk_x + mstore(add(_pPairing, 384), mload(add(pMem, pVk))) + mstore(add(_pPairing, 416), mload(add(pMem, add(pVk, 32)))) + + + // gamma2 + mstore(add(_pPairing, 448), gammax1) + mstore(add(_pPairing, 480), gammax2) + mstore(add(_pPairing, 512), gammay1) + mstore(add(_pPairing, 544), gammay2) + + // C + mstore(add(_pPairing, 576), calldataload(pC)) + mstore(add(_pPairing, 608), calldataload(add(pC, 32))) + + // delta2 + mstore(add(_pPairing, 640), deltax1) + mstore(add(_pPairing, 672), deltax2) + mstore(add(_pPairing, 704), deltay1) + mstore(add(_pPairing, 736), deltay2) + + + let success := staticcall(sub(gas(), 2000), 8, _pPairing, 768, _pPairing, 0x20) + + isOk := and(success, mload(_pPairing)) + } + + let pMem := mload(0x40) + mstore(0x40, add(pMem, pLastMem)) + + // Validate that all evaluations ∈ F + + checkField(calldataload(add(_pubSignals, 0))) + + checkField(calldataload(add(_pubSignals, 32))) + + + // Validate all evaluations + let isValid := checkPairing(_pA, _pB, _pC, _pubSignals, pMem) + + mstore(0, isValid) + return(0, 0x20) + } + } + } diff --git a/docs/crypto/zkCTF/day2/familiar_strangers/README.md b/docs/crypto/zkCTF/day2/familiar_strangers/README.md new file mode 100644 index 0000000..23dcc8d --- /dev/null +++ b/docs/crypto/zkCTF/day2/familiar_strangers/README.md @@ -0,0 +1,139 @@ +# Familiar Strangers + +In the realm of the familiar, where logic gates are the silent sentinels of truth, lies a challenge shrouded in enigma. "Familiar Strangers" beckons you to a world where the simplest of circuits hide secrets just beyond the veil of obviousness. These circuits, reminiscent of the ones you've met countless times, now hold a mystery that only a true Circom savant can unravel. Two levels, each a step deeper into the cryptic dance of numbers and logic, await your prowess. Are you ready to discover the true inputs and reveal the concealed answers within? Find the key, communicate with our judge service, and claim your place among the elite who see beyond the familiar to the truth that lies beneath. + +## How to play? + +1. Install the latest circom, check . +2. Install the dependencies with `npm install`. +3. Read the [circuit](circuits/challenge.circom) and [stranger_judge.js](stranger_judge.js) carefully to understand the challenge. +4. Find the correct inputs and send to the judge service to win the challenge. + +## How to run judge service? + +For local testing, you can run the judge service with: + +```shell +node stranger_judge.js +``` + +## How to send request to judge service? + +Example request with curl: + +```shell +curl -X POST http://localhost:3000/judge -H "Content-Type: application/json" -d '{"l1": "123", "l2": "123"}' +``` + +The `l1` and `l2` are the two levels of this challenge. + +The service will return `{"success":true}` when the input is correct, otherwise it will return `{"success":false}`. + +## Reference + +We include the below files in README for your convenience. You should always read the latest code in the correct location. + +The [challenge.circom](circuits/challenge.circom) is the circuits for this challenge. + +```js +pragma circom 2.1.7; + +include "../node_modules/circomlib/circuits/comparators.circom"; + +template Level1() { + signal input in; + signal output out; + out <== 1; + component lt = LessThan(201); + lt.in[0] <== in; + lt.in[1] <== 6026017665971213533282357846279359759458261226685473132380160; + lt.out === out; + component gt = GreaterThan(201); + gt.in[0] <== in; + gt.in[1] <== -401734511064747568885490523085290650630550748445698208825344; + gt.out === out; +} + +template Level2() { + signal input in; + signal output out; + out <== 1; + component lt = GreaterThan(241); + lt.in[0] <== 3533700027045102098369050084895387317199177651876580346993442643999981568; + lt.in[1] <== in; + lt.out === out; + component gt = LessThan(251); + gt.in[0] <== -3618502782768642773547390826438087570129142810943142283802299270005870559232; + gt.in[1] <== in; + gt.out === out; +} +``` + +The [stranger_judge.js](stranger_judge.js) is the code for the judge service. + +```js +const express = require('express'); +const bodyParser = require('body-parser'); +const { wasm: wasm_tester } = require('circom_tester'); +const path = require('path'); + +const app = express(); +app.use(bodyParser.json()); + +const PASS = "pass"; +const FAIL = "fail"; + +async function runCircuit(circuitPath, input) { + const circuit = await wasm_tester(circuitPath, { + output: path.join(__dirname, "./test/generated"), + // recompile: true, + }); + try { + const witness = await circuit.calculateWitness({ in: input }); + await circuit.checkConstraints(witness); + return PASS; + } catch (error) { + return error.toString(); + } +} + +// Example inputs {"l1": "123", "l2": "123"} +// Test with curl +// curl -X POST http://localhost:3000/judge -H "Content-Type: application/json" -d '{"l1": "123", "l2": "123"}' + +app.post('/judge', async (req, res) => { + // random number for logging + const identifier = Math.floor(Math.random() * 100000000000); + const inputs = req.body; + console.log("identifier", identifier, "inputs", inputs); + + let result = FAIL; + + // Level 1 + result = await runCircuit(path.join(__dirname, "test/level1_test.circom"), inputs.l1); + if (result != PASS) { + res.json({ success: false }); + return; + } + + // Level 2 + if (inputs.l2.length <= 70) { + res.json({ success: false }); + return; + } + result = await runCircuit(path.join(__dirname, "test/level2_test.circom"), inputs.l2); + if (result != PASS) { + res.json({ success: false }); + return; + } + + res.json({ success: true }); + console.log("identifier", identifier, "success"); + return; +}); + +const port = 3000; +app.listen(port, () => { + console.log(`Stranger Judge Service running on port ${port}`); +}); +``` diff --git a/docs/crypto/zkCTF/day2/familiar_strangers/circuits/challenge.circom b/docs/crypto/zkCTF/day2/familiar_strangers/circuits/challenge.circom new file mode 100644 index 0000000..a41db8a --- /dev/null +++ b/docs/crypto/zkCTF/day2/familiar_strangers/circuits/challenge.circom @@ -0,0 +1,31 @@ +pragma circom 2.1.7; + +include "../node_modules/circomlib/circuits/comparators.circom"; + +template Level1() { + signal input in; + signal output out; + out <== 1; + component lt = LessThan(201); + lt.in[0] <== in; + lt.in[1] <== 6026017665971213533282357846279359759458261226685473132380160; + lt.out === out; + component gt = GreaterThan(201); + gt.in[0] <== in; + gt.in[1] <== -401734511064747568885490523085290650630550748445698208825344; + gt.out === out; +} + +template Level2() { + signal input in; + signal output out; + out <== 1; + component lt = GreaterThan(241); + lt.in[0] <== 3533700027045102098369050084895387317199177651876580346993442643999981568; + lt.in[1] <== in; + lt.out === out; + component gt = LessThan(251); + gt.in[0] <== -3618502782768642773547390826438087570129142810943142283802299270005870559232; + gt.in[1] <== in; + gt.out === out; +} \ No newline at end of file diff --git a/docs/crypto/zkCTF/day2/familiar_strangers/package-lock.json b/docs/crypto/zkCTF/day2/familiar_strangers/package-lock.json new file mode 100644 index 0000000..b7f5ca5 --- /dev/null +++ b/docs/crypto/zkCTF/day2/familiar_strangers/package-lock.json @@ -0,0 +1,2166 @@ +{ + "name": "familiar_strangers", + "version": "0.1.0", + "lockfileVersion": 3, + "requires": true, + "packages": { + "": { + "name": "familiar_strangers", + "version": "0.1.0", + "dependencies": { + "chai": "^4.3.7", + "circom_tester": "^0.0.19", + "circomlib": "^2.0.5", + "express": "^4.18.2", + "mocha": "^10.2.0" + } + }, + "node_modules/@iden3/bigarray": { + "version": "0.0.2", + "resolved": "https://registry.npmjs.org/@iden3/bigarray/-/bigarray-0.0.2.tgz", + "integrity": "sha512-Xzdyxqm1bOFF6pdIsiHLLl3HkSLjbhqJHVyqaTxXt3RqXBEnmsUmEW47H7VOi/ak7TdkRpNkxjyK5Zbkm+y52g==" + }, + "node_modules/@iden3/binfileutils": { + "version": "0.0.11", + "resolved": "https://registry.npmjs.org/@iden3/binfileutils/-/binfileutils-0.0.11.tgz", + "integrity": "sha512-LylnJoZ0CTdgErnKY8OxohvW4K+p6UHD3sxt+3P9AmMyBQjYR4IpoqoYZZ+9aMj89cmCQ21UvdhndAx04er3NA==", + "dependencies": { + "fastfile": "0.0.20", + "ffjavascript": "^0.2.48" + } + }, + "node_modules/accepts": { + "version": "1.3.8", + "resolved": "https://registry.npmjs.org/accepts/-/accepts-1.3.8.tgz", + "integrity": "sha512-PYAthTa2m2VKxuvSD3DPC/Gy+U+sOA1LAuT8mkmRuvw+NACSaeXEQ+NHcVF7rONl6qcaxV3Uuemwawk+7+SJLw==", + "dependencies": { + "mime-types": "~2.1.34", + "negotiator": "0.6.3" + }, + "engines": { + "node": ">= 0.6" + } + }, + "node_modules/ansi-colors": { + "version": "4.1.1", + "resolved": "https://registry.npmjs.org/ansi-colors/-/ansi-colors-4.1.1.tgz", + "integrity": "sha512-JoX0apGbHaUJBNl6yF+p6JAFYZ666/hhCGKN5t9QFjbJQKUU/g8MNbFDbvfrgKXvI1QpZplPOnwIo99lX/AAmA==", + "engines": { + "node": ">=6" + } + }, + "node_modules/ansi-regex": { + "version": "5.0.1", + "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-5.0.1.tgz", + "integrity": "sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ==", + "engines": { + "node": ">=8" + } + }, + "node_modules/ansi-styles": { + "version": "4.3.0", + "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-4.3.0.tgz", + "integrity": "sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==", + "dependencies": { + "color-convert": "^2.0.1" + }, + "engines": { + "node": ">=8" + }, + "funding": { + "url": "https://github.com/chalk/ansi-styles?sponsor=1" + } + }, + "node_modules/anymatch": { + "version": "3.1.3", + "resolved": "https://registry.npmjs.org/anymatch/-/anymatch-3.1.3.tgz", + "integrity": "sha512-KMReFUr0B4t+D+OBkjR3KYqvocp2XaSzO55UcB6mgQMd3KbcE+mWTyvVV7D/zsdEbNnV6acZUutkiHQXvTr1Rw==", + "dependencies": { + "normalize-path": "^3.0.0", + "picomatch": "^2.0.4" + }, + "engines": { + "node": ">= 8" + } + }, + "node_modules/argparse": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/argparse/-/argparse-2.0.1.tgz", + "integrity": "sha512-8+9WqebbFzpX9OR+Wa6O29asIogeRMzcGtAINdpMHHyAg10f05aSFVBbcEqGf/PXw1EjAZ+q2/bEBg3DvurK3Q==" + }, + "node_modules/array-flatten": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/array-flatten/-/array-flatten-1.1.1.tgz", + "integrity": "sha512-PCVAQswWemu6UdxsDFFX/+gVeYqKAod3D3UVm91jHwynguOwAvYPhx8nNlM++NqRcK6CxxpUafjmhIdKiHibqg==" + }, + "node_modules/assertion-error": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/assertion-error/-/assertion-error-1.1.0.tgz", + "integrity": "sha512-jgsaNduz+ndvGyFt3uSuWqvy4lCnIJiovtouQN5JZHOKCS2QuhEdbcQHFhVksz2N2U9hXJo8odG7ETyWlEeuDw==", + "engines": { + "node": "*" + } + }, + "node_modules/async": { + "version": "3.2.5", + "resolved": "https://registry.npmjs.org/async/-/async-3.2.5.tgz", + "integrity": "sha512-baNZyqaaLhyLVKm/DlvdW051MSgO6b8eVfIezl9E5PqWxFgzLm/wQntEW4zOytVburDEr0JlALEpdOFwvErLsg==" + }, + "node_modules/available-typed-arrays": { + "version": "1.0.5", + "resolved": "https://registry.npmjs.org/available-typed-arrays/-/available-typed-arrays-1.0.5.tgz", + "integrity": "sha512-DMD0KiN46eipeziST1LPP/STfDU0sufISXmjSgvVsoU2tqxctQeASejWcfNtxYKqETM1UxQ8sp2OrSBWpHY6sw==", + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/b4a": { + "version": "1.6.4", + "resolved": "https://registry.npmjs.org/b4a/-/b4a-1.6.4.tgz", + "integrity": "sha512-fpWrvyVHEKyeEvbKZTVOeZF3VSKKWtJxFIxX/jaVPf+cLbGUSitjb49pHLqPV2BUNNZ0LcoeEGfE/YCpyDYHIw==" + }, + "node_modules/balanced-match": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/balanced-match/-/balanced-match-1.0.2.tgz", + "integrity": "sha512-3oSeUO0TMV67hN1AmbXsK4yaqU7tjiHlbxRDZOpH0KW9+CeX4bRAaX0Anxt0tx2MrpRpWwQaPwIlISEJhYU5Pw==" + }, + "node_modules/bfj": { + "version": "7.1.0", + "resolved": "https://registry.npmjs.org/bfj/-/bfj-7.1.0.tgz", + "integrity": "sha512-I6MMLkn+anzNdCUp9hMRyui1HaNEUCco50lxbvNS4+EyXg8lN3nJ48PjPWtbH8UVS9CuMoaKE9U2V3l29DaRQw==", + "dependencies": { + "bluebird": "^3.7.2", + "check-types": "^11.2.3", + "hoopy": "^0.1.4", + "jsonpath": "^1.1.1", + "tryer": "^1.0.1" + }, + "engines": { + "node": ">= 8.0.0" + } + }, + "node_modules/binary-extensions": { + "version": "2.2.0", + "resolved": "https://registry.npmjs.org/binary-extensions/-/binary-extensions-2.2.0.tgz", + "integrity": "sha512-jDctJ/IVQbZoJykoeHbhXpOlNBqGNcwXJKJog42E5HDPUwQTSdjCHdihjj0DlnheQ7blbT6dHOafNAiS8ooQKA==", + "engines": { + "node": ">=8" + } + }, + "node_modules/blake2b-wasm": { + "version": "2.4.0", + "resolved": "https://registry.npmjs.org/blake2b-wasm/-/blake2b-wasm-2.4.0.tgz", + "integrity": "sha512-S1kwmW2ZhZFFFOghcx73+ZajEfKBqhP82JMssxtLVMxlaPea1p9uoLiUZ5WYyHn0KddwbLc+0vh4wR0KBNoT5w==", + "dependencies": { + "b4a": "^1.0.1", + "nanoassert": "^2.0.0" + } + }, + "node_modules/bluebird": { + "version": "3.7.2", + "resolved": "https://registry.npmjs.org/bluebird/-/bluebird-3.7.2.tgz", + "integrity": "sha512-XpNj6GDQzdfW+r2Wnn7xiSAd7TM3jzkxGXBGTtWKuSXv1xUV+azxAm8jdWZN06QTQk+2N2XB9jRDkvbmQmcRtg==" + }, + "node_modules/body-parser": { + "version": "1.20.1", + "resolved": "https://registry.npmjs.org/body-parser/-/body-parser-1.20.1.tgz", + "integrity": "sha512-jWi7abTbYwajOytWCQc37VulmWiRae5RyTpaCyDcS5/lMdtwSz5lOpDE67srw/HYe35f1z3fDQw+3txg7gNtWw==", + "dependencies": { + "bytes": "3.1.2", + "content-type": "~1.0.4", + "debug": "2.6.9", + "depd": "2.0.0", + "destroy": "1.2.0", + "http-errors": "2.0.0", + "iconv-lite": "0.4.24", + "on-finished": "2.4.1", + "qs": "6.11.0", + "raw-body": "2.5.1", + "type-is": "~1.6.18", + "unpipe": "1.0.0" + }, + "engines": { + "node": ">= 0.8", + "npm": "1.2.8000 || >= 1.4.16" + } + }, + "node_modules/body-parser/node_modules/debug": { + "version": "2.6.9", + "resolved": "https://registry.npmjs.org/debug/-/debug-2.6.9.tgz", + "integrity": "sha512-bC7ElrdJaJnPbAP+1EotYvqZsb3ecl5wi6Bfi6BJTUcNowp6cvspg0jXznRTKDjm/E7AdgFBVeAPVMNcKGsHMA==", + "dependencies": { + "ms": "2.0.0" + } + }, + "node_modules/body-parser/node_modules/ms": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/ms/-/ms-2.0.0.tgz", + "integrity": "sha512-Tpp60P6IUJDTuOq/5Z8cdskzJujfwqfOTkrwIwj7IRISpnkJnT6SyJ4PCPnGMoFjC9ddhal5KVIYtAt97ix05A==" + }, + "node_modules/brace-expansion": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-2.0.1.tgz", + "integrity": "sha512-XnAIvQ8eM+kC6aULx6wuQiwVsnzsi9d3WxzV3FpWTGA19F621kwdbsAcFKXgKUHZWsy+mY6iL1sHTxWEFCytDA==", + "dependencies": { + "balanced-match": "^1.0.0" + } + }, + "node_modules/braces": { + "version": "3.0.2", + "resolved": "https://registry.npmjs.org/braces/-/braces-3.0.2.tgz", + "integrity": "sha512-b8um+L1RzM3WDSzvhm6gIz1yfTbBt6YTlcEKAvsmqCZZFw46z626lVj9j1yEPW33H5H+lBQpZMP1k8l+78Ha0A==", + "dependencies": { + "fill-range": "^7.0.1" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/browser-stdout": { + "version": "1.3.1", + "resolved": "https://registry.npmjs.org/browser-stdout/-/browser-stdout-1.3.1.tgz", + "integrity": "sha512-qhAVI1+Av2X7qelOfAIYwXONood6XlZE/fXaBSmW/T5SzLAmCgzi+eiWE7fUvbHaeNBQH13UftjpXxsfLkMpgw==" + }, + "node_modules/bytes": { + "version": "3.1.2", + "resolved": "https://registry.npmjs.org/bytes/-/bytes-3.1.2.tgz", + "integrity": "sha512-/Nf7TyzTx6S3yRJObOAV7956r8cr2+Oj8AC5dt8wSP3BQAoeX58NoHyCU8P8zGkNXStjTSi6fzO6F0pBdcYbEg==", + "engines": { + "node": ">= 0.8" + } + }, + "node_modules/call-bind": { + "version": "1.0.5", + "resolved": "https://registry.npmjs.org/call-bind/-/call-bind-1.0.5.tgz", + "integrity": "sha512-C3nQxfFZxFRVoJoGKKI8y3MOEo129NQ+FgQ08iye+Mk4zNZZGdjfs06bVTr+DBSlA66Q2VEcMki/cUCP4SercQ==", + "dependencies": { + "function-bind": "^1.1.2", + "get-intrinsic": "^1.2.1", + "set-function-length": "^1.1.1" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/camelcase": { + "version": "6.3.0", + "resolved": "https://registry.npmjs.org/camelcase/-/camelcase-6.3.0.tgz", + "integrity": "sha512-Gmy6FhYlCY7uOElZUSbxo2UCDH8owEk996gkbrpsgGtrJLM3J7jGxl9Ic7Qwwj4ivOE5AWZWRMecDdF7hqGjFA==", + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/chai": { + "version": "4.4.1", + "resolved": "https://registry.npmjs.org/chai/-/chai-4.4.1.tgz", + "integrity": "sha512-13sOfMv2+DWduEU+/xbun3LScLoqN17nBeTLUsmDfKdoiC1fr0n9PU4guu4AhRcOVFk/sW8LyZWHuhWtQZiF+g==", + "dependencies": { + "assertion-error": "^1.1.0", + "check-error": "^1.0.3", + "deep-eql": "^4.1.3", + "get-func-name": "^2.0.2", + "loupe": "^2.3.6", + "pathval": "^1.1.1", + "type-detect": "^4.0.8" + }, + "engines": { + "node": ">=4" + } + }, + "node_modules/chalk": { + "version": "4.1.2", + "resolved": "https://registry.npmjs.org/chalk/-/chalk-4.1.2.tgz", + "integrity": "sha512-oKnbhFyRIXpUuez8iBMmyEa4nbj4IOQyuhc/wy9kY7/WVPcwIO9VA668Pu8RkO7+0G76SLROeyw9CpQ061i4mA==", + "dependencies": { + "ansi-styles": "^4.1.0", + "supports-color": "^7.1.0" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/chalk/chalk?sponsor=1" + } + }, + "node_modules/chalk/node_modules/supports-color": { + "version": "7.2.0", + "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-7.2.0.tgz", + "integrity": "sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw==", + "dependencies": { + "has-flag": "^4.0.0" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/check-error": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/check-error/-/check-error-1.0.3.tgz", + "integrity": "sha512-iKEoDYaRmd1mxM90a2OEfWhjsjPpYPuQ+lMYsoxB126+t8fw7ySEO48nmDg5COTjxDI65/Y2OWpeEHk3ZOe8zg==", + "dependencies": { + "get-func-name": "^2.0.2" + }, + "engines": { + "node": "*" + } + }, + "node_modules/check-types": { + "version": "11.2.3", + "resolved": "https://registry.npmjs.org/check-types/-/check-types-11.2.3.tgz", + "integrity": "sha512-+67P1GkJRaxQD6PKK0Et9DhwQB+vGg3PM5+aavopCpZT1lj9jeqfvpgTLAWErNj8qApkkmXlu/Ug74kmhagkXg==" + }, + "node_modules/child_process": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/child_process/-/child_process-1.0.2.tgz", + "integrity": "sha512-Wmza/JzL0SiWz7kl6MhIKT5ceIlnFPJX+lwUGj7Clhy5MMldsSoJR0+uvRzOS5Kv45Mq7t1PoE8TsOA9bzvb6g==" + }, + "node_modules/chokidar": { + "version": "3.5.3", + "resolved": "https://registry.npmjs.org/chokidar/-/chokidar-3.5.3.tgz", + "integrity": "sha512-Dr3sfKRP6oTcjf2JmUmFJfeVMvXBdegxB0iVQ5eb2V10uFJUCAS8OByZdVAyVb8xXNz3GjjTgj9kLWsZTqE6kw==", + "funding": [ + { + "type": "individual", + "url": "https://paulmillr.com/funding/" + } + ], + "dependencies": { + "anymatch": "~3.1.2", + "braces": "~3.0.2", + "glob-parent": "~5.1.2", + "is-binary-path": "~2.1.0", + "is-glob": "~4.0.1", + "normalize-path": "~3.0.0", + "readdirp": "~3.6.0" + }, + "engines": { + "node": ">= 8.10.0" + }, + "optionalDependencies": { + "fsevents": "~2.3.2" + } + }, + "node_modules/circom_tester": { + "version": "0.0.19", + "resolved": "https://registry.npmjs.org/circom_tester/-/circom_tester-0.0.19.tgz", + "integrity": "sha512-SNHaBsGxcBH6XsVWfsRbRPA7NF8m8AMKJI9dtJJCFGUtOTT2+zsoIqAwi50z6XCnO4TtjyXq7AeXa1PLHqT0tw==", + "dependencies": { + "chai": "^4.3.6", + "child_process": "^1.0.2", + "ffjavascript": "^0.2.56", + "fnv-plus": "^1.3.1", + "r1csfile": "^0.0.41", + "snarkjs": "0.5.0", + "tmp-promise": "^3.0.3", + "util": "^0.12.4" + } + }, + "node_modules/circom_tester/node_modules/circom_runtime": { + "version": "0.1.21", + "resolved": "https://registry.npmjs.org/circom_runtime/-/circom_runtime-0.1.21.tgz", + "integrity": "sha512-qTkud630B/GK8y76hnOaaS1aNuF6prfV0dTrkeRsiJKnlP1ryQbP2FWLgDOPqn6aKyaPlam+Z+DTbBhkEzh8dA==", + "dependencies": { + "ffjavascript": "0.2.56" + }, + "bin": { + "calcwit": "calcwit.js" + } + }, + "node_modules/circom_tester/node_modules/ffjavascript": { + "version": "0.2.56", + "resolved": "https://registry.npmjs.org/ffjavascript/-/ffjavascript-0.2.56.tgz", + "integrity": "sha512-em6G5Lrj7ucIqj4TYEgyoHs/j99Urwwqa4+YxEVY2hggnpRimVj+noX5pZQTxI1pvtiekZI4rG65JBf0xraXrg==", + "dependencies": { + "wasmbuilder": "0.0.16", + "wasmcurves": "0.2.0", + "web-worker": "^1.2.0" + } + }, + "node_modules/circom_tester/node_modules/snarkjs": { + "version": "0.5.0", + "resolved": "https://registry.npmjs.org/snarkjs/-/snarkjs-0.5.0.tgz", + "integrity": "sha512-KWz8mZ2Y+6wvn6GGkQo6/ZlKwETdAGohd40Lzpwp5TUZCn6N6O4Az1SuX1rw/qREGL6Im+ycb19suCFE8/xaKA==", + "dependencies": { + "@iden3/binfileutils": "0.0.11", + "bfj": "^7.0.2", + "blake2b-wasm": "^2.4.0", + "circom_runtime": "0.1.21", + "ejs": "^3.1.6", + "fastfile": "0.0.20", + "ffjavascript": "0.2.56", + "js-sha3": "^0.8.0", + "logplease": "^1.2.15", + "r1csfile": "0.0.41" + }, + "bin": { + "snarkjs": "build/cli.cjs" + } + }, + "node_modules/circom_tester/node_modules/wasmcurves": { + "version": "0.2.0", + "resolved": "https://registry.npmjs.org/wasmcurves/-/wasmcurves-0.2.0.tgz", + "integrity": "sha512-3e2rbxdujOwaod657gxgmdhZNn+i1qKdHO3Y/bK+8E7bV8ttV/fu5FO4/WLBACF375cK0QDLOP+65Na63qYuWA==", + "dependencies": { + "wasmbuilder": "0.0.16" + } + }, + "node_modules/circomlib": { + "version": "2.0.5", + "resolved": "https://registry.npmjs.org/circomlib/-/circomlib-2.0.5.tgz", + "integrity": "sha512-O7NQ8OS+J4eshBuoy36z/TwQU0YHw8W3zxZcs4hVwpEll3e4hDm3mgkIPqItN8FDeLEKZFK3YeT/+k8TiLF3/A==" + }, + "node_modules/cliui": { + "version": "7.0.4", + "resolved": "https://registry.npmjs.org/cliui/-/cliui-7.0.4.tgz", + "integrity": "sha512-OcRE68cOsVMXp1Yvonl/fzkQOyjLSu/8bhPDfQt0e0/Eb283TKP20Fs2MqoPsr9SwA595rRCA+QMzYc9nBP+JQ==", + "dependencies": { + "string-width": "^4.2.0", + "strip-ansi": "^6.0.0", + "wrap-ansi": "^7.0.0" + } + }, + "node_modules/color-convert": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-2.0.1.tgz", + "integrity": "sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ==", + "dependencies": { + "color-name": "~1.1.4" + }, + "engines": { + "node": ">=7.0.0" + } + }, + "node_modules/color-name": { + "version": "1.1.4", + "resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.4.tgz", + "integrity": "sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA==" + }, + "node_modules/concat-map": { + "version": "0.0.1", + "resolved": "https://registry.npmjs.org/concat-map/-/concat-map-0.0.1.tgz", + "integrity": "sha512-/Srv4dswyQNBfohGpz9o6Yb3Gz3SrUDqBH5rTuhGR7ahtlbYKnVxw2bCFMRljaA7EXHaXZ8wsHdodFvbkhKmqg==" + }, + "node_modules/content-disposition": { + "version": "0.5.4", + "resolved": "https://registry.npmjs.org/content-disposition/-/content-disposition-0.5.4.tgz", + "integrity": "sha512-FveZTNuGw04cxlAiWbzi6zTAL/lhehaWbTtgluJh4/E95DqMwTmha3KZN1aAWA8cFIhHzMZUvLevkw5Rqk+tSQ==", + "dependencies": { + "safe-buffer": "5.2.1" + }, + "engines": { + "node": ">= 0.6" + } + }, + "node_modules/content-type": { + "version": "1.0.5", + "resolved": "https://registry.npmjs.org/content-type/-/content-type-1.0.5.tgz", + "integrity": "sha512-nTjqfcBFEipKdXCv4YDQWCfmcLZKm81ldF0pAopTvyrFGVbcR6P/VAAd5G7N+0tTr8QqiU0tFadD6FK4NtJwOA==", + "engines": { + "node": ">= 0.6" + } + }, + "node_modules/cookie": { + "version": "0.5.0", + "resolved": "https://registry.npmjs.org/cookie/-/cookie-0.5.0.tgz", + "integrity": "sha512-YZ3GUyn/o8gfKJlnlX7g7xq4gyO6OSuhGPKaaGssGB2qgDUS0gPgtTvoyZLTt9Ab6dC4hfc9dV5arkvc/OCmrw==", + "engines": { + "node": ">= 0.6" + } + }, + "node_modules/cookie-signature": { + "version": "1.0.6", + "resolved": "https://registry.npmjs.org/cookie-signature/-/cookie-signature-1.0.6.tgz", + "integrity": "sha512-QADzlaHc8icV8I7vbaJXJwod9HWYp8uCqf1xa4OfNu1T7JVxQIrUgOWtHdNDtPiywmFbiS12VjotIXLrKM3orQ==" + }, + "node_modules/debug": { + "version": "4.3.4", + "resolved": "https://registry.npmjs.org/debug/-/debug-4.3.4.tgz", + "integrity": "sha512-PRWFHuSU3eDtQJPvnNY7Jcket1j0t5OuOsFzPPzsekD52Zl8qUfFIPEiswXqIvHWGVHOgX+7G/vCNNhehwxfkQ==", + "dependencies": { + "ms": "2.1.2" + }, + "engines": { + "node": ">=6.0" + }, + "peerDependenciesMeta": { + "supports-color": { + "optional": true + } + } + }, + "node_modules/debug/node_modules/ms": { + "version": "2.1.2", + "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.2.tgz", + "integrity": "sha512-sGkPx+VjMtmA6MX27oA4FBFELFCZZ4S4XqeGOXCv68tT+jb3vk/RyaKWP0PTKyWtmLSM0b+adUTEvbs1PEaH2w==" + }, + "node_modules/decamelize": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/decamelize/-/decamelize-4.0.0.tgz", + "integrity": "sha512-9iE1PgSik9HeIIw2JO94IidnE3eBoQrFJ3w7sFuzSX4DpmZ3v5sZpUiV5Swcf6mQEF+Y0ru8Neo+p+nyh2J+hQ==", + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/deep-eql": { + "version": "4.1.3", + "resolved": "https://registry.npmjs.org/deep-eql/-/deep-eql-4.1.3.tgz", + "integrity": "sha512-WaEtAOpRA1MQ0eohqZjpGD8zdI0Ovsm8mmFhaDN8dvDZzyoUMcYDnf5Y6iu7HTXxf8JDS23qWa4a+hKCDyOPzw==", + "dependencies": { + "type-detect": "^4.0.0" + }, + "engines": { + "node": ">=6" + } + }, + "node_modules/deep-is": { + "version": "0.1.4", + "resolved": "https://registry.npmjs.org/deep-is/-/deep-is-0.1.4.tgz", + "integrity": "sha512-oIPzksmTg4/MriiaYGO+okXDT7ztn/w3Eptv/+gSIdMdKsJo0u4CfYNFJPy+4SKMuCqGw2wxnA+URMg3t8a/bQ==" + }, + "node_modules/define-data-property": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/define-data-property/-/define-data-property-1.1.1.tgz", + "integrity": "sha512-E7uGkTzkk1d0ByLeSc6ZsFS79Axg+m1P/VsgYsxHgiuc3tFSj+MjMIwe90FC4lOAZzNBdY7kkO2P2wKdsQ1vgQ==", + "dependencies": { + "get-intrinsic": "^1.2.1", + "gopd": "^1.0.1", + "has-property-descriptors": "^1.0.0" + }, + "engines": { + "node": ">= 0.4" + } + }, + "node_modules/depd": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/depd/-/depd-2.0.0.tgz", + "integrity": "sha512-g7nH6P6dyDioJogAAGprGpCtVImJhpPk/roCzdb3fIh61/s/nPsfR6onyMwkCAR/OlC3yBC0lESvUoQEAssIrw==", + "engines": { + "node": ">= 0.8" + } + }, + "node_modules/destroy": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/destroy/-/destroy-1.2.0.tgz", + "integrity": "sha512-2sJGJTaXIIaR1w4iJSNoN0hnMY7Gpc/n8D4qSCJw8QqFWXf7cuAgnEHxBpweaVcPevC2l3KpjYCx3NypQQgaJg==", + "engines": { + "node": ">= 0.8", + "npm": "1.2.8000 || >= 1.4.16" + } + }, + "node_modules/diff": { + "version": "5.0.0", + "resolved": "https://registry.npmjs.org/diff/-/diff-5.0.0.tgz", + "integrity": "sha512-/VTCrvm5Z0JGty/BWHljh+BAiw3IK+2j87NGMu8Nwc/f48WoDAC395uomO9ZD117ZOBaHmkX1oyLvkVM/aIT3w==", + "engines": { + "node": ">=0.3.1" + } + }, + "node_modules/ee-first": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/ee-first/-/ee-first-1.1.1.tgz", + "integrity": "sha512-WMwm9LhRUo+WUaRN+vRuETqG89IgZphVSNkdFgeb6sS/E4OrDIN7t48CAewSHXc6C8lefD8KKfr5vY61brQlow==" + }, + "node_modules/ejs": { + "version": "3.1.9", + "resolved": "https://registry.npmjs.org/ejs/-/ejs-3.1.9.tgz", + "integrity": "sha512-rC+QVNMJWv+MtPgkt0y+0rVEIdbtxVADApW9JXrUVlzHetgcyczP/E7DJmWJ4fJCZF2cPcBk0laWO9ZHMG3DmQ==", + "dependencies": { + "jake": "^10.8.5" + }, + "bin": { + "ejs": "bin/cli.js" + }, + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/emoji-regex": { + "version": "8.0.0", + "resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-8.0.0.tgz", + "integrity": "sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A==" + }, + "node_modules/encodeurl": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/encodeurl/-/encodeurl-1.0.2.tgz", + "integrity": "sha512-TPJXq8JqFaVYm2CWmPvnP2Iyo4ZSM7/QKcSmuMLDObfpH5fi7RUGmd/rTDf+rut/saiDiQEeVTNgAmJEdAOx0w==", + "engines": { + "node": ">= 0.8" + } + }, + "node_modules/escalade": { + "version": "3.1.1", + "resolved": "https://registry.npmjs.org/escalade/-/escalade-3.1.1.tgz", + "integrity": "sha512-k0er2gUkLf8O0zKJiAhmkTnJlTvINGv7ygDNPbeIsX/TJjGJZHuh9B2UxbsaEkmlEo9MfhrSzmhIlhRlI2GXnw==", + "engines": { + "node": ">=6" + } + }, + "node_modules/escape-html": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/escape-html/-/escape-html-1.0.3.tgz", + "integrity": "sha512-NiSupZ4OeuGwr68lGIeym/ksIZMJodUGOSCZ/FSnTxcrekbvqrgdUxlJOMpijaKZVjAJrWrGs/6Jy8OMuyj9ow==" + }, + "node_modules/escape-string-regexp": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/escape-string-regexp/-/escape-string-regexp-4.0.0.tgz", + "integrity": "sha512-TtpcNJ3XAzx3Gq8sWRzJaVajRs0uVxA2YAkdb1jm2YkPz4G6egUFAyA3n5vtEIZefPk5Wa4UXbKuS5fKkJWdgA==", + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/escodegen": { + "version": "1.14.3", + "resolved": "https://registry.npmjs.org/escodegen/-/escodegen-1.14.3.tgz", + "integrity": "sha512-qFcX0XJkdg+PB3xjZZG/wKSuT1PnQWx57+TVSjIMmILd2yC/6ByYElPwJnslDsuWuSAp4AwJGumarAAmJch5Kw==", + "dependencies": { + "esprima": "^4.0.1", + "estraverse": "^4.2.0", + "esutils": "^2.0.2", + "optionator": "^0.8.1" + }, + "bin": { + "escodegen": "bin/escodegen.js", + "esgenerate": "bin/esgenerate.js" + }, + "engines": { + "node": ">=4.0" + }, + "optionalDependencies": { + "source-map": "~0.6.1" + } + }, + "node_modules/escodegen/node_modules/esprima": { + "version": "4.0.1", + "resolved": "https://registry.npmjs.org/esprima/-/esprima-4.0.1.tgz", + "integrity": "sha512-eGuFFw7Upda+g4p+QHvnW0RyTX/SVeJBDM/gCtMARO0cLuT2HcEKnTPvhjV6aGeqrCB/sbNop0Kszm0jsaWU4A==", + "bin": { + "esparse": "bin/esparse.js", + "esvalidate": "bin/esvalidate.js" + }, + "engines": { + "node": ">=4" + } + }, + "node_modules/esprima": { + "version": "1.2.2", + "resolved": "https://registry.npmjs.org/esprima/-/esprima-1.2.2.tgz", + "integrity": "sha512-+JpPZam9w5DuJ3Q67SqsMGtiHKENSMRVoxvArfJZK01/BfLEObtZ6orJa/MtoGNR/rfMgp5837T41PAmTwAv/A==", + "bin": { + "esparse": "bin/esparse.js", + "esvalidate": "bin/esvalidate.js" + }, + "engines": { + "node": ">=0.4.0" + } + }, + "node_modules/estraverse": { + "version": "4.3.0", + "resolved": "https://registry.npmjs.org/estraverse/-/estraverse-4.3.0.tgz", + "integrity": "sha512-39nnKffWz8xN1BU/2c79n9nB9HDzo0niYUqx6xyqUnyoAnQyyWpOTdZEeiCch8BBu515t4wp9ZmgVfVhn9EBpw==", + "engines": { + "node": ">=4.0" + } + }, + "node_modules/esutils": { + "version": "2.0.3", + "resolved": "https://registry.npmjs.org/esutils/-/esutils-2.0.3.tgz", + "integrity": "sha512-kVscqXk4OCp68SZ0dkgEKVi6/8ij300KBWTJq32P/dYeWTSwK41WyTxalN1eRmA5Z9UU/LX9D7FWSmV9SAYx6g==", + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/etag": { + "version": "1.8.1", + "resolved": "https://registry.npmjs.org/etag/-/etag-1.8.1.tgz", + "integrity": "sha512-aIL5Fx7mawVa300al2BnEE4iNvo1qETxLrPI/o05L7z6go7fCw1J6EQmbK4FmJ2AS7kgVF/KEZWufBfdClMcPg==", + "engines": { + "node": ">= 0.6" + } + }, + "node_modules/express": { + "version": "4.18.2", + "resolved": "https://registry.npmjs.org/express/-/express-4.18.2.tgz", + "integrity": "sha512-5/PsL6iGPdfQ/lKM1UuielYgv3BUoJfz1aUwU9vHZ+J7gyvwdQXFEBIEIaxeGf0GIcreATNyBExtalisDbuMqQ==", + "dependencies": { + "accepts": "~1.3.8", + "array-flatten": "1.1.1", + "body-parser": "1.20.1", + "content-disposition": "0.5.4", + "content-type": "~1.0.4", + "cookie": "0.5.0", + "cookie-signature": "1.0.6", + "debug": "2.6.9", + "depd": "2.0.0", + "encodeurl": "~1.0.2", + "escape-html": "~1.0.3", + "etag": "~1.8.1", + "finalhandler": "1.2.0", + "fresh": "0.5.2", + "http-errors": "2.0.0", + "merge-descriptors": "1.0.1", + "methods": "~1.1.2", + "on-finished": "2.4.1", + "parseurl": "~1.3.3", + "path-to-regexp": "0.1.7", + "proxy-addr": "~2.0.7", + "qs": "6.11.0", + "range-parser": "~1.2.1", + "safe-buffer": "5.2.1", + "send": "0.18.0", + "serve-static": "1.15.0", + "setprototypeof": "1.2.0", + "statuses": "2.0.1", + "type-is": "~1.6.18", + "utils-merge": "1.0.1", + "vary": "~1.1.2" + }, + "engines": { + "node": ">= 0.10.0" + } + }, + "node_modules/express/node_modules/debug": { + "version": "2.6.9", + "resolved": "https://registry.npmjs.org/debug/-/debug-2.6.9.tgz", + "integrity": "sha512-bC7ElrdJaJnPbAP+1EotYvqZsb3ecl5wi6Bfi6BJTUcNowp6cvspg0jXznRTKDjm/E7AdgFBVeAPVMNcKGsHMA==", + "dependencies": { + "ms": "2.0.0" + } + }, + "node_modules/express/node_modules/ms": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/ms/-/ms-2.0.0.tgz", + "integrity": "sha512-Tpp60P6IUJDTuOq/5Z8cdskzJujfwqfOTkrwIwj7IRISpnkJnT6SyJ4PCPnGMoFjC9ddhal5KVIYtAt97ix05A==" + }, + "node_modules/fast-levenshtein": { + "version": "2.0.6", + "resolved": "https://registry.npmjs.org/fast-levenshtein/-/fast-levenshtein-2.0.6.tgz", + "integrity": "sha512-DCXu6Ifhqcks7TZKY3Hxp3y6qphY5SJZmrWMDrKcERSOXWQdMhU9Ig/PYrzyw/ul9jOIyh0N4M0tbC5hodg8dw==" + }, + "node_modules/fastfile": { + "version": "0.0.20", + "resolved": "https://registry.npmjs.org/fastfile/-/fastfile-0.0.20.tgz", + "integrity": "sha512-r5ZDbgImvVWCP0lA/cGNgQcZqR+aYdFx3u+CtJqUE510pBUVGMn4ulL/iRTI4tACTYsNJ736uzFxEBXesPAktA==" + }, + "node_modules/ffjavascript": { + "version": "0.2.63", + "resolved": "https://registry.npmjs.org/ffjavascript/-/ffjavascript-0.2.63.tgz", + "integrity": "sha512-dBgdsfGks58b66JnUZeZpGxdMIDQ4QsD3VYlRJyFVrKQHb2kJy4R2gufx5oetrTxXPT+aEjg0dOvOLg1N0on4A==", + "dependencies": { + "wasmbuilder": "0.0.16", + "wasmcurves": "0.2.2", + "web-worker": "1.2.0" + } + }, + "node_modules/filelist": { + "version": "1.0.4", + "resolved": "https://registry.npmjs.org/filelist/-/filelist-1.0.4.tgz", + "integrity": "sha512-w1cEuf3S+DrLCQL7ET6kz+gmlJdbq9J7yXCSjK/OZCPA+qEN1WyF4ZAf0YYJa4/shHJra2t/d/r8SV4Ji+x+8Q==", + "dependencies": { + "minimatch": "^5.0.1" + } + }, + "node_modules/fill-range": { + "version": "7.0.1", + "resolved": "https://registry.npmjs.org/fill-range/-/fill-range-7.0.1.tgz", + "integrity": "sha512-qOo9F+dMUmC2Lcb4BbVvnKJxTPjCm+RRpe4gDuGrzkL7mEVl/djYSu2OdQ2Pa302N4oqkSg9ir6jaLWJ2USVpQ==", + "dependencies": { + "to-regex-range": "^5.0.1" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/finalhandler": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/finalhandler/-/finalhandler-1.2.0.tgz", + "integrity": "sha512-5uXcUVftlQMFnWC9qu/svkWv3GTd2PfUhK/3PLkYNAe7FbqJMt3515HaxE6eRL74GdsriiwujiawdaB1BpEISg==", + "dependencies": { + "debug": "2.6.9", + "encodeurl": "~1.0.2", + "escape-html": "~1.0.3", + "on-finished": "2.4.1", + "parseurl": "~1.3.3", + "statuses": "2.0.1", + "unpipe": "~1.0.0" + }, + "engines": { + "node": ">= 0.8" + } + }, + "node_modules/finalhandler/node_modules/debug": { + "version": "2.6.9", + "resolved": "https://registry.npmjs.org/debug/-/debug-2.6.9.tgz", + "integrity": "sha512-bC7ElrdJaJnPbAP+1EotYvqZsb3ecl5wi6Bfi6BJTUcNowp6cvspg0jXznRTKDjm/E7AdgFBVeAPVMNcKGsHMA==", + "dependencies": { + "ms": "2.0.0" + } + }, + "node_modules/finalhandler/node_modules/ms": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/ms/-/ms-2.0.0.tgz", + "integrity": "sha512-Tpp60P6IUJDTuOq/5Z8cdskzJujfwqfOTkrwIwj7IRISpnkJnT6SyJ4PCPnGMoFjC9ddhal5KVIYtAt97ix05A==" + }, + "node_modules/find-up": { + "version": "5.0.0", + "resolved": "https://registry.npmjs.org/find-up/-/find-up-5.0.0.tgz", + "integrity": "sha512-78/PXT1wlLLDgTzDs7sjq9hzz0vXD+zn+7wypEe4fXQxCmdmqfGsEPQxmiCSQI3ajFV91bVSsvNtrJRiW6nGng==", + "dependencies": { + "locate-path": "^6.0.0", + "path-exists": "^4.0.0" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/flat": { + "version": "5.0.2", + "resolved": "https://registry.npmjs.org/flat/-/flat-5.0.2.tgz", + "integrity": "sha512-b6suED+5/3rTpUBdG1gupIl8MPFCAMA0QXwmljLhvCUKcUvdE4gWky9zpuGCcXHOsz4J9wPGNWq6OKpmIzz3hQ==", + "bin": { + "flat": "cli.js" + } + }, + "node_modules/fnv-plus": { + "version": "1.3.1", + "resolved": "https://registry.npmjs.org/fnv-plus/-/fnv-plus-1.3.1.tgz", + "integrity": "sha512-Gz1EvfOneuFfk4yG458dJ3TLJ7gV19q3OM/vVvvHf7eT02Hm1DleB4edsia6ahbKgAYxO9gvyQ1ioWZR+a00Yw==" + }, + "node_modules/for-each": { + "version": "0.3.3", + "resolved": "https://registry.npmjs.org/for-each/-/for-each-0.3.3.tgz", + "integrity": "sha512-jqYfLp7mo9vIyQf8ykW2v7A+2N4QjeCeI5+Dz9XraiO1ign81wjiH7Fb9vSOWvQfNtmSa4H2RoQTrrXivdUZmw==", + "dependencies": { + "is-callable": "^1.1.3" + } + }, + "node_modules/forwarded": { + "version": "0.2.0", + "resolved": "https://registry.npmjs.org/forwarded/-/forwarded-0.2.0.tgz", + "integrity": "sha512-buRG0fpBtRHSTCOASe6hD258tEubFoRLb4ZNA6NxMVHNw2gOcwHo9wyablzMzOA5z9xA9L1KNjk/Nt6MT9aYow==", + "engines": { + "node": ">= 0.6" + } + }, + "node_modules/fresh": { + "version": "0.5.2", + "resolved": "https://registry.npmjs.org/fresh/-/fresh-0.5.2.tgz", + "integrity": "sha512-zJ2mQYM18rEFOudeV4GShTGIQ7RbzA7ozbU9I/XBpm7kqgMywgmylMwXHxZJmkVoYkna9d2pVXVXPdYTP9ej8Q==", + "engines": { + "node": ">= 0.6" + } + }, + "node_modules/fs.realpath": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/fs.realpath/-/fs.realpath-1.0.0.tgz", + "integrity": "sha512-OO0pH2lK6a0hZnAdau5ItzHPI6pUlvI7jMVnxUQRtw4owF2wk8lOSabtGDCTP4Ggrg2MbGnWO9X8K1t4+fGMDw==" + }, + "node_modules/fsevents": { + "version": "2.3.3", + "resolved": "https://registry.npmjs.org/fsevents/-/fsevents-2.3.3.tgz", + "integrity": "sha512-5xoDfX+fL7faATnagmWPpbFtwh/R77WmMMqqHGS65C3vvB0YHrgF+B1YmZ3441tMj5n63k0212XNoJwzlhffQw==", + "hasInstallScript": true, + "optional": true, + "os": [ + "darwin" + ], + "engines": { + "node": "^8.16.0 || ^10.6.0 || >=11.0.0" + } + }, + "node_modules/function-bind": { + "version": "1.1.2", + "resolved": "https://registry.npmjs.org/function-bind/-/function-bind-1.1.2.tgz", + "integrity": "sha512-7XHNxH7qX9xG5mIwxkhumTox/MIRNcOgDrxWsMt2pAr23WHp6MrRlN7FBSFpCpr+oVO0F744iUgR82nJMfG2SA==", + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/get-caller-file": { + "version": "2.0.5", + "resolved": "https://registry.npmjs.org/get-caller-file/-/get-caller-file-2.0.5.tgz", + "integrity": "sha512-DyFP3BM/3YHTQOCUL/w0OZHR0lpKeGrxotcHWcqNEdnltqFwXVfhEBQ94eIo34AfQpo0rGki4cyIiftY06h2Fg==", + "engines": { + "node": "6.* || 8.* || >= 10.*" + } + }, + "node_modules/get-func-name": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/get-func-name/-/get-func-name-2.0.2.tgz", + "integrity": "sha512-8vXOvuE167CtIc3OyItco7N/dpRtBbYOsPsXCz7X/PMnlGjYjSGuZJgM1Y7mmew7BKf9BqvLX2tnOVy1BBUsxQ==", + "engines": { + "node": "*" + } + }, + "node_modules/get-intrinsic": { + "version": "1.2.2", + "resolved": "https://registry.npmjs.org/get-intrinsic/-/get-intrinsic-1.2.2.tgz", + "integrity": "sha512-0gSo4ml/0j98Y3lngkFEot/zhiCeWsbYIlZ+uZOVgzLyLaUw7wxUL+nCTP0XJvJg1AXulJRI3UJi8GsbDuxdGA==", + "dependencies": { + "function-bind": "^1.1.2", + "has-proto": "^1.0.1", + "has-symbols": "^1.0.3", + "hasown": "^2.0.0" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/glob": { + "version": "7.2.0", + "resolved": "https://registry.npmjs.org/glob/-/glob-7.2.0.tgz", + "integrity": "sha512-lmLf6gtyrPq8tTjSmrO94wBeQbFR3HbLHbuyD69wuyQkImp2hWqMGB47OX65FBkPffO641IP9jWa1z4ivqG26Q==", + "dependencies": { + "fs.realpath": "^1.0.0", + "inflight": "^1.0.4", + "inherits": "2", + "minimatch": "^3.0.4", + "once": "^1.3.0", + "path-is-absolute": "^1.0.0" + }, + "engines": { + "node": "*" + }, + "funding": { + "url": "https://github.com/sponsors/isaacs" + } + }, + "node_modules/glob-parent": { + "version": "5.1.2", + "resolved": "https://registry.npmjs.org/glob-parent/-/glob-parent-5.1.2.tgz", + "integrity": "sha512-AOIgSQCepiJYwP3ARnGx+5VnTu2HBYdzbGP45eLw1vr3zB3vZLeyed1sC9hnbcOc9/SrMyM5RPQrkGz4aS9Zow==", + "dependencies": { + "is-glob": "^4.0.1" + }, + "engines": { + "node": ">= 6" + } + }, + "node_modules/glob/node_modules/brace-expansion": { + "version": "1.1.11", + "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.11.tgz", + "integrity": "sha512-iCuPHDFgrHX7H2vEI/5xpz07zSHB00TpugqhmYtVmMO6518mCuRMoOYFldEBl0g187ufozdaHgWKcYFb61qGiA==", + "dependencies": { + "balanced-match": "^1.0.0", + "concat-map": "0.0.1" + } + }, + "node_modules/glob/node_modules/minimatch": { + "version": "3.1.2", + "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.1.2.tgz", + "integrity": "sha512-J7p63hRiAjw1NDEww1W7i37+ByIrOWO5XQQAzZ3VOcL0PNybwpfmV/N05zFAzwQ9USyEcX6t3UO+K5aqBQOIHw==", + "dependencies": { + "brace-expansion": "^1.1.7" + }, + "engines": { + "node": "*" + } + }, + "node_modules/gopd": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/gopd/-/gopd-1.0.1.tgz", + "integrity": "sha512-d65bNlIadxvpb/A2abVdlqKqV563juRnZ1Wtk6s1sIR8uNsXR70xqIzVqxVf1eTqDunwT2MkczEeaezCKTZhwA==", + "dependencies": { + "get-intrinsic": "^1.1.3" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/has-flag": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-4.0.0.tgz", + "integrity": "sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ==", + "engines": { + "node": ">=8" + } + }, + "node_modules/has-property-descriptors": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/has-property-descriptors/-/has-property-descriptors-1.0.1.tgz", + "integrity": "sha512-VsX8eaIewvas0xnvinAe9bw4WfIeODpGYikiWYLH+dma0Jw6KHYqWiWfhQlgOVK8D6PvjubK5Uc4P0iIhIcNVg==", + "dependencies": { + "get-intrinsic": "^1.2.2" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/has-proto": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/has-proto/-/has-proto-1.0.1.tgz", + "integrity": "sha512-7qE+iP+O+bgF9clE5+UoBFzE65mlBiVj3tKCrlNQ0Ogwm0BjpT/gK4SlLYDMybDh5I3TCTKnPPa0oMG7JDYrhg==", + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/has-symbols": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/has-symbols/-/has-symbols-1.0.3.tgz", + "integrity": "sha512-l3LCuF6MgDNwTDKkdYGEihYjt5pRPbEg46rtlmnSPlUbgmB8LOIrKJbYYFBSbnPaJexMKtiPO8hmeRjRz2Td+A==", + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/has-tostringtag": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/has-tostringtag/-/has-tostringtag-1.0.0.tgz", + "integrity": "sha512-kFjcSNhnlGV1kyoGk7OXKSawH5JOb/LzUc5w9B02hOTO0dfFRjbHQKvg1d6cf3HbeUmtU9VbbV3qzZ2Teh97WQ==", + "dependencies": { + "has-symbols": "^1.0.2" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/hasown": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/hasown/-/hasown-2.0.0.tgz", + "integrity": "sha512-vUptKVTpIJhcczKBbgnS+RtcuYMB8+oNzPK2/Hp3hanz8JmpATdmmgLgSaadVREkDm+e2giHwY3ZRkyjSIDDFA==", + "dependencies": { + "function-bind": "^1.1.2" + }, + "engines": { + "node": ">= 0.4" + } + }, + "node_modules/he": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/he/-/he-1.2.0.tgz", + "integrity": "sha512-F/1DnUGPopORZi0ni+CvrCgHQ5FyEAHRLSApuYWMmrbSwoN2Mn/7k+Gl38gJnR7yyDZk6WLXwiGod1JOWNDKGw==", + "bin": { + "he": "bin/he" + } + }, + "node_modules/hoopy": { + "version": "0.1.4", + "resolved": "https://registry.npmjs.org/hoopy/-/hoopy-0.1.4.tgz", + "integrity": "sha512-HRcs+2mr52W0K+x8RzcLzuPPmVIKMSv97RGHy0Ea9y/mpcaK+xTrjICA04KAHi4GRzxliNqNJEFYWHghy3rSfQ==", + "engines": { + "node": ">= 6.0.0" + } + }, + "node_modules/http-errors": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/http-errors/-/http-errors-2.0.0.tgz", + "integrity": "sha512-FtwrG/euBzaEjYeRqOgly7G0qviiXoJWnvEH2Z1plBdXgbyjv34pHTSb9zoeHMyDy33+DWy5Wt9Wo+TURtOYSQ==", + "dependencies": { + "depd": "2.0.0", + "inherits": "2.0.4", + "setprototypeof": "1.2.0", + "statuses": "2.0.1", + "toidentifier": "1.0.1" + }, + "engines": { + "node": ">= 0.8" + } + }, + "node_modules/iconv-lite": { + "version": "0.4.24", + "resolved": "https://registry.npmjs.org/iconv-lite/-/iconv-lite-0.4.24.tgz", + "integrity": "sha512-v3MXnZAcvnywkTUEZomIActle7RXXeedOR31wwl7VlyoXO4Qi9arvSenNQWne1TcRwhCL1HwLI21bEqdpj8/rA==", + "dependencies": { + "safer-buffer": ">= 2.1.2 < 3" + }, + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/inflight": { + "version": "1.0.6", + "resolved": "https://registry.npmjs.org/inflight/-/inflight-1.0.6.tgz", + "integrity": "sha512-k92I/b08q4wvFscXCLvqfsHCrjrF7yiXsQuIVvVE7N82W3+aqpzuUdBbfhWcy/FZR3/4IgflMgKLOsvPDrGCJA==", + "dependencies": { + "once": "^1.3.0", + "wrappy": "1" + } + }, + "node_modules/inherits": { + "version": "2.0.4", + "resolved": "https://registry.npmjs.org/inherits/-/inherits-2.0.4.tgz", + "integrity": "sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ==" + }, + "node_modules/ipaddr.js": { + "version": "1.9.1", + "resolved": "https://registry.npmjs.org/ipaddr.js/-/ipaddr.js-1.9.1.tgz", + "integrity": "sha512-0KI/607xoxSToH7GjN1FfSbLoU0+btTicjsQSWQlh/hZykN8KpmMf7uYwPW3R+akZ6R/w18ZlXSHBYXiYUPO3g==", + "engines": { + "node": ">= 0.10" + } + }, + "node_modules/is-arguments": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/is-arguments/-/is-arguments-1.1.1.tgz", + "integrity": "sha512-8Q7EARjzEnKpt/PCD7e1cgUS0a6X8u5tdSiMqXhojOdoV9TsMsiO+9VLC5vAmO8N7/GmXn7yjR8qnA6bVAEzfA==", + "dependencies": { + "call-bind": "^1.0.2", + "has-tostringtag": "^1.0.0" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/is-binary-path": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/is-binary-path/-/is-binary-path-2.1.0.tgz", + "integrity": "sha512-ZMERYes6pDydyuGidse7OsHxtbI7WVeUEozgR/g7rd0xUimYNlvZRE/K2MgZTjWy725IfelLeVcEM97mmtRGXw==", + "dependencies": { + "binary-extensions": "^2.0.0" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/is-callable": { + "version": "1.2.7", + "resolved": "https://registry.npmjs.org/is-callable/-/is-callable-1.2.7.tgz", + "integrity": "sha512-1BC0BVFhS/p0qtw6enp8e+8OD0UrK0oFLztSjNzhcKA3WDuJxxAPXzPuPtKkjEY9UUoEWlX/8fgKeu2S8i9JTA==", + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/is-extglob": { + "version": "2.1.1", + "resolved": "https://registry.npmjs.org/is-extglob/-/is-extglob-2.1.1.tgz", + "integrity": "sha512-SbKbANkN603Vi4jEZv49LeVJMn4yGwsbzZworEoyEiutsN3nJYdbO36zfhGJ6QEDpOZIFkDtnq5JRxmvl3jsoQ==", + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/is-fullwidth-code-point": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/is-fullwidth-code-point/-/is-fullwidth-code-point-3.0.0.tgz", + "integrity": "sha512-zymm5+u+sCsSWyD9qNaejV3DFvhCKclKdizYaJUuHA83RLjb7nSuGnddCHGv0hk+KY7BMAlsWeK4Ueg6EV6XQg==", + "engines": { + "node": ">=8" + } + }, + "node_modules/is-generator-function": { + "version": "1.0.10", + "resolved": "https://registry.npmjs.org/is-generator-function/-/is-generator-function-1.0.10.tgz", + "integrity": "sha512-jsEjy9l3yiXEQ+PsXdmBwEPcOxaXWLspKdplFUVI9vq1iZgIekeC0L167qeu86czQaxed3q/Uzuw0swL0irL8A==", + "dependencies": { + "has-tostringtag": "^1.0.0" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/is-glob": { + "version": "4.0.3", + "resolved": "https://registry.npmjs.org/is-glob/-/is-glob-4.0.3.tgz", + "integrity": "sha512-xelSayHH36ZgE7ZWhli7pW34hNbNl8Ojv5KVmkJD4hBdD3th8Tfk9vYasLM+mXWOZhFkgZfxhLSnrwRr4elSSg==", + "dependencies": { + "is-extglob": "^2.1.1" + }, + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/is-number": { + "version": "7.0.0", + "resolved": "https://registry.npmjs.org/is-number/-/is-number-7.0.0.tgz", + "integrity": "sha512-41Cifkg6e8TylSpdtTpeLVMqvSBEVzTttHvERD741+pnZ8ANv0004MRL43QKPDlK9cGvNp6NZWZUBlbGXYxxng==", + "engines": { + "node": ">=0.12.0" + } + }, + "node_modules/is-plain-obj": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/is-plain-obj/-/is-plain-obj-2.1.0.tgz", + "integrity": "sha512-YWnfyRwxL/+SsrWYfOpUtz5b3YD+nyfkHvjbcanzk8zgyO4ASD67uVMRt8k5bM4lLMDnXfriRhOpemw+NfT1eA==", + "engines": { + "node": ">=8" + } + }, + "node_modules/is-typed-array": { + "version": "1.1.12", + "resolved": "https://registry.npmjs.org/is-typed-array/-/is-typed-array-1.1.12.tgz", + "integrity": "sha512-Z14TF2JNG8Lss5/HMqt0//T9JeHXttXy5pH/DBU4vi98ozO2btxzq9MwYDZYnKwU8nRsz/+GVFVRDq3DkVuSPg==", + "dependencies": { + "which-typed-array": "^1.1.11" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/is-unicode-supported": { + "version": "0.1.0", + "resolved": "https://registry.npmjs.org/is-unicode-supported/-/is-unicode-supported-0.1.0.tgz", + "integrity": "sha512-knxG2q4UC3u8stRGyAVJCOdxFmv5DZiRcdlIaAQXAbSfJya+OhopNotLQrstBhququ4ZpuKbDc/8S6mgXgPFPw==", + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/jake": { + "version": "10.8.7", + "resolved": "https://registry.npmjs.org/jake/-/jake-10.8.7.tgz", + "integrity": "sha512-ZDi3aP+fG/LchyBzUM804VjddnwfSfsdeYkwt8NcbKRvo4rFkjhs456iLFn3k2ZUWvNe4i48WACDbza8fhq2+w==", + "dependencies": { + "async": "^3.2.3", + "chalk": "^4.0.2", + "filelist": "^1.0.4", + "minimatch": "^3.1.2" + }, + "bin": { + "jake": "bin/cli.js" + }, + "engines": { + "node": ">=10" + } + }, + "node_modules/jake/node_modules/brace-expansion": { + "version": "1.1.11", + "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.11.tgz", + "integrity": "sha512-iCuPHDFgrHX7H2vEI/5xpz07zSHB00TpugqhmYtVmMO6518mCuRMoOYFldEBl0g187ufozdaHgWKcYFb61qGiA==", + "dependencies": { + "balanced-match": "^1.0.0", + "concat-map": "0.0.1" + } + }, + "node_modules/jake/node_modules/minimatch": { + "version": "3.1.2", + "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.1.2.tgz", + "integrity": "sha512-J7p63hRiAjw1NDEww1W7i37+ByIrOWO5XQQAzZ3VOcL0PNybwpfmV/N05zFAzwQ9USyEcX6t3UO+K5aqBQOIHw==", + "dependencies": { + "brace-expansion": "^1.1.7" + }, + "engines": { + "node": "*" + } + }, + "node_modules/js-sha3": { + "version": "0.8.0", + "resolved": "https://registry.npmjs.org/js-sha3/-/js-sha3-0.8.0.tgz", + "integrity": "sha512-gF1cRrHhIzNfToc802P800N8PpXS+evLLXfsVpowqmAFR9uwbi89WvXg2QspOmXL8QL86J4T1EpFu+yUkwJY3Q==" + }, + "node_modules/js-yaml": { + "version": "4.1.0", + "resolved": "https://registry.npmjs.org/js-yaml/-/js-yaml-4.1.0.tgz", + "integrity": "sha512-wpxZs9NoxZaJESJGIZTyDEaYpl0FKSA+FB9aJiyemKhMwkxQg63h4T1KJgUGHpTqPDNRcmmYLugrRjJlBtWvRA==", + "dependencies": { + "argparse": "^2.0.1" + }, + "bin": { + "js-yaml": "bin/js-yaml.js" + } + }, + "node_modules/jsonpath": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/jsonpath/-/jsonpath-1.1.1.tgz", + "integrity": "sha512-l6Cg7jRpixfbgoWgkrl77dgEj8RPvND0wMH6TwQmi9Qs4TFfS9u5cUFnbeKTwj5ga5Y3BTGGNI28k117LJ009w==", + "dependencies": { + "esprima": "1.2.2", + "static-eval": "2.0.2", + "underscore": "1.12.1" + } + }, + "node_modules/levn": { + "version": "0.3.0", + "resolved": "https://registry.npmjs.org/levn/-/levn-0.3.0.tgz", + "integrity": "sha512-0OO4y2iOHix2W6ujICbKIaEQXvFQHue65vUG3pb5EUomzPI90z9hsA1VsO/dbIIpC53J8gxM9Q4Oho0jrCM/yA==", + "dependencies": { + "prelude-ls": "~1.1.2", + "type-check": "~0.3.2" + }, + "engines": { + "node": ">= 0.8.0" + } + }, + "node_modules/locate-path": { + "version": "6.0.0", + "resolved": "https://registry.npmjs.org/locate-path/-/locate-path-6.0.0.tgz", + "integrity": "sha512-iPZK6eYjbxRu3uB4/WZ3EsEIMJFMqAoopl3R+zuq0UjcAm/MO6KCweDgPfP3elTztoKP3KtnVHxTn2NHBSDVUw==", + "dependencies": { + "p-locate": "^5.0.0" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/log-symbols": { + "version": "4.1.0", + "resolved": "https://registry.npmjs.org/log-symbols/-/log-symbols-4.1.0.tgz", + "integrity": "sha512-8XPvpAA8uyhfteu8pIvQxpJZ7SYYdpUivZpGy6sFsBuKRY/7rQGavedeB8aK+Zkyq6upMFVL/9AW6vOYzfRyLg==", + "dependencies": { + "chalk": "^4.1.0", + "is-unicode-supported": "^0.1.0" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/logplease": { + "version": "1.2.15", + "resolved": "https://registry.npmjs.org/logplease/-/logplease-1.2.15.tgz", + "integrity": "sha512-jLlHnlsPSJjpwUfcNyUxXCl33AYg2cHhIf9QhGL2T4iPT0XPB+xP1LRKFPgIg1M/sg9kAJvy94w9CzBNrfnstA==" + }, + "node_modules/loupe": { + "version": "2.3.7", + "resolved": "https://registry.npmjs.org/loupe/-/loupe-2.3.7.tgz", + "integrity": "sha512-zSMINGVYkdpYSOBmLi0D1Uo7JU9nVdQKrHxC8eYlV+9YKK9WePqAlL7lSlorG/U2Fw1w0hTBmaa/jrQ3UbPHtA==", + "dependencies": { + "get-func-name": "^2.0.1" + } + }, + "node_modules/media-typer": { + "version": "0.3.0", + "resolved": "https://registry.npmjs.org/media-typer/-/media-typer-0.3.0.tgz", + "integrity": "sha512-dq+qelQ9akHpcOl/gUVRTxVIOkAJ1wR3QAvb4RsVjS8oVoFjDGTc679wJYmUmknUF5HwMLOgb5O+a3KxfWapPQ==", + "engines": { + "node": ">= 0.6" + } + }, + "node_modules/merge-descriptors": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/merge-descriptors/-/merge-descriptors-1.0.1.tgz", + "integrity": "sha512-cCi6g3/Zr1iqQi6ySbseM1Xvooa98N0w31jzUYrXPX2xqObmFGHJ0tQ5u74H3mVh7wLouTseZyYIq39g8cNp1w==" + }, + "node_modules/methods": { + "version": "1.1.2", + "resolved": "https://registry.npmjs.org/methods/-/methods-1.1.2.tgz", + "integrity": "sha512-iclAHeNqNm68zFtnZ0e+1L2yUIdvzNoauKU4WBA3VvH/vPFieF7qfRlwUZU+DA9P9bPXIS90ulxoUoCH23sV2w==", + "engines": { + "node": ">= 0.6" + } + }, + "node_modules/mime": { + "version": "1.6.0", + "resolved": "https://registry.npmjs.org/mime/-/mime-1.6.0.tgz", + "integrity": "sha512-x0Vn8spI+wuJ1O6S7gnbaQg8Pxh4NNHb7KSINmEWKiPE4RKOplvijn+NkmYmmRgP68mc70j2EbeTFRsrswaQeg==", + "bin": { + "mime": "cli.js" + }, + "engines": { + "node": ">=4" + } + }, + "node_modules/mime-db": { + "version": "1.52.0", + "resolved": "https://registry.npmjs.org/mime-db/-/mime-db-1.52.0.tgz", + "integrity": "sha512-sPU4uV7dYlvtWJxwwxHD0PuihVNiE7TyAbQ5SWxDCB9mUYvOgroQOwYQQOKPJ8CIbE+1ETVlOoK1UC2nU3gYvg==", + "engines": { + "node": ">= 0.6" + } + }, + "node_modules/mime-types": { + "version": "2.1.35", + "resolved": "https://registry.npmjs.org/mime-types/-/mime-types-2.1.35.tgz", + "integrity": "sha512-ZDY+bPm5zTTF+YpCrAU9nK0UgICYPT0QtT1NZWFv4s++TNkcgVaT0g6+4R2uI4MjQjzysHB1zxuWL50hzaeXiw==", + "dependencies": { + "mime-db": "1.52.0" + }, + "engines": { + "node": ">= 0.6" + } + }, + "node_modules/minimatch": { + "version": "5.0.1", + "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-5.0.1.tgz", + "integrity": "sha512-nLDxIFRyhDblz3qMuq+SoRZED4+miJ/G+tdDrjkkkRnjAsBexeGpgjLEQ0blJy7rHhR2b93rhQY4SvyWu9v03g==", + "dependencies": { + "brace-expansion": "^2.0.1" + }, + "engines": { + "node": ">=10" + } + }, + "node_modules/mocha": { + "version": "10.2.0", + "resolved": "https://registry.npmjs.org/mocha/-/mocha-10.2.0.tgz", + "integrity": "sha512-IDY7fl/BecMwFHzoqF2sg/SHHANeBoMMXFlS9r0OXKDssYE1M5O43wUY/9BVPeIvfH2zmEbBfseqN9gBQZzXkg==", + "dependencies": { + "ansi-colors": "4.1.1", + "browser-stdout": "1.3.1", + "chokidar": "3.5.3", + "debug": "4.3.4", + "diff": "5.0.0", + "escape-string-regexp": "4.0.0", + "find-up": "5.0.0", + "glob": "7.2.0", + "he": "1.2.0", + "js-yaml": "4.1.0", + "log-symbols": "4.1.0", + "minimatch": "5.0.1", + "ms": "2.1.3", + "nanoid": "3.3.3", + "serialize-javascript": "6.0.0", + "strip-json-comments": "3.1.1", + "supports-color": "8.1.1", + "workerpool": "6.2.1", + "yargs": "16.2.0", + "yargs-parser": "20.2.4", + "yargs-unparser": "2.0.0" + }, + "bin": { + "_mocha": "bin/_mocha", + "mocha": "bin/mocha.js" + }, + "engines": { + "node": ">= 14.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/mochajs" + } + }, + "node_modules/ms": { + "version": "2.1.3", + "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz", + "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==" + }, + "node_modules/nanoassert": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/nanoassert/-/nanoassert-2.0.0.tgz", + "integrity": "sha512-7vO7n28+aYO4J+8w96AzhmU8G+Y/xpPDJz/se19ICsqj/momRbb9mh9ZUtkoJ5X3nTnPdhEJyc0qnM6yAsHBaA==" + }, + "node_modules/nanoid": { + "version": "3.3.3", + "resolved": "https://registry.npmjs.org/nanoid/-/nanoid-3.3.3.tgz", + "integrity": "sha512-p1sjXuopFs0xg+fPASzQ28agW1oHD7xDsd9Xkf3T15H3c/cifrFHVwrh74PdoklAPi+i7MdRsE47vm2r6JoB+w==", + "bin": { + "nanoid": "bin/nanoid.cjs" + }, + "engines": { + "node": "^10 || ^12 || ^13.7 || ^14 || >=15.0.1" + } + }, + "node_modules/negotiator": { + "version": "0.6.3", + "resolved": "https://registry.npmjs.org/negotiator/-/negotiator-0.6.3.tgz", + "integrity": "sha512-+EUsqGPLsM+j/zdChZjsnX51g4XrHFOIXwfnCVPGlQk/k5giakcKsuxCObBRu6DSm9opw/O6slWbJdghQM4bBg==", + "engines": { + "node": ">= 0.6" + } + }, + "node_modules/normalize-path": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/normalize-path/-/normalize-path-3.0.0.tgz", + "integrity": "sha512-6eZs5Ls3WtCisHWp9S2GUy8dqkpGi4BVSz3GaqiE6ezub0512ESztXUwUB6C6IKbQkY2Pnb/mD4WYojCRwcwLA==", + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/object-inspect": { + "version": "1.13.1", + "resolved": "https://registry.npmjs.org/object-inspect/-/object-inspect-1.13.1.tgz", + "integrity": "sha512-5qoj1RUiKOMsCCNLV1CBiPYE10sziTsnmNxkAI/rZhiD63CF7IqdFGC/XzjWjpSgLf0LxXX3bDFIh0E18f6UhQ==", + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/on-finished": { + "version": "2.4.1", + "resolved": "https://registry.npmjs.org/on-finished/-/on-finished-2.4.1.tgz", + "integrity": "sha512-oVlzkg3ENAhCk2zdv7IJwd/QUD4z2RxRwpkcGY8psCVcCYZNq4wYnVWALHM+brtuJjePWiYF/ClmuDr8Ch5+kg==", + "dependencies": { + "ee-first": "1.1.1" + }, + "engines": { + "node": ">= 0.8" + } + }, + "node_modules/once": { + "version": "1.4.0", + "resolved": "https://registry.npmjs.org/once/-/once-1.4.0.tgz", + "integrity": "sha512-lNaJgI+2Q5URQBkccEKHTQOPaXdUxnZZElQTZY0MFUAuaEqe1E+Nyvgdz/aIyNi6Z9MzO5dv1H8n58/GELp3+w==", + "dependencies": { + "wrappy": "1" + } + }, + "node_modules/optionator": { + "version": "0.8.3", + "resolved": "https://registry.npmjs.org/optionator/-/optionator-0.8.3.tgz", + "integrity": "sha512-+IW9pACdk3XWmmTXG8m3upGUJst5XRGzxMRjXzAuJ1XnIFNvfhjjIuYkDvysnPQ7qzqVzLt78BCruntqRhWQbA==", + "dependencies": { + "deep-is": "~0.1.3", + "fast-levenshtein": "~2.0.6", + "levn": "~0.3.0", + "prelude-ls": "~1.1.2", + "type-check": "~0.3.2", + "word-wrap": "~1.2.3" + }, + "engines": { + "node": ">= 0.8.0" + } + }, + "node_modules/p-limit": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/p-limit/-/p-limit-3.1.0.tgz", + "integrity": "sha512-TYOanM3wGwNGsZN2cVTYPArw454xnXj5qmWF1bEoAc4+cU/ol7GVh7odevjp1FNHduHc3KZMcFduxU5Xc6uJRQ==", + "dependencies": { + "yocto-queue": "^0.1.0" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/p-locate": { + "version": "5.0.0", + "resolved": "https://registry.npmjs.org/p-locate/-/p-locate-5.0.0.tgz", + "integrity": "sha512-LaNjtRWUBY++zB5nE/NwcaoMylSPk+S+ZHNB1TzdbMJMny6dynpAGt7X/tl/QYq3TIeE6nxHppbo2LGymrG5Pw==", + "dependencies": { + "p-limit": "^3.0.2" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/parseurl": { + "version": "1.3.3", + "resolved": "https://registry.npmjs.org/parseurl/-/parseurl-1.3.3.tgz", + "integrity": "sha512-CiyeOxFT/JZyN5m0z9PfXw4SCBJ6Sygz1Dpl0wqjlhDEGGBP1GnsUVEL0p63hoG1fcj3fHynXi9NYO4nWOL+qQ==", + "engines": { + "node": ">= 0.8" + } + }, + "node_modules/path-exists": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/path-exists/-/path-exists-4.0.0.tgz", + "integrity": "sha512-ak9Qy5Q7jYb2Wwcey5Fpvg2KoAc/ZIhLSLOSBmRmygPsGwkVVt0fZa0qrtMz+m6tJTAHfZQ8FnmB4MG4LWy7/w==", + "engines": { + "node": ">=8" + } + }, + "node_modules/path-is-absolute": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/path-is-absolute/-/path-is-absolute-1.0.1.tgz", + "integrity": "sha512-AVbw3UJ2e9bq64vSaS9Am0fje1Pa8pbGqTTsmXfaIiMpnr5DlDhfJOuLj9Sf95ZPVDAUerDfEk88MPmPe7UCQg==", + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/path-to-regexp": { + "version": "0.1.7", + "resolved": "https://registry.npmjs.org/path-to-regexp/-/path-to-regexp-0.1.7.tgz", + "integrity": "sha512-5DFkuoqlv1uYQKxy8omFBeJPQcdoE07Kv2sferDCrAq1ohOU+MSDswDIbnx3YAM60qIOnYa53wBhXW0EbMonrQ==" + }, + "node_modules/pathval": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/pathval/-/pathval-1.1.1.tgz", + "integrity": "sha512-Dp6zGqpTdETdR63lehJYPeIOqpiNBNtc7BpWSLrOje7UaIsE5aY92r/AunQA7rsXvet3lrJ3JnZX29UPTKXyKQ==", + "engines": { + "node": "*" + } + }, + "node_modules/picomatch": { + "version": "2.3.1", + "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-2.3.1.tgz", + "integrity": "sha512-JU3teHTNjmE2VCGFzuY8EXzCDVwEqB2a8fsIvwaStHhAWJEeVd1o1QD80CU6+ZdEXXSLbSsuLwJjkCBWqRQUVA==", + "engines": { + "node": ">=8.6" + }, + "funding": { + "url": "https://github.com/sponsors/jonschlinkert" + } + }, + "node_modules/prelude-ls": { + "version": "1.1.2", + "resolved": "https://registry.npmjs.org/prelude-ls/-/prelude-ls-1.1.2.tgz", + "integrity": "sha512-ESF23V4SKG6lVSGZgYNpbsiaAkdab6ZgOxe52p7+Kid3W3u3bxR4Vfd/o21dmN7jSt0IwgZ4v5MUd26FEtXE9w==", + "engines": { + "node": ">= 0.8.0" + } + }, + "node_modules/proxy-addr": { + "version": "2.0.7", + "resolved": "https://registry.npmjs.org/proxy-addr/-/proxy-addr-2.0.7.tgz", + "integrity": "sha512-llQsMLSUDUPT44jdrU/O37qlnifitDP+ZwrmmZcoSKyLKvtZxpyV0n2/bD/N4tBAAZ/gJEdZU7KMraoK1+XYAg==", + "dependencies": { + "forwarded": "0.2.0", + "ipaddr.js": "1.9.1" + }, + "engines": { + "node": ">= 0.10" + } + }, + "node_modules/qs": { + "version": "6.11.0", + "resolved": "https://registry.npmjs.org/qs/-/qs-6.11.0.tgz", + "integrity": "sha512-MvjoMCJwEarSbUYk5O+nmoSzSutSsTwF85zcHPQ9OrlFoZOYIjaqBAJIqIXjptyD5vThxGq52Xu/MaJzRkIk4Q==", + "dependencies": { + "side-channel": "^1.0.4" + }, + "engines": { + "node": ">=0.6" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/r1csfile": { + "version": "0.0.41", + "resolved": "https://registry.npmjs.org/r1csfile/-/r1csfile-0.0.41.tgz", + "integrity": "sha512-Q1WDF3u1vYeAwjHo4YuddkA8Aq0TulbKjmGm99+Atn13Lf5fTsMZBnBV9T741w8iSyPFG6Uh6sapQby77sREqA==", + "dependencies": { + "@iden3/bigarray": "0.0.2", + "@iden3/binfileutils": "0.0.11", + "fastfile": "0.0.20", + "ffjavascript": "0.2.56" + } + }, + "node_modules/r1csfile/node_modules/ffjavascript": { + "version": "0.2.56", + "resolved": "https://registry.npmjs.org/ffjavascript/-/ffjavascript-0.2.56.tgz", + "integrity": "sha512-em6G5Lrj7ucIqj4TYEgyoHs/j99Urwwqa4+YxEVY2hggnpRimVj+noX5pZQTxI1pvtiekZI4rG65JBf0xraXrg==", + "dependencies": { + "wasmbuilder": "0.0.16", + "wasmcurves": "0.2.0", + "web-worker": "^1.2.0" + } + }, + "node_modules/r1csfile/node_modules/wasmcurves": { + "version": "0.2.0", + "resolved": "https://registry.npmjs.org/wasmcurves/-/wasmcurves-0.2.0.tgz", + "integrity": "sha512-3e2rbxdujOwaod657gxgmdhZNn+i1qKdHO3Y/bK+8E7bV8ttV/fu5FO4/WLBACF375cK0QDLOP+65Na63qYuWA==", + "dependencies": { + "wasmbuilder": "0.0.16" + } + }, + "node_modules/randombytes": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/randombytes/-/randombytes-2.1.0.tgz", + "integrity": "sha512-vYl3iOX+4CKUWuxGi9Ukhie6fsqXqS9FE2Zaic4tNFD2N2QQaXOMFbuKK4QmDHC0JO6B1Zp41J0LpT0oR68amQ==", + "dependencies": { + "safe-buffer": "^5.1.0" + } + }, + "node_modules/range-parser": { + "version": "1.2.1", + "resolved": "https://registry.npmjs.org/range-parser/-/range-parser-1.2.1.tgz", + "integrity": "sha512-Hrgsx+orqoygnmhFbKaHE6c296J+HTAQXoxEF6gNupROmmGJRoyzfG3ccAveqCBrwr/2yxQ5BVd/GTl5agOwSg==", + "engines": { + "node": ">= 0.6" + } + }, + "node_modules/raw-body": { + "version": "2.5.1", + "resolved": "https://registry.npmjs.org/raw-body/-/raw-body-2.5.1.tgz", + "integrity": "sha512-qqJBtEyVgS0ZmPGdCFPWJ3FreoqvG4MVQln/kCgF7Olq95IbOp0/BWyMwbdtn4VTvkM8Y7khCQ2Xgk/tcrCXig==", + "dependencies": { + "bytes": "3.1.2", + "http-errors": "2.0.0", + "iconv-lite": "0.4.24", + "unpipe": "1.0.0" + }, + "engines": { + "node": ">= 0.8" + } + }, + "node_modules/readdirp": { + "version": "3.6.0", + "resolved": "https://registry.npmjs.org/readdirp/-/readdirp-3.6.0.tgz", + "integrity": "sha512-hOS089on8RduqdbhvQ5Z37A0ESjsqz6qnRcffsMU3495FuTdqSm+7bhJ29JvIOsBDEEnan5DPu9t3To9VRlMzA==", + "dependencies": { + "picomatch": "^2.2.1" + }, + "engines": { + "node": ">=8.10.0" + } + }, + "node_modules/require-directory": { + "version": "2.1.1", + "resolved": "https://registry.npmjs.org/require-directory/-/require-directory-2.1.1.tgz", + "integrity": "sha512-fGxEI7+wsG9xrvdjsrlmL22OMTTiHRwAMroiEeMgq8gzoLC/PQr7RsRDSTLUg/bZAZtF+TVIkHc6/4RIKrui+Q==", + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/rimraf": { + "version": "3.0.2", + "resolved": "https://registry.npmjs.org/rimraf/-/rimraf-3.0.2.tgz", + "integrity": "sha512-JZkJMZkAGFFPP2YqXZXPbMlMBgsxzE8ILs4lMIX/2o0L9UBw9O/Y3o6wFw/i9YLapcUJWwqbi3kdxIPdC62TIA==", + "dependencies": { + "glob": "^7.1.3" + }, + "bin": { + "rimraf": "bin.js" + }, + "funding": { + "url": "https://github.com/sponsors/isaacs" + } + }, + "node_modules/safe-buffer": { + "version": "5.2.1", + "resolved": "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.2.1.tgz", + "integrity": "sha512-rp3So07KcdmmKbGvgaNxQSJr7bGVSVk5S9Eq1F+ppbRo70+YeaDxkw5Dd8NPN+GD6bjnYm2VuPuCXmpuYvmCXQ==", + "funding": [ + { + "type": "github", + "url": "https://github.com/sponsors/feross" + }, + { + "type": "patreon", + "url": "https://www.patreon.com/feross" + }, + { + "type": "consulting", + "url": "https://feross.org/support" + } + ] + }, + "node_modules/safer-buffer": { + "version": "2.1.2", + "resolved": "https://registry.npmjs.org/safer-buffer/-/safer-buffer-2.1.2.tgz", + "integrity": "sha512-YZo3K82SD7Riyi0E1EQPojLz7kpepnSQI9IyPbHHg1XXXevb5dJI7tpyN2ADxGcQbHG7vcyRHk0cbwqcQriUtg==" + }, + "node_modules/send": { + "version": "0.18.0", + "resolved": "https://registry.npmjs.org/send/-/send-0.18.0.tgz", + "integrity": "sha512-qqWzuOjSFOuqPjFe4NOsMLafToQQwBSOEpS+FwEt3A2V3vKubTquT3vmLTQpFgMXp8AlFWFuP1qKaJZOtPpVXg==", + "dependencies": { + "debug": "2.6.9", + "depd": "2.0.0", + "destroy": "1.2.0", + "encodeurl": "~1.0.2", + "escape-html": "~1.0.3", + "etag": "~1.8.1", + "fresh": "0.5.2", + "http-errors": "2.0.0", + "mime": "1.6.0", + "ms": "2.1.3", + "on-finished": "2.4.1", + "range-parser": "~1.2.1", + "statuses": "2.0.1" + }, + "engines": { + "node": ">= 0.8.0" + } + }, + "node_modules/send/node_modules/debug": { + "version": "2.6.9", + "resolved": "https://registry.npmjs.org/debug/-/debug-2.6.9.tgz", + "integrity": "sha512-bC7ElrdJaJnPbAP+1EotYvqZsb3ecl5wi6Bfi6BJTUcNowp6cvspg0jXznRTKDjm/E7AdgFBVeAPVMNcKGsHMA==", + "dependencies": { + "ms": "2.0.0" + } + }, + "node_modules/send/node_modules/debug/node_modules/ms": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/ms/-/ms-2.0.0.tgz", + "integrity": "sha512-Tpp60P6IUJDTuOq/5Z8cdskzJujfwqfOTkrwIwj7IRISpnkJnT6SyJ4PCPnGMoFjC9ddhal5KVIYtAt97ix05A==" + }, + "node_modules/serialize-javascript": { + "version": "6.0.0", + "resolved": "https://registry.npmjs.org/serialize-javascript/-/serialize-javascript-6.0.0.tgz", + "integrity": "sha512-Qr3TosvguFt8ePWqsvRfrKyQXIiW+nGbYpy8XK24NQHE83caxWt+mIymTT19DGFbNWNLfEwsrkSmN64lVWB9ag==", + "dependencies": { + "randombytes": "^2.1.0" + } + }, + "node_modules/serve-static": { + "version": "1.15.0", + "resolved": "https://registry.npmjs.org/serve-static/-/serve-static-1.15.0.tgz", + "integrity": "sha512-XGuRDNjXUijsUL0vl6nSD7cwURuzEgglbOaFuZM9g3kwDXOWVTck0jLzjPzGD+TazWbboZYu52/9/XPdUgne9g==", + "dependencies": { + "encodeurl": "~1.0.2", + "escape-html": "~1.0.3", + "parseurl": "~1.3.3", + "send": "0.18.0" + }, + "engines": { + "node": ">= 0.8.0" + } + }, + "node_modules/set-function-length": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/set-function-length/-/set-function-length-1.2.0.tgz", + "integrity": "sha512-4DBHDoyHlM1IRPGYcoxexgh67y4ueR53FKV1yyxwFMY7aCqcN/38M1+SwZ/qJQ8iLv7+ck385ot4CcisOAPT9w==", + "dependencies": { + "define-data-property": "^1.1.1", + "function-bind": "^1.1.2", + "get-intrinsic": "^1.2.2", + "gopd": "^1.0.1", + "has-property-descriptors": "^1.0.1" + }, + "engines": { + "node": ">= 0.4" + } + }, + "node_modules/setprototypeof": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/setprototypeof/-/setprototypeof-1.2.0.tgz", + "integrity": "sha512-E5LDX7Wrp85Kil5bhZv46j8jOeboKq5JMmYM3gVGdGH8xFpPWXUMsNrlODCrkoxMEeNi/XZIwuRvY4XNwYMJpw==" + }, + "node_modules/side-channel": { + "version": "1.0.4", + "resolved": "https://registry.npmjs.org/side-channel/-/side-channel-1.0.4.tgz", + "integrity": "sha512-q5XPytqFEIKHkGdiMIrY10mvLRvnQh42/+GoBlFW3b2LXLE2xxJpZFdm94we0BaoV3RwJyGqg5wS7epxTv0Zvw==", + "dependencies": { + "call-bind": "^1.0.0", + "get-intrinsic": "^1.0.2", + "object-inspect": "^1.9.0" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/source-map": { + "version": "0.6.1", + "resolved": "https://registry.npmjs.org/source-map/-/source-map-0.6.1.tgz", + "integrity": "sha512-UjgapumWlbMhkBgzT7Ykc5YXUT46F0iKu8SGXq0bcwP5dz/h0Plj6enJqjz1Zbq2l5WaqYnrVbwWOWMyF3F47g==", + "optional": true, + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/static-eval": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/static-eval/-/static-eval-2.0.2.tgz", + "integrity": "sha512-N/D219Hcr2bPjLxPiV+TQE++Tsmrady7TqAJugLy7Xk1EumfDWS/f5dtBbkRCGE7wKKXuYockQoj8Rm2/pVKyg==", + "dependencies": { + "escodegen": "^1.8.1" + } + }, + "node_modules/statuses": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/statuses/-/statuses-2.0.1.tgz", + "integrity": "sha512-RwNA9Z/7PrK06rYLIzFMlaF+l73iwpzsqRIFgbMLbTcLD6cOao82TaWefPXQvB2fOC4AjuYSEndS7N/mTCbkdQ==", + "engines": { + "node": ">= 0.8" + } + }, + "node_modules/string-width": { + "version": "4.2.3", + "resolved": "https://registry.npmjs.org/string-width/-/string-width-4.2.3.tgz", + "integrity": "sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g==", + "dependencies": { + "emoji-regex": "^8.0.0", + "is-fullwidth-code-point": "^3.0.0", + "strip-ansi": "^6.0.1" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/strip-ansi": { + "version": "6.0.1", + "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-6.0.1.tgz", + "integrity": "sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A==", + "dependencies": { + "ansi-regex": "^5.0.1" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/strip-json-comments": { + "version": "3.1.1", + "resolved": "https://registry.npmjs.org/strip-json-comments/-/strip-json-comments-3.1.1.tgz", + "integrity": "sha512-6fPc+R4ihwqP6N/aIv2f1gMH8lOVtWQHoqC4yK6oSDVVocumAsfCqjkXnqiYMhmMwS/mEHLp7Vehlt3ql6lEig==", + "engines": { + "node": ">=8" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/supports-color": { + "version": "8.1.1", + "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-8.1.1.tgz", + "integrity": "sha512-MpUEN2OodtUzxvKQl72cUF7RQ5EiHsGvSsVG0ia9c5RbWGL2CI4C7EpPS8UTBIplnlzZiNuV56w+FuNxy3ty2Q==", + "dependencies": { + "has-flag": "^4.0.0" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/chalk/supports-color?sponsor=1" + } + }, + "node_modules/tmp": { + "version": "0.2.1", + "resolved": "https://registry.npmjs.org/tmp/-/tmp-0.2.1.tgz", + "integrity": "sha512-76SUhtfqR2Ijn+xllcI5P1oyannHNHByD80W1q447gU3mp9G9PSpGdWmjUOHRDPiHYacIk66W7ubDTuPF3BEtQ==", + "dependencies": { + "rimraf": "^3.0.0" + }, + "engines": { + "node": ">=8.17.0" + } + }, + "node_modules/tmp-promise": { + "version": "3.0.3", + "resolved": "https://registry.npmjs.org/tmp-promise/-/tmp-promise-3.0.3.tgz", + "integrity": "sha512-RwM7MoPojPxsOBYnyd2hy0bxtIlVrihNs9pj5SUvY8Zz1sQcQG2tG1hSr8PDxfgEB8RNKDhqbIlroIarSNDNsQ==", + "dependencies": { + "tmp": "^0.2.0" + } + }, + "node_modules/to-regex-range": { + "version": "5.0.1", + "resolved": "https://registry.npmjs.org/to-regex-range/-/to-regex-range-5.0.1.tgz", + "integrity": "sha512-65P7iz6X5yEr1cwcgvQxbbIw7Uk3gOy5dIdtZ4rDveLqhrdJP+Li/Hx6tyK0NEb+2GCyneCMJiGqrADCSNk8sQ==", + "dependencies": { + "is-number": "^7.0.0" + }, + "engines": { + "node": ">=8.0" + } + }, + "node_modules/toidentifier": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/toidentifier/-/toidentifier-1.0.1.tgz", + "integrity": "sha512-o5sSPKEkg/DIQNmH43V0/uerLrpzVedkUh8tGNvaeXpfpuwjKenlSox/2O/BTlZUtEe+JG7s5YhEz608PlAHRA==", + "engines": { + "node": ">=0.6" + } + }, + "node_modules/tryer": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/tryer/-/tryer-1.0.1.tgz", + "integrity": "sha512-c3zayb8/kWWpycWYg87P71E1S1ZL6b6IJxfb5fvsUgsf0S2MVGaDhDXXjDMpdCpfWXqptc+4mXwmiy1ypXqRAA==" + }, + "node_modules/type-check": { + "version": "0.3.2", + "resolved": "https://registry.npmjs.org/type-check/-/type-check-0.3.2.tgz", + "integrity": "sha512-ZCmOJdvOWDBYJlzAoFkC+Q0+bUyEOS1ltgp1MGU03fqHG+dbi9tBFU2Rd9QKiDZFAYrhPh2JUf7rZRIuHRKtOg==", + "dependencies": { + "prelude-ls": "~1.1.2" + }, + "engines": { + "node": ">= 0.8.0" + } + }, + "node_modules/type-detect": { + "version": "4.0.8", + "resolved": "https://registry.npmjs.org/type-detect/-/type-detect-4.0.8.tgz", + "integrity": "sha512-0fr/mIH1dlO+x7TlcMy+bIDqKPsw/70tVyeHW787goQjhmqaZe10uwLujubK9q9Lg6Fiho1KUKDYz0Z7k7g5/g==", + "engines": { + "node": ">=4" + } + }, + "node_modules/type-is": { + "version": "1.6.18", + "resolved": "https://registry.npmjs.org/type-is/-/type-is-1.6.18.tgz", + "integrity": "sha512-TkRKr9sUTxEH8MdfuCSP7VizJyzRNMjj2J2do2Jr3Kym598JVdEksuzPQCnlFPW4ky9Q+iA+ma9BGm06XQBy8g==", + "dependencies": { + "media-typer": "0.3.0", + "mime-types": "~2.1.24" + }, + "engines": { + "node": ">= 0.6" + } + }, + "node_modules/underscore": { + "version": "1.12.1", + "resolved": "https://registry.npmjs.org/underscore/-/underscore-1.12.1.tgz", + "integrity": "sha512-hEQt0+ZLDVUMhebKxL4x1BTtDY7bavVofhZ9KZ4aI26X9SRaE+Y3m83XUL1UP2jn8ynjndwCCpEHdUG+9pP1Tw==" + }, + "node_modules/unpipe": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/unpipe/-/unpipe-1.0.0.tgz", + "integrity": "sha512-pjy2bYhSsufwWlKwPc+l3cN7+wuJlK6uz0YdJEOlQDbl6jo/YlPi4mb8agUkVC8BF7V8NuzeyPNqRksA3hztKQ==", + "engines": { + "node": ">= 0.8" + } + }, + "node_modules/util": { + "version": "0.12.5", + "resolved": "https://registry.npmjs.org/util/-/util-0.12.5.tgz", + "integrity": "sha512-kZf/K6hEIrWHI6XqOFUiiMa+79wE/D8Q+NCNAWclkyg3b4d2k7s0QGepNjiABc+aR3N1PAyHL7p6UcLY6LmrnA==", + "dependencies": { + "inherits": "^2.0.3", + "is-arguments": "^1.0.4", + "is-generator-function": "^1.0.7", + "is-typed-array": "^1.1.3", + "which-typed-array": "^1.1.2" + } + }, + "node_modules/utils-merge": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/utils-merge/-/utils-merge-1.0.1.tgz", + "integrity": "sha512-pMZTvIkT1d+TFGvDOqodOclx0QWkkgi6Tdoa8gC8ffGAAqz9pzPTZWAybbsHHoED/ztMtkv/VoYTYyShUn81hA==", + "engines": { + "node": ">= 0.4.0" + } + }, + "node_modules/vary": { + "version": "1.1.2", + "resolved": "https://registry.npmjs.org/vary/-/vary-1.1.2.tgz", + "integrity": "sha512-BNGbWLfd0eUPabhkXUVm0j8uuvREyTh5ovRa/dyow/BqAbZJyC+5fU+IzQOzmAKzYqYRAISoRhdQr3eIZ/PXqg==", + "engines": { + "node": ">= 0.8" + } + }, + "node_modules/wasmbuilder": { + "version": "0.0.16", + "resolved": "https://registry.npmjs.org/wasmbuilder/-/wasmbuilder-0.0.16.tgz", + "integrity": "sha512-Qx3lEFqaVvp1cEYW7Bfi+ebRJrOiwz2Ieu7ZG2l7YyeSJIok/reEQCQCuicj/Y32ITIJuGIM9xZQppGx5LrQdA==" + }, + "node_modules/wasmcurves": { + "version": "0.2.2", + "resolved": "https://registry.npmjs.org/wasmcurves/-/wasmcurves-0.2.2.tgz", + "integrity": "sha512-JRY908NkmKjFl4ytnTu5ED6AwPD+8VJ9oc94kdq7h5bIwbj0L4TDJ69mG+2aLs2SoCmGfqIesMWTEJjtYsoQXQ==", + "dependencies": { + "wasmbuilder": "0.0.16" + } + }, + "node_modules/web-worker": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/web-worker/-/web-worker-1.2.0.tgz", + "integrity": "sha512-PgF341avzqyx60neE9DD+XS26MMNMoUQRz9NOZwW32nPQrF6p77f1htcnjBSEV8BGMKZ16choqUG4hyI0Hx7mA==" + }, + "node_modules/which-typed-array": { + "version": "1.1.13", + "resolved": "https://registry.npmjs.org/which-typed-array/-/which-typed-array-1.1.13.tgz", + "integrity": "sha512-P5Nra0qjSncduVPEAr7xhoF5guty49ArDTwzJ/yNuPIbZppyRxFQsRCWrocxIY+CnMVG+qfbU2FmDKyvSGClow==", + "dependencies": { + "available-typed-arrays": "^1.0.5", + "call-bind": "^1.0.4", + "for-each": "^0.3.3", + "gopd": "^1.0.1", + "has-tostringtag": "^1.0.0" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/word-wrap": { + "version": "1.2.5", + "resolved": "https://registry.npmjs.org/word-wrap/-/word-wrap-1.2.5.tgz", + "integrity": "sha512-BN22B5eaMMI9UMtjrGd5g5eCYPpCPDUy0FJXbYsaT5zYxjFOckS53SQDE3pWkVoWpHXVb3BrYcEN4Twa55B5cA==", + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/workerpool": { + "version": "6.2.1", + "resolved": "https://registry.npmjs.org/workerpool/-/workerpool-6.2.1.tgz", + "integrity": "sha512-ILEIE97kDZvF9Wb9f6h5aXK4swSlKGUcOEGiIYb2OOu/IrDU9iwj0fD//SsA6E5ibwJxpEvhullJY4Sl4GcpAw==" + }, + "node_modules/wrap-ansi": { + "version": "7.0.0", + "resolved": "https://registry.npmjs.org/wrap-ansi/-/wrap-ansi-7.0.0.tgz", + "integrity": "sha512-YVGIj2kamLSTxw6NsZjoBxfSwsn0ycdesmc4p+Q21c5zPuZ1pl+NfxVdxPtdHvmNVOQ6XSYG4AUtyt/Fi7D16Q==", + "dependencies": { + "ansi-styles": "^4.0.0", + "string-width": "^4.1.0", + "strip-ansi": "^6.0.0" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/chalk/wrap-ansi?sponsor=1" + } + }, + "node_modules/wrappy": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/wrappy/-/wrappy-1.0.2.tgz", + "integrity": "sha512-l4Sp/DRseor9wL6EvV2+TuQn63dMkPjZ/sp9XkghTEbV9KlPS1xUsZ3u7/IQO4wxtcFB4bgpQPRcR3QCvezPcQ==" + }, + "node_modules/y18n": { + "version": "5.0.8", + "resolved": "https://registry.npmjs.org/y18n/-/y18n-5.0.8.tgz", + "integrity": "sha512-0pfFzegeDWJHJIAmTLRP2DwHjdF5s7jo9tuztdQxAhINCdvS+3nGINqPd00AphqJR/0LhANUS6/+7SCb98YOfA==", + "engines": { + "node": ">=10" + } + }, + "node_modules/yargs": { + "version": "16.2.0", + "resolved": "https://registry.npmjs.org/yargs/-/yargs-16.2.0.tgz", + "integrity": "sha512-D1mvvtDG0L5ft/jGWkLpG1+m0eQxOfaBvTNELraWj22wSVUMWxZUvYgJYcKh6jGGIkJFhH4IZPQhR4TKpc8mBw==", + "dependencies": { + "cliui": "^7.0.2", + "escalade": "^3.1.1", + "get-caller-file": "^2.0.5", + "require-directory": "^2.1.1", + "string-width": "^4.2.0", + "y18n": "^5.0.5", + "yargs-parser": "^20.2.2" + }, + "engines": { + "node": ">=10" + } + }, + "node_modules/yargs-parser": { + "version": "20.2.4", + "resolved": "https://registry.npmjs.org/yargs-parser/-/yargs-parser-20.2.4.tgz", + "integrity": "sha512-WOkpgNhPTlE73h4VFAFsOnomJVaovO8VqLDzy5saChRBFQFBoMYirowyW+Q9HB4HFF4Z7VZTiG3iSzJJA29yRA==", + "engines": { + "node": ">=10" + } + }, + "node_modules/yargs-unparser": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/yargs-unparser/-/yargs-unparser-2.0.0.tgz", + "integrity": "sha512-7pRTIA9Qc1caZ0bZ6RYRGbHJthJWuakf+WmHK0rVeLkNrrGhfoabBNdue6kdINI6r4if7ocq9aD/n7xwKOdzOA==", + "dependencies": { + "camelcase": "^6.0.0", + "decamelize": "^4.0.0", + "flat": "^5.0.2", + "is-plain-obj": "^2.1.0" + }, + "engines": { + "node": ">=10" + } + }, + "node_modules/yocto-queue": { + "version": "0.1.0", + "resolved": "https://registry.npmjs.org/yocto-queue/-/yocto-queue-0.1.0.tgz", + "integrity": "sha512-rVksvsnNCdJ/ohGc6xgPwyN8eheCxsiLM8mxuE/t/mOVqJewPuO1miLpTHQiRgTKCLexL4MeAFVagts7HmNZ2Q==", + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + } + } +} diff --git a/docs/crypto/zkCTF/day2/familiar_strangers/package.json b/docs/crypto/zkCTF/day2/familiar_strangers/package.json new file mode 100644 index 0000000..178f8c5 --- /dev/null +++ b/docs/crypto/zkCTF/day2/familiar_strangers/package.json @@ -0,0 +1,17 @@ +{ + "name": "familiar_strangers", + "version": "0.1.0", + "directories": { + "test": "test" + }, + "scripts": { + "test": "mocha test" + }, + "dependencies": { + "chai": "^4.3.7", + "circom_tester": "^0.0.19", + "circomlib": "^2.0.5", + "express": "^4.18.2", + "mocha": "^10.2.0" + } +} diff --git a/docs/crypto/zkCTF/day2/familiar_strangers/stranger_judge.js b/docs/crypto/zkCTF/day2/familiar_strangers/stranger_judge.js new file mode 100644 index 0000000..2c72c55 --- /dev/null +++ b/docs/crypto/zkCTF/day2/familiar_strangers/stranger_judge.js @@ -0,0 +1,64 @@ +const express = require('express'); +const bodyParser = require('body-parser'); +const { wasm: wasm_tester } = require('circom_tester'); +const path = require('path'); + +const app = express(); +app.use(bodyParser.json()); + +const PASS = "pass"; +const FAIL = "fail"; + +async function runCircuit(circuitPath, input) { + const circuit = await wasm_tester(circuitPath, { + output: path.join(__dirname, "./test/generated"), + // recompile: true, + }); + try { + const witness = await circuit.calculateWitness({ in: input }); + await circuit.checkConstraints(witness); + return PASS; + } catch (error) { + return error.toString(); + } +} + +// Example inputs {"l1": "123", "l2": "123"} +// Test with curl +// curl -X POST http://localhost:3000/judge -H "Content-Type: application/json" -d '{"l1": "123", "l2": "123"}' + +app.post('/judge', async (req, res) => { + // random number for logging + const identifier = Math.floor(Math.random() * 100000000000); + const inputs = req.body; + console.log("identifier", identifier, "inputs", inputs); + + let result = FAIL; + + // Level 1 + result = await runCircuit(path.join(__dirname, "test/level1_test.circom"), inputs.l1); + if (result != PASS) { + res.json({ success: false }); + return; + } + + // Level 2 + if (inputs.l2.length <= 70) { + res.json({ success: false }); + return; + } + result = await runCircuit(path.join(__dirname, "test/level2_test.circom"), inputs.l2); + if (result != PASS) { + res.json({ success: false }); + return; + } + + res.json({ success: true }); + console.log("identifier", identifier, "success"); + return; +}); + +const port = 3000; +app.listen(port, () => { + console.log(`Stranger Judge Service running on port ${port}`); +}); \ No newline at end of file diff --git a/docs/crypto/zkCTF/day2/familiar_strangers/test/level1_test.circom b/docs/crypto/zkCTF/day2/familiar_strangers/test/level1_test.circom new file mode 100644 index 0000000..1dae410 --- /dev/null +++ b/docs/crypto/zkCTF/day2/familiar_strangers/test/level1_test.circom @@ -0,0 +1,5 @@ +pragma circom 2.0.0; + +include "../circuits/challenge.circom"; + +component main = Level1(); \ No newline at end of file diff --git a/docs/crypto/zkCTF/day2/familiar_strangers/test/level2_test.circom b/docs/crypto/zkCTF/day2/familiar_strangers/test/level2_test.circom new file mode 100644 index 0000000..50072de --- /dev/null +++ b/docs/crypto/zkCTF/day2/familiar_strangers/test/level2_test.circom @@ -0,0 +1,5 @@ +pragma circom 2.0.0; + +include "../circuits/challenge.circom"; + +component main = Level2(); \ No newline at end of file diff --git a/docs/crypto/zkCTF/imgs/feistel.png b/docs/crypto/zkCTF/imgs/feistel.png new file mode 100644 index 0000000000000000000000000000000000000000..126be379dad9ab1629019312dd52d3390bc06743 GIT binary patch literal 262324 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 z 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

%R;5jmppo)5V3)|kd!UM|f?-7$ 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 +

查看合约核心源代码👀 + +```solidity +contract Mint is Verifier { + struct DepositInfo { + bool registered; + uint256 nonce; + Pairing.G1Point commitment; + Pairing.G1Point soulBox; + uint256[] collectedY; + bool escaped0; + bool escaped1; + } + + // function is_sovled(DepositInfo info) returns (bool) { + // if(DepositInfo.escaped0 && DepositInfo escaped1) + // {return true;} + // else + // {return false;} + // } + + + function getCollectedY(address user) public view returns (uint256[] memory) { + return deposits[user].collectedY; + } + + mapping(address => DepositInfo) public deposits; + event Deposit(Pairing.G1Point indexed soulbox, Pairing.G1Point commitment,uint256 timestamp); + event Minted(address indexed user, uint256 nonce); + event Pwned(uint256 indexed privateKey); + + function register( + Pairing.G1Point calldata _commitment, + Pairing.G1Point calldata _proof, + Pairing.G1Point calldata _soulBox + ) external payable { + address sender = msg.sender; + require(!deposits[sender].registered, "User registered"); + require(verifySoulBox(_commitment, _proof, _soulBox), "Invalid soul box proof"); + deposits[sender] = DepositInfo({ + registered: true, + nonce: 1, + commitment: _commitment, + soulBox: _soulBox, + collectedY: new uint256[](0), + escaped0: false, + escaped1: false + }); + emit Deposit(_soulBox, _commitment, block.timestamp); + } + + function getNonce(address _user) public view returns (uint256) { + return deposits[_user].nonce; + } + + function mint( + Pairing.G1Point calldata _proof, + uint256 _value + ) external { + address sender = msg.sender; + uint256 nonce = getNonce(sender); + require(deposits[sender].registered, "User registered"); + require(verify(deposits[sender].commitment, _proof, nonce, _value), "Invalid mint proof"); + deposits[sender].collectedY.push(_value); + + uint256[] memory xArray = new uint256[](nonce); + for (uint256 i = 0; i < nonce; i++) { + xArray[i] = i+1; + } + uint256[] memory wArray = getBarycentricWeights(xArray); + // recover private_key = f(0) by lagrange interpolation + uint256 soul = evaluateBarycentricPolynomial(0, deposits[sender].collectedY, wArray); + Pairing.G1Point memory soulBox = Pairing.mulScalar(SRS_G1_0, soul); + require(soulBox.X != deposits[sender].soulBox.X, "Soul dispersed"); + + if(nonce == 10){ + deposits[sender].escaped0 = true; + } + if(nonce == 20){ + deposits[sender].escaped1 = true; + } + + emit Minted(sender, deposits[sender].nonce); + deposits[sender].nonce += 1; + } + + function replay() external { + address sender = msg.sender; + require(deposits[sender].registered, "User not registered"); + delete(deposits[sender]); + delete(deposits[sender].collectedY); + } +} +``` + + +The register function takes in 3 inputs: a KZG cimmitment `_commitment` of polynomial, a opening proof `_proof` of corresponding polynomial and a publicKey `_soulBox`. The 3 stuffs can be generate by `CraftBladeSignature` in `mint-client/blacksmith.go` and it is actually a KZG opening proof of a sword polynomial which is generated by random and stored in the `sword.json` at index `0`. So the privateKey is actually the first number of `sword.json`. + +Note that `verifySoulBox` method will verify the KZG openning proof of index 0. + +we can check it by running: + +```bash +go run . -contract 0x5fbdb2315678afecb367f032d93f642f64180aa3 -action register +# (*big.Int)(0xc000126000)(7387512810814433601023902593855093598498966062809372162954534333509796980828) +# (*bn254.G1Affine)(0xc000128040)(E([4663152887034778978712025808205539272224485928059866901645348175989267801382,7337163707989781172140860281787651571090746340470207475573012821654567505278])) +``` + +When we mint gems, we should provide a opening proof of sword poly at the index of `nonce`. Note that the nonce of user's desposit information in the contract is initialized by 1. The contract will verify the opening proof and further the Mint contract is trying to recover the privateKey f(0) of the sword poly, minting will fail if it is recovered successfully. + +In order to solve this puzzle, we need to mint 20 gems. However, according to the SRS given in the `Constant.sol`, we can only generate 16 openning proof at most (the first one is the privateKey (soul) so that we can not use it to produce a opening proof). + +Obviously, the size of SRS is limited and this is acttually a Rate Limitinmg Nullifier (RLN) protocol on the KZG version. The security of the protocol guaranteed by the **polynomial interpolation theorem**. + +There are two ways to solve the problem: + +1. Can we recover the trapdoor of the SRS so that we can add the length of SRS and forge a polynomial of degree > 20? +2. Is the protocol has some vulnerability to allow us forge proofs that these points do not lie on the polynomial of degree 16, like malleable attack? + +Both methods are feasible. + +For #Method 1, by googling the `SRS_G1_X=0x2f588cffe99db877a4434b598ab28f81e0522910ea52b45f0adaa772b2d5d352`, we can find this [repo](https://github.com/matter-labs/era-compiler-tests/blob/9a8c6d99d84cec7343e79a28b2a6df49aef57796/yul/precompiles/ecmul_source.yul#L68-L82). It leaked the trapdoor value: `115792089237316195423570985008687907853269984665640564039457584007913129639935`. I think this is an unexpected solution :) + +For #Method 2, this [article](https://hackmd.io/@n1trox/SJlFMYlr2) introduces the attack vector to forge kzg opening proofs without knowing the trapdoor value. + +In detail, we notice that `KZGVerifier.verifySoulBox` checks the pairing equation when $u=0$: + +$$ +e(g^{f(\tau)-f(u)},g)\overset{?}=e(g^{h(\tau)},g^{(\tau-u)}) +$$ + +Normally, we should input $f(u)$ (specifically `_value` or `soul`), $u$ (specifically `_index`) and $h(\tau)$ (sepecifically `_proof`). In order to reduce the amounts of $\mathbb{G}_2$ element, we perform the following transformation: + +$$ +e(g^{f(\tau)-f(u)},g)\overset{?}= e(g^{h(\tau)},g^{(\tau-u)}) \\ +\Rightarrow e(g^{f(\tau)-f(u)},g)\cdot e(g,g)^{-h(\tau)\cdot(\tau-u))}\overset{?}=1\\ +\Rightarrow e(g^{f(\tau)-f(u)},g)^{u\cdot h(\tau)}\cdot e(g,g)^{-h(\tau)\cdot \tau}\overset{?}=1\\ +\Rightarrow e(g^{u\cdot h(\tau)+f(\tau)-f(u)},g)\cdot e(g^{-h(\tau)},g^\tau)\overset{?}=1 +$$ + +That is the code implementation corresponding to the puzzle. When $u=0$, we can use the attack vector to forge arbitary proofs. + +1. select a random field element $\gamma$; +2. construct the new value $nv = g^{f(0)-\gamma\tau}$ and new proof $nf=g^{h(\tau)+\gamma}$ + +Let us verify its correctness: + +$$ +e(g^{f(\tau)-f(0)},g)\cdot e(g^{-h(\tau)},g^\tau)\overset{?}=1\\ +\Rightarrow e(g^{f(\tau)-(f(0)-\gamma\tau)},g)\cdot e(g^{-(h(\tau)+\gamma)},g^\tau)\overset{?}=1 +$$ + +Then the polynomial equation is: + +$$ +f(\tau)-(f(0)-\gamma\tau)=(h(\tau)+\gamma)\cdot\tau\\ +\Rightarrow f(\tau)-f(0)+\gamma\tau=h(\tau)\tau+\gamma\tau\\ +\Rightarrow f(\tau)-f(0)=h(\tau)\tau\\ +$$ + +Correct! + +Therefore, we can register with the fake opening proof generated by the existing soulBox and its opening proof. Tee contract will pass the register process and then it can no longer recover the privateKey f(0) because the fake soulBox is a point that does not lie on the polynomial of degree 16 and the protocol loses efficacy. + +#### EXP + +``` +case "forge": + // 1. load sword info + var sword []fr.Element + f, err := os.Open("sword.json") + panicErr(err) + defer f.Close() + decoder := json.NewDecoder(f) + err = decoder.Decode(&sword) + panicErr(err) + + // 2. forge + bladeCommitment, bladeProof := CraftBladeSignature(sword, SRS) + commitmentPoint := G1AffineToG1Point(&bladeCommitment) + // forge the fake bladeProof + var fakeProof bn254.G1Affine + fakeProof.ScalarMultiplication(&SRS.Pk.G1[0], big.NewInt(114514)) // g^{114514}) + spew.Dump(fakeProof) + fakeProof.Add(&fakeProof, &bladeProof.H) + spew.Dump(fakeProof) + bladeProofPoint := G1AffineToG1Point(&fakeProof) + spew.Dump(bladeProofPoint) + + var fakeSoulBox bn254.G1Affine + fakeSoulBox.ScalarMultiplication(&SRS.Pk.G1[1], big.NewInt(114514)) // g^{\tau * 114514}) + fakeSoulBox.Sub(&bladeProof.PublicKeyG1Aff, &fakeSoulBox) + soulBox := G1AffineToG1Point(&fakeSoulBox) + + // 3. register + mintContract.Register(transactor, *commitmentPoint, *bladeProofPoint, *soulBox) + } +``` + +After register, when can mint as much as we want! + +## Day 2 + +Puzzles: https://github.com/scalebit/zkCTF-day2 + +### Is Zero + +This is a simple is_zero circuit implement. According to the test case, we know that the input arrays `a, b` are the input and result respectively. + +The 3 advice columns are repectively a, a_inv and b. Then We configure and asssign them. + +### Mixer + +We are required to drain the immutable contract Mixer. + +The implementation is quiet similar with the [Tornado Cash](https://www.rareskills.io/post/how-does-tornado-cash-work) protocol. One can deposit 1 ether with a commitment (usually a hash of some secret value), then withdraw by providing the corresponding proof that the secret value can be exactly used to generate the commitment. [Nullifier](https://hackmd.io/@liangcc/nullifier) is a clever mechinism that make sure a message only takes effect once. It is the nullifiers keep the protocol from suffering double-spending attack and nullifiers have something to do with the secret value so that verifier can check the prover indeed owns the secret value to generate the corresponding commitment. + +When it comes to draining a tornado cash protocol, the first possibility that comes to my mind is if we can forge the nullifiers. One should always pay attention to the field operation in the zk application and always check the input data validation. + +According to the code given in the `Verifier.sol`, we notice the finite field that protocol works on is $\mathbb{F}_p$, where $p=21888242871839275222246405745257275088548364400416034343698204186575808495617$, known as the modulus of bn254 curve. But uint256 in solidity can represent a number of 256 bits, so it remains a huge space for hackers to forge nullifiers. Therefore, protocol has to check that the range of nullifier is strictly within finite field. However, it does not. + +So we can repeatly withdraw funds with the same proof and commitment using as many as nullifiers we want by adding `p` repeatly, until the contract drains. + +### Familiar Strangers + +#### Description + +In the realm of the familiar, where logic gates are the silent sentinels of truth, lies a challenge shrouded in enigma. "Familiar Strangers" beckons you to a world where the simplest of circuits hide secrets just beyond the veil of obviousness. These circuits, reminiscent of the ones you've met countless times, now hold a mystery that only a true Circom savant can unravel. Two levels, each a step deeper into the cryptic dance of numbers and logic, await your prowess. Are you ready to discover the true inputs and reveal the concealed answers within? Find the key, communicate with our judge service, and claim your place among the elite who see beyond the familiar to the truth that lies beneath. + +#### Analysis + +We are given 2 circom circuits (respectively level1 and level2) and required to reveal the inputs. + +```circom +template Level1() { + signal input in; + signal output out; + out <== 1; + component lt = LessThan(201); + lt.in[0] <== in; + lt.in[1] <== 6026017665971213533282357846279359759458261226685473132380160; + lt.out === out; + component gt = GreaterThan(201); + gt.in[0] <== in; + gt.in[1] <== -401734511064747568885490523085290650630550748445698208825344; + gt.out === out; +} +``` + +Level1 circuit constrains the `out` signal to 1, and the `in` signal less than $6026017665971213533282357846279359759458261226685473132380160$ and greater than $-401734511064747568885490523085290650630550748445698208825344$. Note that the input is **expected** to be a number with 201 bits but `LessThan` and `GreaterThan` template never checks it is within the valid range. This attack vector is well explained [here](https://github.com/0xPARC/zk-bug-tracker?tab=readme-ov-file#4-mismatching-bit-lengths) + +To pass the circuit, we only need to find a number whose 202th bit is 0 within [0, 2**201). + +```python +6026017665971213533282357846279359759458261226685473132380160 % 2**n +# 2812141577453232982198433661597034554413855239119887461777408 +-401734511064747568885490523085290650630550748445698208825344 % 2**n +# 2812141577453232982198433661597034554413855239119887461777408 +``` + +Do the same operation with level2 circuit: + +```python +3533700027045102098369050084895387317199177651876580346993442643999981568 % (1<<241) +# 5897488333439202455083409550285544209858125342430750230241414742016 +-3618502782768642773547390826438087570129142810943142283802299270005870559232 % (1<<251) +# 5897488333439202455083409550285544209858125342430750230241414742016 +``` + +Note that we need to constrain the length of input of level2 circuit to be great and equal than 70. We can make use of the characteristics of field operations again, which is known as input alias issue. + +``` +input_of_level2 = 5897488333439202455083409550285544209858125342430750230241414742016 + p +``` + +Because this is just a check in javascript, we can simply add some leading-zero before the input, saying `00005897488333439202455083409550285544209858125342430750230241414742016` to bypass this check. + +### What a Waste + +We are given a Round 2 seed random value but nothing else and required to forge a proof. + +Emmm... Try to figure it out next time. diff --git a/mkdocs.yml b/mkdocs.yml index 2b73809..8e7ccbf 100644 --- a/mkdocs.yml +++ b/mkdocs.yml @@ -15,6 +15,8 @@ nav: - Let's hash it out: crypto/lets-hash-it-out/lets-hash-it-out.md - SafeEscrow: crypto/safeescrow.md - Group dynamics: crypto/group-dynamics/group-dynamics.md + - 2+2=5: crypto/2+2=5/two_plus_two.md + - zkCTF: crypto/zkCTF/zkCTF.md # Theme theme: