From daf02f36648e4a1f99486ca711fa1999da974fc2 Mon Sep 17 00:00:00 2001 From: Dylan <13701258+dylandesrosier@users.noreply.github.com> Date: Fri, 6 Sep 2024 17:31:02 -0400 Subject: [PATCH] Adding code coverage execution modes (#443) and (#430) --- lcov.info | 1858 +++++++++++++++++++++++++++ script/DeployEnvironmentSetUp.s.sol | 91 +- script/coverage.sh | 8 +- test/DeleGatorTestSuite.t.sol | 348 ++++- test/DelegationManagerTest.t.sol | 67 + test/utils/Counter.t.sol | 4 + 6 files changed, 2321 insertions(+), 55 deletions(-) create mode 100644 lcov.info diff --git a/lcov.info b/lcov.info new file mode 100644 index 0000000..63360d7 --- /dev/null +++ b/lcov.info @@ -0,0 +1,1858 @@ +TN: +SF:src/DeleGatorCore.sol +FN:91,DeleGatorCore.onlyEntryPoint +FNDA:191,DeleGatorCore.onlyEntryPoint +DA:92,191 +BRDA:92,0,0,6 +FN:100,DeleGatorCore.onlyEntryPointOrSelf +FNDA:16,DeleGatorCore.onlyEntryPointOrSelf +DA:101,16 +BRDA:101,1,0,1 +FN:109,DeleGatorCore.onlyDelegationManager +FNDA:107,DeleGatorCore.onlyDelegationManager +DA:110,107 +BRDA:110,2,0,3 +FN:121,DeleGatorCore. +FNDA:8,DeleGatorCore. +DA:122,8 +DA:123,10 +DA:124,6 +DA:125,8 +DA:126,8 +FN:144,DeleGatorCore.redeemDelegations +FNDA:88,DeleGatorCore.redeemDelegations +DA:152,88 +FN:161,DeleGatorCore.execute +FNDA:25,DeleGatorCore.execute +DA:162,22 +FN:172,DeleGatorCore.execute +FNDA:48,DeleGatorCore.execute +DA:173,48 +DA:176,48 +BRDA:176,3,0,18 +BRDA:176,3,1,3 +DA:178,18 +DA:180,18 +BRDA:180,4,0,12 +BRDA:180,4,1,3 +DA:181,6 +BRDA:181,5,0,3 +BRDA:181,5,1,3 +DA:182,3 +DA:183,30 +BRDA:183,6,0,27 +BRDA:183,6,1,3 +DA:185,27 +DA:187,27 +BRDA:187,7,0,21 +BRDA:187,7,1,3 +DA:188,21 +DA:189,6 +BRDA:189,8,0,3 +BRDA:189,8,1,3 +DA:190,3 +DA:191,3 +DA:192,3 +DA:193,3 +BRDA:193,9,0,3 +DA:195,3 +DA:198,3 +FN:206,DeleGatorCore.executeFromExecutor +FNDA:107,DeleGatorCore.executeFromExecutor +DA:215,104 +DA:218,104 +BRDA:218,10,0,9 +BRDA:218,10,1,3 +DA:220,9 +DA:222,9 +BRDA:222,11,0,3 +BRDA:222,11,1,3 +DA:223,6 +BRDA:223,12,0,3 +BRDA:223,12,1,3 +DA:224,3 +DA:225,95 +BRDA:225,13,0,92 +BRDA:225,13,1,3 +DA:227,92 +DA:228,92 +DA:229,92 +DA:231,92 +BRDA:231,14,0,86 +BRDA:231,14,1,3 +DA:232,86 +DA:233,6 +BRDA:233,15,0,3 +BRDA:233,15,1,3 +DA:234,3 +DA:235,3 +BRDA:235,16,0,3 +DA:237,3 +DA:240,3 +FN:252,DeleGatorCore.validateUserOp +FNDA:191,DeleGatorCore.validateUserOp +DA:262,182 +DA:263,182 +FN:275,DeleGatorCore.isValidSignature +FNDA:146,DeleGatorCore.isValidSignature +DA:285,143 +FN:289,DeleGatorCore.onERC721Received +FNDA:0,DeleGatorCore.onERC721Received +DA:290,0 +FN:294,DeleGatorCore.onERC1155Received +FNDA:0,DeleGatorCore.onERC1155Received +DA:307,0 +FN:311,DeleGatorCore.onERC1155BatchReceived +FNDA:0,DeleGatorCore.onERC1155BatchReceived +DA:324,0 +FN:331,DeleGatorCore.addDeposit +FNDA:6,DeleGatorCore.addDeposit +DA:332,6 +FN:341,DeleGatorCore.withdrawDeposit +FNDA:3,DeleGatorCore.withdrawDeposit +DA:342,3 +FN:349,DeleGatorCore.disableDelegation +FNDA:18,DeleGatorCore.disableDelegation +DA:350,18 +FN:358,DeleGatorCore.enableDelegation +FNDA:15,DeleGatorCore.enableDelegation +DA:359,15 +FN:368,DeleGatorCore.upgradeToAndCallAndRetainStorage +FNDA:1,DeleGatorCore.upgradeToAndCallAndRetainStorage +DA:369,1 +FN:378,DeleGatorCore.upgradeToAndCall +FNDA:3,DeleGatorCore.upgradeToAndCall +DA:379,3 +DA:380,3 +FN:388,DeleGatorCore.isDelegationDisabled +FNDA:24,DeleGatorCore.isDelegationDisabled +DA:389,24 +FN:397,DeleGatorCore.getDeposit +FNDA:3,DeleGatorCore.getDeposit +DA:398,3 +FN:406,DeleGatorCore.getImplementation +FNDA:6,DeleGatorCore.getImplementation +DA:407,6 +FN:415,DeleGatorCore.getInitializedVersion +FNDA:7,DeleGatorCore.getInitializedVersion +DA:416,7 +FN:424,DeleGatorCore.getNonce +FNDA:3,DeleGatorCore.getNonce +DA:425,3 +FN:434,DeleGatorCore.getNonce +FNDA:3,DeleGatorCore.getNonce +DA:435,3 +FN:442,DeleGatorCore.supportsInterface +FNDA:17,DeleGatorCore.supportsInterface +DA:443,17 +DA:444,10 +DA:445,4 +FN:473,DeleGatorCore._authorizeUpgrade +FNDA:4,DeleGatorCore._authorizeUpgrade +FN:485,DeleGatorCore._validateUserOpSignature +FNDA:182,DeleGatorCore._validateUserOpSignature +DA:493,182 +DA:494,182 +BRDA:494,17,0,172 +BRDA:494,17,1,10 +DA:495,172 +DA:497,10 +FN:506,DeleGatorCore._payPrefund +FNDA:182,DeleGatorCore._payPrefund +DA:507,182 +BRDA:507,18,0,176 +DA:508,176 +DA:511,176 +FNF:29 +FNH:26 +LF:73 +LH:70 +BRF:32 +BRH:32 +end_of_record +TN: +SF:src/DelegationManager.sol +FN:53,DelegationManager.onlyDeleGator +FNDA:15,DelegationManager.onlyDeleGator +DA:54,15 +BRDA:54,0,0,6 +FN:64,DelegationManager. +FNDA:12,DelegationManager. +DA:65,4 +DA:66,8 +FN:74,DelegationManager.pause +FNDA:8,DelegationManager.pause +DA:75,6 +FN:81,DelegationManager.unpause +FNDA:2,DelegationManager.unpause +DA:82,2 +FN:90,DelegationManager.disableDelegation +FNDA:18,DelegationManager.disableDelegation +DA:91,15 +DA:92,3 +BRDA:92,1,0,3 +DA:93,12 +DA:94,12 +FN:103,DelegationManager.enableDelegation +FNDA:15,DelegationManager.enableDelegation +DA:104,9 +DA:105,9 +BRDA:105,2,0,3 +DA:106,6 +DA:107,6 +FN:124,DelegationManager.redeemDelegations +FNDA:130,DelegationManager.redeemDelegations +DA:132,129 +DA:133,129 +BRDA:133,3,0,3 +DA:135,126 +DA:136,126 +DA:139,126 +DA:140,130 +DA:142,127 +BRDA:142,4,0,1 +BRDA:142,4,1,91 +DA:144,1 +DA:145,1 +DA:147,126 +DA:150,126 +DA:151,126 +DA:154,126 +BRDA:154,5,0,6 +DA:155,6 +DA:158,120 +DA:159,144 +DA:160,144 +DA:162,144 +BRDA:162,6,0,3 +DA:164,3 +DA:167,141 +BRDA:167,7,0,7 +BRDA:167,7,1,126 +DA:169,7 +DA:173,7 +BRDA:173,8,0,3 +DA:176,134 +DA:177,134 +DA:179,134 +DA:180,133 +BRDA:180,9,0,7 +DA:181,7 +DA:187,106 +DA:189,3 +BRDA:189,10,0,3 +DA:190,3 +DA:194,118 +BRDA:194,11,0,24 +BRDA:194,11,1,91 +DA:195,24 +BRDA:195,12,0,6 +DA:196,6 +DA:199,18 +DA:200,18 +BRDA:200,13,0,3 +DA:201,3 +DA:203,94 +BRDA:203,14,0,3 +DA:204,3 +DA:211,88 +DA:212,92 +BRDA:212,15,0,91 +DA:214,91 +DA:215,106 +DA:216,106 +DA:217,75 +DA:218,75 +DA:232,76 +DA:233,80 +BRDA:233,16,0,1 +BRDA:233,16,1,79 +DA:235,1 +DA:237,79 +DA:243,76 +DA:244,80 +BRDA:244,17,0,79 +DA:246,79 +DA:248,94 +DA:249,94 +DA:250,62 +DA:251,62 +DA:265,73 +DA:266,76 +BRDA:266,18,0,75 +DA:267,75 +DA:268,90 +FN:282,DelegationManager.getDomainHash +FNDA:147,DelegationManager.getDomainHash +DA:283,288 +FN:291,DelegationManager.getDelegationHash +FNDA:3,DelegationManager.getDelegationHash +DA:292,27 +FNF:9 +FNH:9 +LF:75 +LH:75 +BRF:23 +BRH:23 +end_of_record +TN: +SF:src/HybridDeleGator.sol +FN:77,HybridDeleGator. +FNDA:0,HybridDeleGator. +FN:90,HybridDeleGator.initialize +FNDA:1177,HybridDeleGator.initialize +DA:99,1177 +FN:115,HybridDeleGator.reinitialize +FNDA:5,HybridDeleGator.reinitialize +DA:127,5 +FN:138,HybridDeleGator.addKey +FNDA:14,HybridDeleGator.addKey +DA:139,14 +FN:146,HybridDeleGator.removeKey +FNDA:6,HybridDeleGator.removeKey +DA:147,6 +DA:148,6 +DA:149,6 +DA:150,6 +DA:151,6 +DA:153,6 +BRDA:153,0,0,1 +DA:155,5 +DA:157,5 +BRDA:157,1,0,1 +DA:159,4 +DA:160,3 +BRDA:160,2,0,1 +DA:161,1 +DA:162,1 +DA:165,4 +DA:167,4 +DA:168,4 +FN:177,HybridDeleGator.getKey +FNDA:8,HybridDeleGator.getKey +DA:178,8 +DA:179,8 +DA:180,8 +DA:181,8 +FN:187,HybridDeleGator.getKeyIdHashes +FNDA:5,HybridDeleGator.getKeyIdHashes +DA:188,5 +DA:189,5 +FN:195,HybridDeleGator.getKeyIdHashesCount +FNDA:9,HybridDeleGator.getKeyIdHashesCount +DA:196,9 +DA:197,9 +FN:207,HybridDeleGator.updateSigners +FNDA:9,HybridDeleGator.updateSigners +DA:216,9 +FN:222,HybridDeleGator.owner +FNDA:19,HybridDeleGator.owner +DA:223,91 +DA:224,91 +FN:231,HybridDeleGator.transferOwnership +FNDA:3,HybridDeleGator.transferOwnership +DA:232,1 +FN:238,HybridDeleGator.renounceOwnership +FNDA:3,HybridDeleGator.renounceOwnership +DA:239,2 +FN:246,HybridDeleGator.supportsInterface +FNDA:12,HybridDeleGator.supportsInterface +DA:247,12 +FN:258,HybridDeleGator._addKey +FNDA:1163,HybridDeleGator._addKey +DA:259,1163 +BRDA:259,3,0,2 +DA:260,1161 +DA:262,1161 +BRDA:262,4,0,1 +DA:263,1160 +DA:265,1160 +DA:266,1160 +BRDA:266,5,0,1 +DA:268,1159 +DA:269,1159 +DA:271,1159 +FN:278,HybridDeleGator._transferOwnership +FNDA:1189,HybridDeleGator._transferOwnership +DA:279,1189 +DA:280,1189 +BRDA:280,6,0,1 +DA:282,1188 +DA:283,1188 +DA:284,1188 +FN:295,HybridDeleGator._updateSigners +FNDA:1191,HybridDeleGator._updateSigners +DA:304,1191 +DA:305,1191 +BRDA:305,7,0,1 +DA:306,1190 +BRDA:306,8,0,3 +DA:307,3 +DA:310,6 +BRDA:310,9,0,6 +DA:311,6 +DA:312,6 +DA:313,6 +BRDA:313,10,0,3 +DA:314,3 +DA:315,3 +DA:316,3 +DA:317,3 +DA:318,3 +DA:320,3 +DA:324,1187 +DA:325,1149 +DA:328,1186 +FN:335,HybridDeleGator._clearDeleGatorStorage +FNDA:2,HybridDeleGator._clearDeleGatorStorage +DA:336,2 +DA:337,2 +DA:338,2 +DA:339,1 +DA:341,2 +DA:342,2 +DA:344,2 +FN:358,HybridDeleGator._isValidSignature +FNDA:166,HybridDeleGator._isValidSignature +DA:359,166 +DA:360,166 +BRDA:360,11,0,72 +BRDA:360,11,1,2 +DA:361,72 +DA:362,3 +DA:364,94 +DA:366,89 +DA:367,89 +DA:369,89 +DA:370,89 +DA:372,86 +BRDA:372,15,0,81 +BRDA:372,15,1,2 +DA:373,81 +DA:374,5 +BRDA:374,16,0,3 +DA:375,3 +DA:377,2 +FN:384,HybridDeleGator._getDeleGatorStorage +FNDA:2565,HybridDeleGator._getDeleGatorStorage +DA:386,2565 +FNF:19 +FNH:18 +LF:85 +LH:85 +BRF:16 +BRH:16 +end_of_record +TN: +SF:src/MultiSigDeleGator.sol +FN:81,MultiSigDeleGator. +FNDA:24,MultiSigDeleGator. +DA:82,8 +DA:83,10 +DA:84,8 +FN:93,MultiSigDeleGator.initialize +FNDA:1354,MultiSigDeleGator.initialize +DA:94,1354 +FN:105,MultiSigDeleGator.reinitialize +FNDA:5,MultiSigDeleGator.reinitialize +DA:115,4 +FN:125,MultiSigDeleGator.replaceSigner +FNDA:10,MultiSigDeleGator.replaceSigner +DA:126,9 +BRDA:126,0,0,3 +DA:128,6 +DA:130,6 +BRDA:130,1,0,1 +DA:131,1 +BRDA:131,2,0,1 +DA:133,4 +DA:134,4 +DA:135,7 +BRDA:135,3,0,4 +DA:136,4 +DA:137,4 +DA:141,4 +DA:142,4 +DA:143,4 +FN:150,MultiSigDeleGator.addSigner +FNDA:45,MultiSigDeleGator.addSigner +DA:151,44 +BRDA:151,4,0,3 +DA:153,41 +DA:155,41 +BRDA:155,5,0,1 +DA:156,1 +BRDA:156,6,0,1 +DA:158,39 +DA:159,39 +DA:161,39 +FN:168,MultiSigDeleGator.removeSigner +FNDA:7,MultiSigDeleGator.removeSigner +DA:169,6 +DA:171,6 +BRDA:171,7,0,1 +DA:172,5 +DA:173,5 +BRDA:173,8,0,2 +DA:175,3 +DA:176,6 +BRDA:176,9,0,2 +DA:177,2 +DA:178,2 +DA:181,3 +DA:182,3 +DA:184,3 +FN:191,MultiSigDeleGator.updateThreshold +FNDA:6,MultiSigDeleGator.updateThreshold +DA:192,5 +BRDA:192,10,0,1 +DA:193,4 +DA:194,4 +BRDA:194,11,0,1 +DA:196,3 +DA:198,3 +FN:207,MultiSigDeleGator.updateMultiSigParameters +FNDA:16,MultiSigDeleGator.updateMultiSigParameters +DA:215,13 +FN:223,MultiSigDeleGator.isSigner +FNDA:2,MultiSigDeleGator.isSigner +DA:224,2 +DA:225,2 +FN:232,MultiSigDeleGator.getSigners +FNDA:21,MultiSigDeleGator.getSigners +DA:233,21 +DA:234,21 +FN:241,MultiSigDeleGator.getThreshold +FNDA:6,MultiSigDeleGator.getThreshold +DA:242,6 +DA:243,6 +FN:249,MultiSigDeleGator.getSignersCount +FNDA:1,MultiSigDeleGator.getSignersCount +DA:250,1 +DA:251,1 +FN:261,MultiSigDeleGator._setSignersAndThreshold +FNDA:1371,MultiSigDeleGator._setSignersAndThreshold +DA:262,1371 +DA:263,1371 +DA:264,1371 +DA:266,1371 +DA:267,1371 +BRDA:267,12,0,8 +DA:268,1363 +BRDA:268,13,0,3 +DA:270,5 +BRDA:270,14,0,5 +DA:271,5 +DA:272,7 +DA:273,7 +DA:274,7 +DA:276,5 +DA:279,1360 +DA:280,1453 +DA:281,2 +BRDA:281,15,0,2 +DA:282,1451 +BRDA:282,16,0,3 +DA:284,1448 +DA:285,1448 +DA:287,1448 +DA:289,1355 +DA:290,1355 +FN:297,MultiSigDeleGator._clearDeleGatorStorage +FNDA:1,MultiSigDeleGator._clearDeleGatorStorage +DA:298,1 +DA:299,1 +DA:300,1 +DA:301,1 +DA:303,1 +DA:304,1 +DA:305,1 +FN:315,MultiSigDeleGator._isValidSignature +FNDA:159,MultiSigDeleGator._isValidSignature +DA:316,159 +DA:319,159 +DA:321,154 +DA:322,154 +DA:325,154 +DA:326,154 +DA:327,154 +DA:329,154 +DA:330,159 +DA:332,159 +DA:334,159 +DA:336,154 +DA:338,154 +BRDA:338,19,0,149 +DA:339,149 +DA:342,5 +DA:345,0 +FN:351,MultiSigDeleGator._getDeleGatorStorage +FNDA:1638,MultiSigDeleGator._getDeleGatorStorage +DA:353,1624 +FNF:16 +FNH:16 +LF:94 +LH:93 +BRF:18 +BRH:18 +end_of_record +TN: +SF:src/enforcers/AllowedCalldataEnforcer.sol +FN:31,AllowedCalldataEnforcer.beforeHook +FNDA:14,AllowedCalldataEnforcer.beforeHook +DA:46,14 +DA:47,14 +DA:49,14 +DA:51,14 +DA:52,13 +DA:53,13 +BRDA:53,0,0,1 +BRDA:53,0,1,12 +DA:55,12 +BRDA:55,1,0,2 +BRDA:55,1,1,10 +FN:64,AllowedCalldataEnforcer.getTermsInfo +FNDA:0,AllowedCalldataEnforcer.getTermsInfo +DA:65,14 +BRDA:65,2,0,1 +BRDA:65,2,1,13 +DA:66,13 +DA:67,13 +FN:76,AllowedCalldataEnforcer._compare +FNDA:12,AllowedCalldataEnforcer._compare +DA:77,12 +FNF:3 +FNH:2 +LF:11 +LH:11 +BRF:6 +BRH:6 +end_of_record +TN: +SF:src/enforcers/AllowedMethodsEnforcer.sol +FN:27,AllowedMethodsEnforcer.beforeHook +FNDA:13,AllowedMethodsEnforcer.beforeHook +DA:41,13 +DA:43,13 +BRDA:43,0,0,1 +BRDA:43,0,1,12 +DA:45,12 +DA:46,12 +DA:47,12 +DA:49,12 +DA:50,18 +BRDA:50,1,0,10 +DA:51,10 +DA:54,2 +FN:62,AllowedMethodsEnforcer.getTermsInfo +FNDA:1,AllowedMethodsEnforcer.getTermsInfo +DA:63,13 +DA:64,13 +DA:65,13 +BRDA:65,2,0,1 +BRDA:65,2,1,12 +DA:66,12 +DA:67,12 +DA:68,18 +DA:69,18 +FNF:2 +FNH:2 +LF:16 +LH:16 +BRF:5 +BRH:5 +end_of_record +TN: +SF:src/enforcers/AllowedTargetsEnforcer.sol +FN:26,AllowedTargetsEnforcer.beforeHook +FNDA:24,AllowedTargetsEnforcer.beforeHook +DA:40,24 +DA:42,24 +DA:43,24 +DA:44,24 +DA:45,30 +BRDA:45,0,0,22 +DA:46,22 +DA:49,2 +FN:57,AllowedTargetsEnforcer.getTermsInfo +FNDA:1,AllowedTargetsEnforcer.getTermsInfo +DA:58,25 +DA:59,25 +DA:60,25 +BRDA:60,1,0,1 +BRDA:60,1,1,24 +DA:61,24 +DA:62,24 +DA:63,32 +DA:64,32 +FNF:2 +FNH:2 +LF:14 +LH:14 +BRF:3 +BRH:3 +end_of_record +TN: +SF:src/enforcers/ArgsEqualityCheckEnforcer.sol +FN:31,ArgsEqualityCheckEnforcer.beforeHook +FNDA:6,ArgsEqualityCheckEnforcer.beforeHook +DA:43,6 +BRDA:43,0,0,2 +DA:44,2 +DA:45,2 +FNF:1 +FNH:1 +LF:3 +LH:3 +BRF:1 +BRH:1 +end_of_record +TN: +SF:src/enforcers/BlockNumberEnforcer.sol +FN:20,BlockNumberEnforcer.beforeHook +FNDA:9,BlockNumberEnforcer.beforeHook +DA:33,9 +DA:35,9 +BRDA:35,0,0,7 +DA:37,7 +BRDA:37,1,0,2 +BRDA:37,1,1,5 +DA:40,7 +BRDA:40,2,0,6 +DA:42,6 +BRDA:42,3,0,3 +BRDA:42,3,1,3 +FN:52,BlockNumberEnforcer.getTermsInfo +FNDA:1,BlockNumberEnforcer.getTermsInfo +DA:57,10 +BRDA:57,4,0,1 +BRDA:57,4,1,9 +DA:58,9 +DA:59,9 +FNF:2 +FNH:2 +LF:8 +LH:8 +BRF:8 +BRH:8 +end_of_record +TN: +SF:src/enforcers/CaveatEnforcer.sol +FN:18,CaveatEnforcer.beforeHook +FNDA:5,CaveatEnforcer.beforeHook +FN:21,CaveatEnforcer.afterHook +FNDA:49,CaveatEnforcer.afterHook +FN:26,CaveatEnforcer.onlySingleExecutionMode +FNDA:74,CaveatEnforcer.onlySingleExecutionMode +DA:27,74 +BRDA:27,0,0,- +BRDA:27,0,1,74 +FN:34,CaveatEnforcer.onlyBatchExecutionMode +FNDA:0,CaveatEnforcer.onlyBatchExecutionMode +DA:35,0 +BRDA:35,1,0,- +BRDA:35,1,1,- +FNF:4 +FNH:3 +LF:2 +LH:1 +BRF:4 +BRH:1 +end_of_record +TN: +SF:src/enforcers/DeployedEnforcer.sol +FN:36,DeployedEnforcer._deploy +FNDA:9,DeployedEnforcer._deploy +DA:37,9 +DA:38,9 +BRDA:38,0,0,1 +DA:39,8 +FN:52,DeployedEnforcer.beforeHook +FNDA:13,DeployedEnforcer.beforeHook +DA:64,13 +DA:67,10 +BRDA:67,1,0,1 +DA:69,1 +DA:70,1 +DA:73,9 +DA:74,8 +BRDA:74,2,0,2 +BRDA:74,2,1,6 +FN:84,DeployedEnforcer.getTermsInfo +FNDA:0,DeployedEnforcer.getTermsInfo +DA:89,13 +BRDA:89,3,0,3 +BRDA:89,3,1,10 +DA:90,10 +DA:91,10 +DA:92,10 +FN:99,DeployedEnforcer.computeAddress +FNDA:2,DeployedEnforcer.computeAddress +DA:100,2 +FNF:4 +FNH:3 +LF:14 +LH:14 +BRF:6 +BRH:6 +end_of_record +TN: +SF:src/enforcers/ERC20BalanceGteEnforcer.sol +FN:32,ERC20BalanceGteEnforcer.getHashKey +FNDA:1,ERC20BalanceGteEnforcer.getHashKey +DA:33,1 +FN:43,ERC20BalanceGteEnforcer.beforeHook +FNDA:8,ERC20BalanceGteEnforcer.beforeHook +DA:55,8 +DA:56,8 +DA:57,8 +BRDA:57,0,0,1 +BRDA:57,0,1,7 +DA:58,7 +DA:59,7 +DA:60,6 +FN:68,ERC20BalanceGteEnforcer.afterHook +FNDA:5,ERC20BalanceGteEnforcer.afterHook +DA:80,5 +DA:81,5 +DA:82,5 +DA:83,5 +DA:84,5 +BRDA:84,1,0,2 +BRDA:84,1,1,3 +FN:93,ERC20BalanceGteEnforcer.getTermsInfo +FNDA:3,ERC20BalanceGteEnforcer.getTermsInfo +DA:94,16 +BRDA:94,2,0,2 +BRDA:94,2,1,14 +DA:95,14 +DA:96,14 +FN:104,ERC20BalanceGteEnforcer._getHashKey +FNDA:14,ERC20BalanceGteEnforcer._getHashKey +DA:105,14 +FNF:5 +FNH:5 +LF:16 +LH:16 +BRF:6 +BRH:6 +end_of_record +TN: +SF:src/enforcers/ERC20TransferAmountEnforcer.sol +FN:38,ERC20TransferAmountEnforcer.beforeHook +FNDA:9,ERC20TransferAmountEnforcer.beforeHook +DA:51,9 +DA:52,3 +FN:61,ERC20TransferAmountEnforcer.getTermsInfo +FNDA:0,ERC20TransferAmountEnforcer.getTermsInfo +DA:62,8 +BRDA:62,0,0,1 +BRDA:62,0,1,7 +DA:64,7 +DA:65,7 +FN:76,ERC20TransferAmountEnforcer._validateAndIncrease +FNDA:9,ERC20TransferAmountEnforcer._validateAndIncrease +DA:84,9 +DA:86,9 +BRDA:86,1,0,1 +BRDA:86,1,1,8 +DA:88,8 +DA:89,8 +DA:91,7 +BRDA:91,2,0,1 +BRDA:91,2,1,6 +DA:93,6 +BRDA:93,3,0,1 +BRDA:93,3,1,5 +DA:95,5 +DA:96,5 +BRDA:96,4,0,2 +BRDA:96,4,1,3 +FNF:3 +FNH:2 +LF:13 +LH:13 +BRF:10 +BRH:10 +end_of_record +TN: +SF:src/enforcers/IdEnforcer.sol +FN:31,IdEnforcer.beforeHook +FNDA:6,IdEnforcer.beforeHook +DA:43,6 +DA:44,4 +BRDA:44,0,0,2 +BRDA:44,0,1,2 +DA:45,2 +DA:46,2 +FN:54,IdEnforcer.getTermsInfo +FNDA:1,IdEnforcer.getTermsInfo +DA:55,7 +BRDA:55,1,0,2 +BRDA:55,1,1,5 +DA:56,5 +FN:66,IdEnforcer.getIsUsed +FNDA:2,IdEnforcer.getIsUsed +DA:67,6 +FNF:3 +FNH:3 +LF:7 +LH:7 +BRF:4 +BRH:4 +end_of_record +TN: +SF:src/enforcers/LimitedCallsEnforcer.sol +FN:30,LimitedCallsEnforcer.beforeHook +FNDA:8,LimitedCallsEnforcer.beforeHook +DA:42,8 +DA:43,6 +DA:44,6 +BRDA:44,0,0,2 +BRDA:44,0,1,4 +DA:45,4 +FN:53,LimitedCallsEnforcer.getTermsInfo +FNDA:0,LimitedCallsEnforcer.getTermsInfo +DA:54,8 +BRDA:54,1,0,2 +BRDA:54,1,1,6 +DA:55,6 +FNF:2 +FNH:1 +LF:6 +LH:6 +BRF:4 +BRH:4 +end_of_record +TN: +SF:src/enforcers/NativeBalanceGteEnforcer.sol +FN:29,NativeBalanceGteEnforcer.getHashKey +FNDA:1,NativeBalanceGteEnforcer.getHashKey +DA:30,1 +FN:41,NativeBalanceGteEnforcer.beforeHook +FNDA:7,NativeBalanceGteEnforcer.beforeHook +DA:53,7 +DA:54,7 +DA:56,7 +BRDA:56,0,0,1 +BRDA:56,0,1,6 +DA:57,6 +DA:58,6 +FN:67,NativeBalanceGteEnforcer.afterHook +FNDA:5,NativeBalanceGteEnforcer.afterHook +DA:79,5 +DA:80,5 +DA:81,5 +DA:82,5 +BRDA:82,1,0,1 +BRDA:82,1,1,3 +FN:92,NativeBalanceGteEnforcer.getTermsInfo +FNDA:3,NativeBalanceGteEnforcer.getTermsInfo +DA:93,15 +BRDA:93,2,0,2 +BRDA:93,2,1,13 +DA:94,13 +DA:95,13 +FN:103,NativeBalanceGteEnforcer._getHashKey +FNDA:13,NativeBalanceGteEnforcer._getHashKey +DA:104,13 +FNF:5 +FNH:5 +LF:14 +LH:14 +BRF:6 +BRH:6 +end_of_record +TN: +SF:src/enforcers/NativeTokenPaymentEnforcer.sol +FN:45,NativeTokenPaymentEnforcer. +FNDA:0,NativeTokenPaymentEnforcer. +DA:46,0 +DA:47,0 +FN:61,NativeTokenPaymentEnforcer.afterHook +FNDA:10,NativeTokenPaymentEnforcer.afterHook +DA:73,10 +BRDA:73,0,0,1 +BRDA:73,0,1,9 +DA:76,9 +DA:78,9 +DA:81,9 +DA:82,10 +DA:83,10 +DA:84,12 +BRDA:84,1,0,4 +DA:85,4 +DA:90,9 +DA:91,9 +DA:93,9 +DA:94,9 +DA:96,9 +DA:97,9 +DA:99,9 +DA:102,9 +DA:105,7 +DA:106,7 +BRDA:106,2,0,1 +BRDA:106,2,1,6 +DA:108,6 +FN:118,NativeTokenPaymentEnforcer.getTermsInfo +FNDA:2,NativeTokenPaymentEnforcer.getTermsInfo +DA:119,11 +BRDA:119,3,0,1 +BRDA:119,3,1,10 +DA:121,10 +DA:122,10 +FNF:3 +FNH:2 +LF:24 +LH:22 +BRF:7 +BRH:7 +end_of_record +TN: +SF:src/enforcers/NativeTokenTransferAmountEnforcer.sol +FN:36,NativeTokenTransferAmountEnforcer.beforeHook +FNDA:11,NativeTokenTransferAmountEnforcer.beforeHook +DA:50,11 +DA:52,11 +DA:54,11 +DA:55,11 +BRDA:55,0,0,2 +BRDA:55,0,1,9 +DA:57,9 +FN:65,NativeTokenTransferAmountEnforcer.getTermsInfo +FNDA:1,NativeTokenTransferAmountEnforcer.getTermsInfo +DA:66,12 +FNF:2 +FNH:2 +LF:6 +LH:6 +BRF:2 +BRH:2 +end_of_record +TN: +SF:src/enforcers/NonceEnforcer.sol +FN:27,NonceEnforcer.beforeHook +FNDA:3,NonceEnforcer.beforeHook +DA:40,3 +DA:41,3 +BRDA:41,0,0,2 +BRDA:41,0,1,1 +FN:49,NonceEnforcer.getTermsInfo +FNDA:5,NonceEnforcer.getTermsInfo +DA:50,8 +BRDA:50,1,0,2 +BRDA:50,1,1,6 +DA:51,6 +FN:59,NonceEnforcer.incrementNonce +FNDA:2,NonceEnforcer.incrementNonce +DA:60,2 +DA:62,2 +DA:64,2 +FNF:3 +FNH:3 +LF:7 +LH:7 +BRF:4 +BRH:4 +end_of_record +TN: +SF:src/enforcers/RedeemerEnforcer.sol +FN:21,RedeemerEnforcer.beforeHook +FNDA:5,RedeemerEnforcer.beforeHook +DA:34,5 +DA:35,4 +DA:36,4 +DA:37,5 +DA:39,1 +FN:47,RedeemerEnforcer.getTermsInfo +FNDA:2,RedeemerEnforcer.getTermsInfo +DA:48,7 +DA:49,7 +DA:50,7 +BRDA:50,1,0,2 +BRDA:50,1,1,5 +DA:51,5 +DA:52,5 +DA:53,8 +DA:54,8 +FNF:2 +FNH:2 +LF:12 +LH:12 +BRF:2 +BRH:2 +end_of_record +TN: +SF:src/enforcers/TimestampEnforcer.sol +FN:20,TimestampEnforcer.beforeHook +FNDA:11,TimestampEnforcer.beforeHook +DA:33,11 +DA:35,9 +BRDA:35,0,0,7 +DA:37,7 +BRDA:37,1,0,2 +BRDA:37,1,1,5 +DA:40,7 +BRDA:40,2,0,6 +DA:42,6 +BRDA:42,3,0,3 +BRDA:42,3,1,3 +FN:52,TimestampEnforcer.getTermsInfo +FNDA:0,TimestampEnforcer.getTermsInfo +DA:57,11 +BRDA:57,4,0,2 +BRDA:57,4,1,9 +DA:58,9 +DA:59,9 +FNF:2 +FNH:1 +LF:8 +LH:8 +BRF:8 +BRH:8 +end_of_record +TN: +SF:src/enforcers/ValueLteEnforcer.sol +FN:24,ValueLteEnforcer.beforeHook +FNDA:3,ValueLteEnforcer.beforeHook +DA:38,3 +DA:39,3 +DA:40,3 +BRDA:40,0,0,1 +BRDA:40,0,1,2 +FN:48,ValueLteEnforcer.getTermsInfo +FNDA:5,ValueLteEnforcer.getTermsInfo +DA:49,8 +BRDA:49,1,0,2 +BRDA:49,1,1,6 +DA:50,6 +FNF:2 +FNH:2 +LF:5 +LH:5 +BRF:4 +BRH:4 +end_of_record +TN: +SF:src/libraries/EncoderLib.sol +FN:18,EncoderLib._getDelegationHash +FNDA:371,EncoderLib._getDelegationHash +DA:19,371 +DA:27,371 +FN:36,EncoderLib._getCaveatArrayPacketHash +FNDA:372,EncoderLib._getCaveatArrayPacketHash +DA:37,372 +DA:38,372 +DA:39,169 +DA:41,372 +FN:50,EncoderLib._getCaveatPacketHash +FNDA:170,EncoderLib._getCaveatPacketHash +DA:51,170 +DA:52,170 +FNF:3 +FNH:3 +LF:8 +LH:8 +BRF:0 +BRH:0 +end_of_record +TN: +SF:src/libraries/P256FCLVerifierLib.sol +FN:26,P256FCLVerifierLib.isValidPublicKey +FNDA:1163,P256FCLVerifierLib.isValidPublicKey +DA:27,1163 +FN:38,P256FCLVerifierLib.verifySignature +FNDA:85,P256FCLVerifierLib.verifySignature +DA:40,85 +BRDA:40,0,0,- +DA:41,0 +DA:44,85 +DA:47,85 +DA:51,85 +DA:52,85 +DA:54,1 +FNF:2 +FNH:2 +LF:8 +LH:7 +BRF:1 +BRH:0 +end_of_record +TN: +SF:src/libraries/P256VerifierLib.sol +FN:22,P256VerifierLib._verifyRawP256Signature +FNDA:82,P256VerifierLib._verifyRawP256Signature +DA:23,82 +DA:24,82 +DA:25,82 +FN:39,P256VerifierLib._verifyWebAuthnP256Signature +FNDA:4,P256VerifierLib._verifyWebAuthnP256Signature +DA:49,4 +DA:51,4 +FN:72,P256VerifierLib._decodeRawP256Signature +FNDA:82,P256VerifierLib._decodeRawP256Signature +DA:73,82 +FN:82,P256VerifierLib._decodeWebAuthnP256Signature +FNDA:4,P256VerifierLib._decodeWebAuthnP256Signature +DA:87,4 +FNF:4 +FNH:4 +LF:7 +LH:7 +BRF:0 +BRH:0 +end_of_record +TN: +SF:src/libraries/WebAuthn.sol +FN:13,WebAuthn.contains +FNDA:4,WebAuthn.contains +DA:14,4 +DA:15,4 +DA:17,4 +DA:18,4 +DA:20,4 +DA:21,75 +BRDA:21,0,0,- +DA:22,0 +DA:25,75 +BRDA:25,1,0,1 +DA:26,1 +DA:30,3 +FN:41,WebAuthn.checkAuthFlags +FNDA:4,WebAuthn.checkAuthFlags +DA:43,4 +BRDA:43,2,0,- +DA:44,0 +DA:50,4 +BRDA:50,3,0,- +DA:51,0 +DA:56,4 +BRDA:56,4,0,4 +DA:57,4 +BRDA:57,5,0,- +DA:58,0 +DA:62,4 +FN:115,WebAuthn.verifySignature +FNDA:4,WebAuthn.verifySignature +DA:132,4 +BRDA:132,6,0,- +DA:133,0 +DA:136,4 +DA:139,4 +DA:140,4 +BRDA:140,7,0,1 +DA:141,1 +DA:145,3 +DA:146,3 +DA:148,3 +FNF:3 +FNH:3 +LF:27 +LH:22 +BRF:8 +BRH:3 +end_of_record +TN: +SF:src/libraries/utils/Base64URL.sol +FN:7,Base64URL.encode +FNDA:4,Base64URL.encode +DA:8,4 +DA:9,4 +DA:12,4 +DA:13,4 +BRDA:13,0,0,- +BRDA:13,0,1,4 +DA:14,4 +BRDA:14,1,0,4 +DA:16,4 +DA:17,4 +DA:19,4 +DA:20,172 +BRDA:20,2,0,8 +BRDA:20,2,1,160 +DA:21,8 +DA:22,164 +BRDA:22,3,0,4 +BRDA:22,3,1,160 +DA:23,4 +DA:25,160 +DA:29,4 +FNF:1 +FNH:1 +LF:14 +LH:14 +BRF:7 +BRH:6 +end_of_record +TN: +SF:src/utils/SimpleFactory.sol +FN:25,SimpleFactory.deploy +FNDA:3,SimpleFactory.deploy +DA:26,3 +DA:27,3 +BRDA:27,0,0,- +DA:28,3 +FN:35,SimpleFactory.computeAddress +FNDA:1,SimpleFactory.computeAddress +DA:36,1 +FNF:2 +FNH:2 +LF:4 +LH:4 +BRF:1 +BRH:0 +end_of_record +TN: +SF:test/DeleGatorTestSuite.t.sol +FN:2223,HybridDeleGator_TestSuite_P256_Test. +FNDA:0,HybridDeleGator_TestSuite_P256_Test. +DA:2224,0 +DA:2225,0 +FN:2230,HybridDeleGator_TestSuite_EOA_Test. +FNDA:0,HybridDeleGator_TestSuite_EOA_Test. +DA:2231,0 +DA:2232,0 +FN:2237,MultiSig_TestSuite_Test. +FNDA:0,MultiSig_TestSuite_Test. +DA:2238,0 +DA:2239,0 +FNF:3 +FNH:0 +LF:6 +LH:0 +BRF:0 +BRH:0 +end_of_record +TN: +SF:test/enforcers/AllowedCalldataEnforcer.t.sol +FN:21,DummyContract.stringFn +FNDA:0,DummyContract.stringFn +FN:22,DummyContract.arrayFn +FNDA:0,DummyContract.arrayFn +FNF:2 +FNH:0 +LF:0 +LH:0 +BRF:0 +BRH:0 +end_of_record +TN: +SF:test/enforcers/CaveatEnforcerBaseTest.t.sol +FN:10,CaveatEnforcerBaseTest. +FNDA:0,CaveatEnforcerBaseTest. +DA:11,0 +DA:12,0 +FN:23,CaveatEnforcerBaseTest.setUp +FNDA:115,CaveatEnforcerBaseTest.setUp +DA:24,115 +DA:25,115 +DA:26,115 +DA:27,115 +DA:28,115 +FNF:2 +FNH:1 +LF:7 +LH:5 +BRF:0 +BRH:0 +end_of_record +TN: +SF:test/enforcers/DeployedEnforcer.t.sol +FN:312,Counter.setCount +FNDA:1,Counter.setCount +DA:313,1 +FN:316,Counter.increment +FNDA:0,Counter.increment +DA:317,0 +FNF:2 +FNH:1 +LF:2 +LH:1 +BRF:0 +BRH:0 +end_of_record +TN: +SF:test/enforcers/NativeTokenPaymentEnforcer.t.sol +FN:515,MockDelegationManager.redeemDelegations +FNDA:1,MockDelegationManager.redeemDelegations +FNF:1 +FNH:1 +LF:0 +LH:0 +BRF:0 +BRH:0 +end_of_record +TN: +SF:test/utils/AccountSorterLib.t.sol +FN:7,AccountSorterLib.sortAddressesWithPrivateKeys +FNDA:0,AccountSorterLib.sortAddressesWithPrivateKeys +DA:15,0 +BRDA:15,0,0,- +BRDA:15,0,1,- +DA:16,0 +DA:17,0 +FN:22,AccountSorterLib._quickSort +FNDA:0,AccountSorterLib._quickSort +DA:23,0 +BRDA:23,1,0,- +DA:24,0 +DA:25,0 +DA:26,0 +FN:30,AccountSorterLib._partition +FNDA:0,AccountSorterLib._partition +DA:40,0 +DA:41,0 +DA:43,0 +DA:44,0 +BRDA:44,2,0,- +DA:45,0 +DA:46,0 +DA:47,0 +DA:51,0 +DA:52,0 +DA:54,0 +FNF:3 +FNH:0 +LF:17 +LH:0 +BRF:4 +BRH:0 +end_of_record +TN: +SF:test/utils/BaseTest.t.sol +FN:65,BaseTest.setUp +FNDA:406,BaseTest.setUp +DA:67,406 +DA:68,406 +DA:71,406 +DA:72,406 +DA:75,406 +DA:76,406 +DA:79,406 +DA:80,406 +DA:83,406 +DA:84,406 +DA:87,406 +DA:88,406 +DA:90,406 +DA:91,406 +DA:94,406 +DA:97,406 +DA:98,406 +FN:103,BaseTest.signHash +FNDA:0,BaseTest.signHash +DA:104,307 +FN:107,BaseTest.signHash +FNDA:0,BaseTest.signHash +DA:108,311 +BRDA:108,0,0,77 +BRDA:108,0,1,90 +DA:109,77 +DA:110,234 +BRDA:110,1,0,144 +BRDA:110,1,1,90 +DA:111,144 +DA:112,144 +DA:113,144 +DA:114,90 +BRDA:114,2,0,90 +BRDA:114,2,1,90 +DA:115,90 +DA:117,0 +FN:123,BaseTest.signDelegation +FNDA:0,BaseTest.signDelegation +DA:131,131 +DA:132,131 +DA:133,131 +DA:134,131 +FN:145,BaseTest.createUserOp +FNDA:0,BaseTest.createUserOp +DA:158,187 +DA:160,187 +FN:174,BaseTest.createUserOp +FNDA:0,BaseTest.createUserOp +DA:181,44 +FN:185,BaseTest.createUserOp +FNDA:0,BaseTest.createUserOp +DA:193,125 +FN:197,BaseTest.createUserOp +FNDA:0,BaseTest.createUserOp +DA:206,187 +DA:207,187 +DA:208,187 +DA:209,187 +DA:210,187 +DA:211,187 +DA:213,187 +FN:216,BaseTest.signUserOp +FNDA:0,BaseTest.signUserOp +DA:224,67 +FN:227,BaseTest.signUserOp +FNDA:0,BaseTest.signUserOp +DA:236,70 +DA:237,70 +DA:238,70 +FN:241,BaseTest.createAndSignUserOp +FNDA:0,BaseTest.createAndSignUserOp +DA:250,64 +DA:251,64 +FN:254,BaseTest.createAndSignUserOp +FNDA:0,BaseTest.createAndSignUserOp +DA:264,0 +DA:265,0 +FN:268,BaseTest.createAndSignUserOp +FNDA:0,BaseTest.createAndSignUserOp +DA:276,62 +FN:279,BaseTest.execute_UserOp +FNDA:0,BaseTest.execute_UserOp +DA:280,18 +FN:283,BaseTest.execute_UserOp +FNDA:0,BaseTest.execute_UserOp +DA:284,0 +FN:287,BaseTest.execute_UserOp +FNDA:0,BaseTest.execute_UserOp +DA:295,18 +DA:300,18 +DA:301,18 +DA:302,18 +DA:303,18 +FN:306,BaseTest.execute_UserOp +FNDA:0,BaseTest.execute_UserOp +DA:307,18 +DA:308,18 +FN:311,BaseTest.executeBatch_UserOp +FNDA:0,BaseTest.executeBatch_UserOp +DA:312,9 +DA:313,9 +DA:314,9 +DA:315,9 +DA:316,9 +DA:317,9 +FN:320,BaseTest.invokeDelegation_UserOp +FNDA:0,BaseTest.invokeDelegation_UserOp +DA:321,57 +FN:324,BaseTest.invokeDelegation_UserOp +FNDA:0,BaseTest.invokeDelegation_UserOp +DA:332,57 +DA:333,57 +DA:335,57 +DA:336,57 +DA:338,57 +DA:339,57 +DA:341,57 +DA:342,57 +DA:343,57 +DA:344,57 +DA:345,57 +DA:346,57 +FN:349,BaseTest.submitUserOp_Bundler +FNDA:0,BaseTest.submitUserOp_Bundler +DA:350,48 +FN:353,BaseTest.submitUserOp_Bundler +FNDA:0,BaseTest.submitUserOp_Bundler +DA:354,154 +DA:355,154 +DA:356,154 +DA:357,1 +BRDA:357,3,0,1 +DA:358,154 +FN:361,BaseTest.deployDeleGator +FNDA:0,BaseTest.deployDeleGator +DA:362,2436 +FN:365,BaseTest.deployDeleGator +FNDA:0,BaseTest.deployDeleGator +DA:366,2436 +BRDA:366,4,0,1134 +BRDA:366,4,1,- +DA:367,1134 +DA:368,1302 +BRDA:368,5,0,1302 +BRDA:368,5,1,- +DA:369,1302 +DA:371,0 +FN:375,BaseTest.deployDeleGator_MultiSig +FNDA:0,BaseTest.deployDeleGator_MultiSig +DA:376,1304 +DA:377,1304 +DA:378,1304 +FN:381,BaseTest.deployDeleGator_MultiSig +FNDA:0,BaseTest.deployDeleGator_MultiSig +DA:382,1343 +FN:389,BaseTest.deployDeleGator_Hybrid +FNDA:0,BaseTest.deployDeleGator_Hybrid +DA:390,1134 +DA:391,1134 +DA:392,1134 +DA:393,1134 +DA:394,1134 +DA:395,1134 +DA:396,1134 +FN:399,BaseTest.deployDeleGator_Hybrid +FNDA:0,BaseTest.deployDeleGator_Hybrid +DA:408,1172 +FN:417,BaseTest.createUser +FNDA:0,BaseTest.createUser +DA:418,2436 +DA:419,2436 +DA:420,2436 +DA:422,2436 +DA:423,2436 +DA:424,2436 +DA:425,2436 +DA:426,2436 +DA:428,2436 +DA:429,2436 +FN:434,BaseTest._createUsers +FNDA:406,BaseTest._createUsers +DA:435,406 +DA:436,406 +DA:437,406 +DA:438,406 +DA:439,406 +DA:440,406 +FNF:30 +FNH:2 +LF:119 +LH:114 +BRF:11 +BRH:9 +end_of_record +TN: +SF:test/utils/BasicCF721.t.sol +FN:17,BasicCF721. +FNDA:3,BasicCF721. +DA:26,3 +FN:31,BasicCF721.setBaseURI +FNDA:0,BasicCF721.setBaseURI +DA:32,0 +FN:35,BasicCF721.mint +FNDA:3,BasicCF721.mint +DA:36,3 +DA:37,3 +FN:40,BasicCF721.selfMint +FNDA:0,BasicCF721.selfMint +DA:41,0 +FN:44,BasicCF721.mintWithMetadata +FNDA:0,BasicCF721.mintWithMetadata +DA:45,0 +DA:46,0 +FN:49,BasicCF721.tokenURI +FNDA:0,BasicCF721.tokenURI +DA:50,0 +FN:55,BasicCF721._baseURI +FNDA:0,BasicCF721._baseURI +DA:56,0 +FNF:7 +FNH:2 +LF:9 +LH:3 +BRF:0 +BRH:0 +end_of_record +TN: +SF:test/utils/BasicERC20.t.sol +FN:16,BasicERC20. +FNDA:0,BasicERC20. +DA:25,0 +BRDA:25,0,0,- +FN:33,BasicERC20.burn +FNDA:0,BasicERC20.burn +DA:34,0 +FN:40,BasicERC20.mint +FNDA:4,BasicERC20.mint +DA:41,4 +FNF:3 +FNH:1 +LF:3 +LH:1 +BRF:1 +BRH:0 +end_of_record +TN: +SF:test/utils/Counter.t.sol +FN:13,Counter. +FNDA:0,Counter. +FN:17,Counter.setCount +FNDA:0,Counter.setCount +DA:18,0 +FN:21,Counter.increment +FNDA:100,Counter.increment +DA:22,97 +FN:25,Counter.unsafeIncrement +FNDA:2,Counter.unsafeIncrement +DA:26,2 +FNF:4 +FNH:2 +LF:3 +LH:2 +BRF:0 +BRH:0 +end_of_record +TN: +SF:test/utils/FCLWrapperLib.sol +FN:13,FCL_all_wrapper. +FNDA:84,FCL_all_wrapper. +DA:14,84 +BRDA:14,0,0,- +DA:15,0 +DA:18,84 +DA:19,84 +DA:20,84 +DA:21,84 +DA:22,84 +DA:24,84 +BRDA:24,1,0,84 +DA:25,84 +DA:29,0 +BRDA:29,2,0,- +DA:31,0 +DA:32,0 +FN:37,FCL_all_wrapper.ecdsa_verify +FNDA:0,FCL_all_wrapper.ecdsa_verify +DA:38,0 +FN:41,FCL_all_wrapper.ecdsa_verify +FNDA:0,FCL_all_wrapper.ecdsa_verify +DA:42,0 +FN:45,FCL_all_wrapper.ecdsa_precomputed_verify +FNDA:0,FCL_all_wrapper.ecdsa_precomputed_verify +DA:46,0 +FN:49,FCL_all_wrapper.ecdsa_sign +FNDA:0,FCL_all_wrapper.ecdsa_sign +DA:50,0 +FN:53,FCL_all_wrapper.ecdsa_DerivKpub +FNDA:0,FCL_all_wrapper.ecdsa_DerivKpub +DA:54,0 +FN:57,FCL_all_wrapper.ecdsa_GenKeyPair +FNDA:0,FCL_all_wrapper.ecdsa_GenKeyPair +DA:58,0 +DA:59,0 +FN:62,FCL_all_wrapper.ecdsa_precalc_8dim +FNDA:0,FCL_all_wrapper.ecdsa_precalc_8dim +DA:63,0 +FNF:8 +FNH:1 +LF:20 +LH:8 +BRF:3 +BRH:1 +end_of_record +TN: +SF:test/utils/Invalid1271.t.sol +FN:11,Invalid1271Returns.isValidSignature +FNDA:1,Invalid1271Returns.isValidSignature +DA:12,1 +FN:21,Invalid1271Reverts.isValidSignature +FNDA:1,Invalid1271Reverts.isValidSignature +DA:22,1 +FNF:2 +FNH:2 +LF:2 +LH:2 +BRF:0 +BRH:0 +end_of_record +TN: +SF:test/utils/MockCaveatEnforcer.sol +FN:19,MockCaveatEnforcer.beforeHook +FNDA:7,MockCaveatEnforcer.beforeHook +DA:20,7 +FN:27,MockCaveatEnforcer.afterHook +FNDA:7,MockCaveatEnforcer.afterHook +DA:28,7 +FNF:2 +FNH:2 +LF:2 +LH:2 +BRF:0 +BRH:0 +end_of_record +TN: +SF:test/utils/MockFailureCaveatEnforcer.sol +FN:18,MockFailureCaveatEnforcer.beforeHook +FNDA:1,MockFailureCaveatEnforcer.beforeHook +DA:19,1 +FN:26,MockFailureCaveatEnforcer.afterHook +FNDA:1,MockFailureCaveatEnforcer.afterHook +DA:27,1 +FNF:2 +FNH:2 +LF:2 +LH:2 +BRF:0 +BRH:0 +end_of_record +TN: +SF:test/utils/PasswordCaveatEnforcer.t.sol +FN:18,PasswordEnforcer.beforeHook +FNDA:5,PasswordEnforcer.beforeHook +DA:31,5 +DA:32,5 +BRDA:32,0,0,3 +FNF:1 +FNH:1 +LF:2 +LH:2 +BRF:1 +BRH:1 +end_of_record +TN: +SF:test/utils/SigningUtilsLib.t.sol +FN:29,SigningUtilsLib.signHash_EOA +FNDA:92,SigningUtilsLib.signHash_EOA +DA:30,243 +DA:31,243 +FN:35,SigningUtilsLib.signHash_MultiSig +FNDA:148,SigningUtilsLib.signHash_MultiSig +DA:36,148 +DA:37,151 +DA:38,151 +DA:39,151 +FN:44,SigningUtilsLib.signHash_P256 +FNDA:91,SigningUtilsLib.signHash_P256 +DA:53,91 +DA:55,91 +BRDA:55,0,0,54 +DA:56,54 +DA:59,91 +FNF:3 +FNH:3 +LF:10 +LH:10 +BRF:1 +BRH:1 +end_of_record +TN: +SF:test/utils/StorageUtilsLib.t.sol +FN:20,StorageUtilsLib.toBool +FNDA:8,StorageUtilsLib.toBool +DA:21,8 +DA:23,8 +BRDA:23,0,0,- +BRDA:23,0,1,8 +DA:25,8 +DA:27,8 +DA:30,8 +FN:41,StorageUtilsLib.getStorageLocation +FNDA:5,StorageUtilsLib.getStorageLocation +DA:42,5 +FN:49,StorageUtilsLib.toAddress +FNDA:0,StorageUtilsLib.toAddress +DA:50,0 +FN:59,StorageUtilsLib.loadFullArray +FNDA:2,StorageUtilsLib.loadFullArray +DA:61,2 +DA:63,2 +DA:66,2 +DA:68,2 +DA:70,2 +DA:71,1 +DA:72,1 +DA:74,2 +FNF:4 +FNH:3 +LF:15 +LH:14 +BRF:2 +BRH:1 +end_of_record diff --git a/script/DeployEnvironmentSetUp.s.sol b/script/DeployEnvironmentSetUp.s.sol index 4f53c15..222f40a 100644 --- a/script/DeployEnvironmentSetUp.s.sol +++ b/script/DeployEnvironmentSetUp.s.sol @@ -58,66 +58,71 @@ contract DeployEnvironmentSetUp is Script { // Deploy Delegation Environment Contracts address delegationManager = address(new DelegationManager{ salt: salt }(deployer)); console2.log("DelegationManager: %s", address(delegationManager)); - - address multiSigDeleGatorImpl_ = - address(new MultiSigDeleGator{ salt: salt }(IDelegationManager(delegationManager), entryPoint)); - console2.log("MultiSigDeleGatorImpl: %s", address(multiSigDeleGatorImpl_)); - - address hybridDeleGatorImpl_ = address(new HybridDeleGator{ salt: salt }(IDelegationManager(delegationManager), entryPoint)); - console2.log("HybridDeleGatorImpl: %s", address(hybridDeleGatorImpl_)); - + { + address multiSigDeleGatorImpl_ = + address(new MultiSigDeleGator{ salt: salt }(IDelegationManager(delegationManager), entryPoint)); + console2.log("MultiSigDeleGatorImpl: %s", address(multiSigDeleGatorImpl_)); + + address hybridDeleGatorImpl_ = + address(new HybridDeleGator{ salt: salt }(IDelegationManager(delegationManager), entryPoint)); + console2.log("HybridDeleGatorImpl: %s", address(hybridDeleGatorImpl_)); + } console2.log("~~~"); - // Caveat Enforcers - address allowedCalldataEnforcer = address(new AllowedCalldataEnforcer{ salt: salt }()); - console2.log("AllowedCalldataEnforcer: %s", address(allowedCalldataEnforcer)); + { + // Caveat Enforcers + address allowedCalldataEnforcer = address(new AllowedCalldataEnforcer{ salt: salt }()); + console2.log("AllowedCalldataEnforcer: %s", address(allowedCalldataEnforcer)); - address allowedMethodsEnforcer = address(new AllowedMethodsEnforcer{ salt: salt }()); - console2.log("AllowedMethodsEnforcer: %s", address(allowedMethodsEnforcer)); + address allowedMethodsEnforcer = address(new AllowedMethodsEnforcer{ salt: salt }()); + console2.log("AllowedMethodsEnforcer: %s", address(allowedMethodsEnforcer)); - address allowedTargetsEnforcer = address(new AllowedTargetsEnforcer{ salt: salt }()); - console2.log("AllowedTargetsEnforcer: %s", address(allowedTargetsEnforcer)); + address allowedTargetsEnforcer = address(new AllowedTargetsEnforcer{ salt: salt }()); + console2.log("AllowedTargetsEnforcer: %s", address(allowedTargetsEnforcer)); - address blockNumberEnforcer = address(new BlockNumberEnforcer{ salt: salt }()); - console2.log("BlockNumberEnforcer: %s", address(blockNumberEnforcer)); + address blockNumberEnforcer = address(new BlockNumberEnforcer{ salt: salt }()); + console2.log("BlockNumberEnforcer: %s", address(blockNumberEnforcer)); - address deployedEnforcer = address(new DeployedEnforcer{ salt: salt }()); - console2.log("DeployedEnforcer: %s", address(deployedEnforcer)); + address deployedEnforcer = address(new DeployedEnforcer{ salt: salt }()); + console2.log("DeployedEnforcer: %s", address(deployedEnforcer)); - address erc20BalanceGteEnforcer = address(new ERC20BalanceGteEnforcer{ salt: salt }()); - console2.log("ERC20BalanceGteEnforcer: %s", address(erc20BalanceGteEnforcer)); + address erc20BalanceGteEnforcer = address(new ERC20BalanceGteEnforcer{ salt: salt }()); + console2.log("ERC20BalanceGteEnforcer: %s", address(erc20BalanceGteEnforcer)); - address erc20TransferAmountEnforcer = address(new ERC20TransferAmountEnforcer{ salt: salt }()); - console2.log("ERC20TransferAmountEnforcer: %s", address(erc20TransferAmountEnforcer)); + address erc20TransferAmountEnforcer = address(new ERC20TransferAmountEnforcer{ salt: salt }()); + console2.log("ERC20TransferAmountEnforcer: %s", address(erc20TransferAmountEnforcer)); - address idEnforcer = address(new IdEnforcer{ salt: salt }()); - console2.log("IdEnforcer: %s", address(idEnforcer)); + address idEnforcer = address(new IdEnforcer{ salt: salt }()); + console2.log("IdEnforcer: %s", address(idEnforcer)); - address limitedCallsEnforcer = address(new LimitedCallsEnforcer{ salt: salt }()); - console2.log("LimitedCallsEnforcer: %s", address(limitedCallsEnforcer)); + address limitedCallsEnforcer = address(new LimitedCallsEnforcer{ salt: salt }()); + console2.log("LimitedCallsEnforcer: %s", address(limitedCallsEnforcer)); - address nonceEnforcer = address(new NonceEnforcer{ salt: salt }()); - console2.log("NonceEnforcer: %s", address(nonceEnforcer)); + address nonceEnforcer = address(new NonceEnforcer{ salt: salt }()); + console2.log("NonceEnforcer: %s", address(nonceEnforcer)); - address timestampEnforcer = address(new TimestampEnforcer{ salt: salt }()); - console2.log("TimestampEnforcer: %s", address(timestampEnforcer)); + address timestampEnforcer = address(new TimestampEnforcer{ salt: salt }()); + console2.log("TimestampEnforcer: %s", address(timestampEnforcer)); - address valueLteEnfocer = address(new ValueLteEnforcer{ salt: salt }()); - console2.log("ValueLteEnforcer: %s", address(valueLteEnfocer)); + address valueLteEnfocer = address(new ValueLteEnforcer{ salt: salt }()); + console2.log("ValueLteEnforcer: %s", address(valueLteEnfocer)); - address nativeTokenTransferAmountEnforcer = address(new NativeTokenTransferAmountEnforcer{ salt: salt }()); - console2.log("NativeTokenTransferAmountEnforcer: %s", address(nativeTokenTransferAmountEnforcer)); + address nativeTokenTransferAmountEnforcer = address(new NativeTokenTransferAmountEnforcer{ salt: salt }()); + console2.log("NativeTokenTransferAmountEnforcer: %s", address(nativeTokenTransferAmountEnforcer)); - address nativeBalanceGteEnforcer = address(new NativeBalanceGteEnforcer{ salt: salt }()); - console2.log("NativeBalanceGteEnforcer: %s", address(nativeBalanceGteEnforcer)); + address nativeBalanceGteEnforcer = address(new NativeBalanceGteEnforcer{ salt: salt }()); + console2.log("NativeBalanceGteEnforcer: %s", address(nativeBalanceGteEnforcer)); - address argsEqualityCheckEnforcer = address(new ArgsEqualityCheckEnforcer{ salt: salt }()); - console2.log("ArgsEqualityCheckEnforcer: %s", address(argsEqualityCheckEnforcer)); + address argsEqualityCheckEnforcer = address(new ArgsEqualityCheckEnforcer{ salt: salt }()); + console2.log("ArgsEqualityCheckEnforcer: %s", address(argsEqualityCheckEnforcer)); - address nativeTokenPaymentEnforcer = address( - new NativeTokenPaymentEnforcer{ salt: salt }(IDelegationManager(delegationManager), address(argsEqualityCheckEnforcer)) - ); - console2.log("NativeTokenPaymentEnforcer: %s", address(nativeTokenPaymentEnforcer)); + address nativeTokenPaymentEnforcer = address( + new NativeTokenPaymentEnforcer{ salt: salt }( + IDelegationManager(delegationManager), address(argsEqualityCheckEnforcer) + ) + ); + console2.log("NativeTokenPaymentEnforcer: %s", address(nativeTokenPaymentEnforcer)); + } vm.stopBroadcast(); } diff --git a/script/coverage.sh b/script/coverage.sh index f64c049..f9bed60 100755 --- a/script/coverage.sh +++ b/script/coverage.sh @@ -1,3 +1,5 @@ +# NOTE: Expects to be run from inside the script directory. + set -e # Exit on error cd .. @@ -14,15 +16,15 @@ fi -# # Generates lcov.info -forge coverage --ir-minimum --report lcov --report-file "$folder_path/lcov.info" +# Generates lcov.info +forge coverage --report lcov --skip scripts --report-file "$folder_path/lcov.info" # Filter out test, mock, and script files lcov \ --rc branch_coverage=1 \ --remove "$folder_path/lcov.info" \ --output-file "$folder_path/filtered-lcov.info" \ - "test/*.*" "script/*.*" + "test/*.*" # Generate summary lcov \ diff --git a/test/DeleGatorTestSuite.t.sol b/test/DeleGatorTestSuite.t.sol index ffbbd30..028c00b 100644 --- a/test/DeleGatorTestSuite.t.sol +++ b/test/DeleGatorTestSuite.t.sol @@ -14,12 +14,23 @@ import { ModeLib } from "@erc7579/lib/ModeLib.sol"; import { ExecutionHelper } from "@erc7579/core/ExecutionHelper.sol"; import { BaseTest } from "./utils/BaseTest.t.sol"; -import { Delegation, Caveat, PackedUserOperation, Delegation, Execution, ModeCode } from "../src/utils/Types.sol"; +import { + Delegation, + Caveat, + PackedUserOperation, + Delegation, + Execution, + ModeCode, + ModePayload, + ExecType, + CallType +} from "../src/utils/Types.sol"; +import { CALLTYPE_SINGLE, CALLTYPE_BATCH, EXECTYPE_DEFAULT, EXECTYPE_TRY, MODE_DEFAULT } from "../src/utils/Constants.sol"; import { Implementation, SignatureType } from "./utils/Types.t.sol"; import { Counter } from "./utils/Counter.t.sol"; import { StorageUtilsLib } from "./utils/StorageUtilsLib.t.sol"; import { SigningUtilsLib } from "./utils/SigningUtilsLib.t.sol"; -import { EXECUTE_SINGULAR_SIGNATURE } from "./utils/Constants.sol"; +import { EXECUTE_SIGNATURE, EXECUTE_SINGULAR_SIGNATURE } from "./utils/Constants.sol"; import { IDeleGatorCore } from "../src/interfaces/IDeleGatorCore.sol"; import { IDelegationManager } from "../src/interfaces/IDelegationManager.sol"; import { DeleGatorCore } from "../src/DeleGatorCore.sol"; @@ -1180,12 +1191,35 @@ abstract contract DeleGatorTestSuite is BaseTest { assertEq(finalValue_, initialValue_ + 1); } - // should allow Alice to execute multiple executionCallDatas_ in a single UserOp + // should allow Alice to execute a single execution with a single UserOp + function test_allow_singleExecution_UserOp() public { + // Get Alice's DeleGator's Counter's initial count + uint256 initialValue_ = aliceDeleGatorCounter.count(); + + // Execute Executions + bytes memory userOpCallData_ = abi.encodeWithSignature( + EXECUTE_SIGNATURE, + ModeLib.encode(CALLTYPE_SINGLE, EXECTYPE_DEFAULT, MODE_DEFAULT, ModePayload.wrap(0x00)), + ExecutionLib.encodeSingle(address(aliceDeleGatorCounter), 0, abi.encodeWithSelector(Counter.increment.selector)) + ); + PackedUserOperation memory userOp_ = createUserOp(address(users.alice.deleGator), userOpCallData_); + bytes32 userOpHash_ = entryPoint.getUserOpHash(userOp_); + userOp_.signature = signHash(users.alice, userOpHash_.toEthSignedMessageHash()); + submitUserOp_Bundler(userOp_, false); + + // Get final count + uint256 finalValue_ = aliceDeleGatorCounter.count(); + + // Validate that the delegations_ were worked + assertEq(finalValue_, initialValue_ + 1); + } + + // should allow Alice to execute multiple Executions in a single UserOp function test_allow_multiExecution_UserOp() public { // Get Alice's DeleGator's Counter's initial count uint256 initialValue_ = aliceDeleGatorCounter.count(); - // Create executionCallDatas_ + // Create Executions Execution[] memory executionCallDatas_ = new Execution[](2); executionCallDatas_[0] = Execution({ target: address(aliceDeleGatorCounter), @@ -1199,7 +1233,74 @@ abstract contract DeleGatorTestSuite is BaseTest { }); // Execute Executions - executeBatch_UserOp(users.alice, executionCallDatas_); + bytes memory userOpCallData_ = abi.encodeWithSignature( + EXECUTE_SIGNATURE, + ModeLib.encode(CALLTYPE_BATCH, EXECTYPE_DEFAULT, MODE_DEFAULT, ModePayload.wrap(0x00)), + abi.encode(executionCallDatas_) + ); + PackedUserOperation memory userOp_ = createUserOp(address(users.alice.deleGator), userOpCallData_); + bytes32 userOpHash_ = entryPoint.getUserOpHash(userOp_); + userOp_.signature = signHash(users.alice, userOpHash_.toEthSignedMessageHash()); + submitUserOp_Bundler(userOp_, false); + + // Get final count + uint256 finalValue_ = aliceDeleGatorCounter.count(); + + // Validate that the delegations_ were worked + assertEq(finalValue_, initialValue_ + 2); + } + + // should allow Alice to execute a single Execution in a single UserOp that catches reverts + function test_allow_trySingleExecution_UserOp() public { + // Get Alice's DeleGator's Counter's initial count + uint256 initialValue_ = aliceDeleGatorCounter.count(); + + // Execute Executions + bytes memory userOpCallData_ = abi.encodeWithSignature( + EXECUTE_SIGNATURE, + ModeLib.encode(CALLTYPE_SINGLE, EXECTYPE_TRY, MODE_DEFAULT, ModePayload.wrap(0x00)), + ExecutionLib.encodeSingle(address(aliceDeleGatorCounter), 0, abi.encodeWithSelector(Counter.increment.selector)) + ); + PackedUserOperation memory userOp_ = createUserOp(address(users.alice.deleGator), userOpCallData_); + bytes32 userOpHash_ = entryPoint.getUserOpHash(userOp_); + userOp_.signature = signHash(users.alice, userOpHash_.toEthSignedMessageHash()); + submitUserOp_Bundler(userOp_, false); + + // Get final count + uint256 finalValue_ = aliceDeleGatorCounter.count(); + + // Validate that the delegations_ were worked + assertEq(finalValue_, initialValue_ + 1); + } + + // should allow Alice to execute multiple Executions in a single UserOp that catches reverts + function test_allow_tryMultiExecution_UserOp() public { + // Get Alice's DeleGator's Counter's initial count + uint256 initialValue_ = aliceDeleGatorCounter.count(); + + // Create Executions + Execution[] memory executionCallDatas_ = new Execution[](2); + executionCallDatas_[0] = Execution({ + target: address(aliceDeleGatorCounter), + value: 0, + callData: abi.encodeWithSelector(Counter.increment.selector) + }); + executionCallDatas_[1] = Execution({ + target: address(aliceDeleGatorCounter), + value: 0, + callData: abi.encodeWithSelector(Counter.increment.selector) + }); + + // Execute Executions + bytes memory userOpCallData_ = abi.encodeWithSignature( + EXECUTE_SIGNATURE, + ModeLib.encode(CALLTYPE_BATCH, EXECTYPE_TRY, MODE_DEFAULT, ModePayload.wrap(0x00)), + abi.encode(executionCallDatas_) + ); + PackedUserOperation memory userOp_ = createUserOp(address(users.alice.deleGator), userOpCallData_); + bytes32 userOpHash_ = entryPoint.getUserOpHash(userOp_); + userOp_.signature = signHash(users.alice, userOpHash_.toEthSignedMessageHash()); + submitUserOp_Bundler(userOp_, false); // Get final count uint256 finalValue_ = aliceDeleGatorCounter.count(); @@ -1208,7 +1309,90 @@ abstract contract DeleGatorTestSuite is BaseTest { assertEq(finalValue_, initialValue_ + 2); } - // should allow Bob to execute multiple executionCallDatas_ that redeem delegations_ in a single UserOp (offchain) + // should not allow an unsupported callType + function test_notAllow_unsupportedCallType_UserOp() public { + // Execute Executions + bytes memory userOpCallData_ = abi.encodeWithSignature( + EXECUTE_SIGNATURE, + ModeLib.encode(CallType.wrap(0x02), EXECTYPE_DEFAULT, MODE_DEFAULT, ModePayload.wrap(0x00)), + ExecutionLib.encodeSingle(address(aliceDeleGatorCounter), 0, abi.encodeWithSelector(Counter.increment.selector)) + ); + PackedUserOperation memory userOp_ = createUserOp(address(users.alice.deleGator), userOpCallData_); + bytes32 userOpHash_ = entryPoint.getUserOpHash(userOp_); + userOp_.signature = signHash(users.alice, userOpHash_.toEthSignedMessageHash()); + + // Expect a revert event + vm.expectEmit(false, false, false, true, address(entryPoint)); + emit UserOperationRevertReason( + userOpHash_, + address(users.alice.deleGator), + 0, + abi.encodeWithSelector(DeleGatorCore.UnsupportedCallType.selector, CallType.wrap(0x02)) + ); + + submitUserOp_Bundler(userOp_, false); + } + + // should not allow an unsupported execType + function test_notAllow_singleUnsupportedExecType_UserOp() public { + // Execute Executions + bytes memory userOpCallData_ = abi.encodeWithSignature( + EXECUTE_SIGNATURE, + ModeLib.encode(CALLTYPE_SINGLE, ExecType.wrap(0x02), MODE_DEFAULT, ModePayload.wrap(0x00)), + ExecutionLib.encodeSingle(address(aliceDeleGatorCounter), 0, abi.encodeWithSelector(Counter.increment.selector)) + ); + PackedUserOperation memory userOp_ = createUserOp(address(users.alice.deleGator), userOpCallData_); + bytes32 userOpHash_ = entryPoint.getUserOpHash(userOp_); + userOp_.signature = signHash(users.alice, userOpHash_.toEthSignedMessageHash()); + + // Expect a revert event + vm.expectEmit(false, false, false, true, address(entryPoint)); + emit UserOperationRevertReason( + userOpHash_, + address(users.alice.deleGator), + 0, + abi.encodeWithSelector(DeleGatorCore.UnsupportedExecType.selector, ExecType.wrap(0x02)) + ); + submitUserOp_Bundler(userOp_, false); + } + + // should not allow an unsupported execType in a batch + function test_notAllow_multiUnsupportedExecType_UserOp() public { + // Create Executions + Execution[] memory executionCallDatas_ = new Execution[](2); + executionCallDatas_[0] = Execution({ + target: address(aliceDeleGatorCounter), + value: 0, + callData: abi.encodeWithSelector(Counter.increment.selector) + }); + executionCallDatas_[1] = Execution({ + target: address(aliceDeleGatorCounter), + value: 0, + callData: abi.encodeWithSelector(Counter.increment.selector) + }); + + // Execute Executions + bytes memory userOpCallData_ = abi.encodeWithSignature( + EXECUTE_SIGNATURE, + ModeLib.encode(CALLTYPE_BATCH, ExecType.wrap(0x02), MODE_DEFAULT, ModePayload.wrap(0x00)), + abi.encode(executionCallDatas_) + ); + PackedUserOperation memory userOp_ = createUserOp(address(users.alice.deleGator), userOpCallData_); + bytes32 userOpHash_ = entryPoint.getUserOpHash(userOp_); + userOp_.signature = signHash(users.alice, userOpHash_.toEthSignedMessageHash()); + + // Expect a revert event + vm.expectEmit(false, false, false, true, address(entryPoint)); + emit UserOperationRevertReason( + userOpHash_, + address(users.alice.deleGator), + 0, + abi.encodeWithSelector(DeleGatorCore.UnsupportedExecType.selector, ExecType.wrap(0x02)) + ); + submitUserOp_Bundler(userOp_, false); + } + + // should allow Bob to execute multiple Executions that redeem delegations_ in a single UserOp (offchain) function test_allow_multiExecutionDelegationClaim_Offchain_UserOp() public { // Get Alice's DeleGator's Counter's initial count uint256 initialValue_ = aliceDeleGatorCounter.count(); @@ -1262,7 +1446,7 @@ abstract contract DeleGatorTestSuite is BaseTest { assertEq(finalValue_, initialValue_ + 2); } - // should allow Alice to execute a combination of executionCallDatas_ through a single UserOp + // should allow Alice to execute a combination of Executions through a single UserOp function test_allow_multiExecutionCombination_UserOp() public { // Get DeleGator's Counter's initial count uint256 initialValueAlice_ = aliceDeleGatorCounter.count(); @@ -1317,6 +1501,152 @@ abstract contract DeleGatorTestSuite is BaseTest { assertEq(finalValueBob_, initialValueBob_ + 1); } + // should allow Alice to execute a single Executions in a single UserOp + function test_allow_executeFromExecutor() public { + // Get Alice's DeleGator's Counter's initial count + uint256 initialValue_ = aliceDeleGatorCounter.count(); + + // Execute Execution + vm.prank(address(delegationManager)); + users.alice.deleGator.executeFromExecutor( + ModeLib.encode(CALLTYPE_SINGLE, EXECTYPE_DEFAULT, MODE_DEFAULT, ModePayload.wrap(0x00)), + ExecutionLib.encodeSingle(address(aliceDeleGatorCounter), 0, abi.encodeWithSelector(Counter.increment.selector)) + ); + + // Get final count + uint256 finalValue_ = aliceDeleGatorCounter.count(); + + // Validate that the delegations_ were worked + assertEq(finalValue_, initialValue_ + 1); + } + + // should allow Alice to execute a single Executions in a single UserOp + function test_allow_executeFromExecutor_batch() public { + // Get Alice's DeleGator's Counter's initial count + uint256 initialValue_ = aliceDeleGatorCounter.count(); + + // Execute Execution + Execution[] memory executions_ = new Execution[](2); + executions_[0] = Execution({ + target: address(aliceDeleGatorCounter), + value: 0, + callData: abi.encodeWithSelector(Counter.increment.selector) + }); + executions_[1] = Execution({ + target: address(aliceDeleGatorCounter), + value: 0, + callData: abi.encodeWithSelector(Counter.increment.selector) + }); + vm.prank(address(delegationManager)); + users.alice.deleGator.executeFromExecutor( + ModeLib.encode(CALLTYPE_BATCH, EXECTYPE_DEFAULT, MODE_DEFAULT, ModePayload.wrap(0x00)), + ExecutionLib.encodeBatch(executions_) + ); + + // Get final count + uint256 finalValue_ = aliceDeleGatorCounter.count(); + + // Validate that the delegations_ were worked + assertEq(finalValue_, initialValue_ + 2); + } + + // should allow Alice to execute a single Executions in a single UserOp + function test_allow_tryExecuteFromExecutor() public { + // Get Alice's DeleGator's Counter's initial count + uint256 initialValue_ = aliceDeleGatorCounter.count(); + + // Execute Execution + vm.prank(address(delegationManager)); + users.alice.deleGator.executeFromExecutor( + ModeLib.encode(CALLTYPE_SINGLE, EXECTYPE_TRY, MODE_DEFAULT, ModePayload.wrap(0x00)), + ExecutionLib.encodeSingle(address(aliceDeleGatorCounter), 0, abi.encodeWithSelector(Counter.increment.selector)) + ); + + // Get final count + uint256 finalValue_ = aliceDeleGatorCounter.count(); + + // Validate that the delegations_ were worked + assertEq(finalValue_, initialValue_ + 1); + } + + // should allow Alice to execute a single Executions in a single UserOp + function test_allow_tryExecuteFromExecutor_batch() public { + // Get Alice's DeleGator's Counter's initial count + uint256 initialValue_ = aliceDeleGatorCounter.count(); + + // Execute Execution + Execution[] memory executions_ = new Execution[](2); + executions_[0] = Execution({ + target: address(aliceDeleGatorCounter), + value: 0, + callData: abi.encodeWithSelector(Counter.increment.selector) + }); + executions_[1] = Execution({ + target: address(aliceDeleGatorCounter), + value: 0, + callData: abi.encodeWithSelector(Counter.increment.selector) + }); + vm.prank(address(delegationManager)); + users.alice.deleGator.executeFromExecutor( + ModeLib.encode(CALLTYPE_BATCH, EXECTYPE_TRY, MODE_DEFAULT, ModePayload.wrap(0x00)), + ExecutionLib.encodeBatch(executions_) + ); + + // Get final count + uint256 finalValue_ = aliceDeleGatorCounter.count(); + + // Validate that the delegations_ were worked + assertEq(finalValue_, initialValue_ + 2); + } + + // should allow Alice to execute a single Executions in a single UserOp + function test_allow_executeFromExecutorUnsupportedExecType() public { + vm.expectRevert(abi.encodeWithSelector(DeleGatorCore.UnsupportedExecType.selector, ExecType.wrap(0x02))); + + // Execute Execution + vm.prank(address(delegationManager)); + users.alice.deleGator.executeFromExecutor( + ModeLib.encode(CALLTYPE_SINGLE, ExecType.wrap(0x02), MODE_DEFAULT, ModePayload.wrap(0x00)), + ExecutionLib.encodeSingle(address(aliceDeleGatorCounter), 0, abi.encodeWithSelector(Counter.increment.selector)) + ); + } + + // should allow Alice to execute a single Executions in a single UserOp + function test_notAllow_executeFromExecutorUnsupportedExecType_batch() public { + // Execute Execution + Execution[] memory executions_ = new Execution[](2); + executions_[0] = Execution({ + target: address(aliceDeleGatorCounter), + value: 0, + callData: abi.encodeWithSelector(Counter.increment.selector) + }); + executions_[1] = Execution({ + target: address(aliceDeleGatorCounter), + value: 0, + callData: abi.encodeWithSelector(Counter.increment.selector) + }); + + vm.expectRevert(abi.encodeWithSelector(DeleGatorCore.UnsupportedExecType.selector, ExecType.wrap(0x02))); + + vm.prank(address(delegationManager)); + users.alice.deleGator.executeFromExecutor( + ModeLib.encode(CALLTYPE_BATCH, ExecType.wrap(0x02), MODE_DEFAULT, ModePayload.wrap(0x00)), + ExecutionLib.encodeBatch(executions_) + ); + } + + // should allow Alice to execute a single Executions in a single UserOp + function test_notAllow_executeFromExecutorUnsupportedCallType() public { + vm.expectRevert(abi.encodeWithSelector(DeleGatorCore.UnsupportedCallType.selector, CallType.wrap(0x02))); + + // Execute Execution + vm.prank(address(delegationManager)); + users.alice.deleGator.executeFromExecutor( + ModeLib.encode(CallType.wrap(0x02), EXECTYPE_TRY, MODE_DEFAULT, ModePayload.wrap(0x00)), + ExecutionLib.encodeSingle(address(aliceDeleGatorCounter), 0, abi.encodeWithSelector(Counter.increment.selector)) + ); + } + ////////////////////////////// Invalid cases ////////////////////////////// // should not allow a second Execution to execute if the first Execution fails @@ -1325,7 +1655,7 @@ abstract contract DeleGatorTestSuite is BaseTest { uint256 initialValueAlice_ = aliceDeleGatorCounter.count(); uint256 initialValueBob_ = bobDeleGatorCounter.count(); - // Create executionCallDatas_, incorrectly incrementing Bob's Counter first + // Create Executions, incorrectly incrementing Bob's Counter first Execution[] memory executionCallDatas_ = new Execution[](2); executionCallDatas_[0] = Execution({ target: address(bobDeleGatorCounter), @@ -1338,7 +1668,7 @@ abstract contract DeleGatorTestSuite is BaseTest { callData: abi.encodeWithSelector(Counter.increment.selector) }); - // Execute executionCallDatas_ + // Execute Executions executeBatch_UserOp(users.alice, executionCallDatas_); // Get final count diff --git a/test/DelegationManagerTest.t.sol b/test/DelegationManagerTest.t.sol index 285d369..785a3f3 100644 --- a/test/DelegationManagerTest.t.sol +++ b/test/DelegationManagerTest.t.sol @@ -30,6 +30,7 @@ contract DelegationManagerTest is BaseTest { string private _versionFallback; ModeCode[] _oneSingularMode; ModeCode[] _twoSingularModes; + Counter counter; constructor() { IMPLEMENTATION = Implementation.Hybrid; @@ -45,6 +46,8 @@ contract DelegationManagerTest is BaseTest { _twoSingularModes = new ModeCode[](2); _twoSingularModes[0] = ModeLib.encodeSimpleSingle(); _twoSingularModes[1] = ModeLib.encodeSimpleSingle(); + + counter = new Counter(users.alice.addr); } ////////////////////////////// Events ////////////////////////////// @@ -271,6 +274,70 @@ contract DelegationManagerTest is BaseTest { assertEq(mockEnforcer.afterHookCallCount(), 2); } + function test_allow_redeemBatchDelegationWithPassthrough() public { + // Create a mock caveat enforcers contract + MockCaveatEnforcer mockEnforcer = new MockCaveatEnforcer(); + + // Create delegations with caveats + Delegation memory delegation1 = Delegation({ + delegate: address(users.bob.deleGator), + delegator: address(users.alice.deleGator), + authority: ROOT_AUTHORITY, + caveats: new Caveat[](1), + salt: 0, + signature: hex"" + }); + delegation1.caveats[0] = Caveat({ enforcer: address(mockEnforcer), terms: hex"", args: hex"" }); + + bytes[] memory permissionContexts_ = new bytes[](2); + + // Sign delegations + delegation1 = signDelegation(users.alice, delegation1); + + Delegation[] memory delegations1 = new Delegation[](1); + delegations1[0] = delegation1; + permissionContexts_[0] = abi.encode(delegations1); + + Delegation[] memory delegations2 = new Delegation[](0); + permissionContexts_[1] = abi.encode(delegations2); + + bytes[] memory executionCallDatas_ = new bytes[](2); + executionCallDatas_[0] = + ExecutionLib.encodeSingle(address(counter), 0, abi.encodeWithSelector(Counter.unsafeIncrement.selector)); + executionCallDatas_[1] = + ExecutionLib.encodeSingle(address(counter), 0, abi.encodeWithSelector(Counter.unsafeIncrement.selector)); + + vm.prank(address(users.bob.deleGator)); + delegationManager.redeemDelegations(permissionContexts_, _twoSingularModes, executionCallDatas_); + + // Assert that beforeHook was called for each execution + assertEq(mockEnforcer.beforeHookCallCount(), 1); + + // Assert that afterHook was called after executing all executions + assertEq(mockEnforcer.afterHookCallCount(), 1); + + // Assert the count was increased twice + assertEq(counter.count(), 2); + } + + function test_notAllow_redeemLengthMismatching() public { + bytes[] memory permissionContexts_ = new bytes[](1); + bytes[] memory permissionContexts2_ = new bytes[](2); + ModeCode[] memory modes_ = new ModeCode[](1); + ModeCode[] memory modes2_ = new ModeCode[](2); + bytes[] memory executionCallDatas_ = new bytes[](1); + bytes[] memory executionCallDatas2_ = new bytes[](2); + + vm.expectRevert(abi.encodeWithSelector(IDelegationManager.BatchDataLengthMismatch.selector)); + delegationManager.redeemDelegations(permissionContexts_, modes_, executionCallDatas2_); + + vm.expectRevert(abi.encodeWithSelector(IDelegationManager.BatchDataLengthMismatch.selector)); + delegationManager.redeemDelegations(permissionContexts_, modes2_, executionCallDatas_); + + vm.expectRevert(abi.encodeWithSelector(IDelegationManager.BatchDataLengthMismatch.selector)); + delegationManager.redeemDelegations(permissionContexts2_, modes_, executionCallDatas_); + } + function test_allow_redeemBatchWithEoaInSecondBatchDelegation() public { // Create a mock caveat enforcers contract MockCaveatEnforcer mockEnforcer = new MockCaveatEnforcer(); diff --git a/test/utils/Counter.t.sol b/test/utils/Counter.t.sol index 736f15e..bf06fda 100644 --- a/test/utils/Counter.t.sol +++ b/test/utils/Counter.t.sol @@ -21,4 +21,8 @@ contract Counter is Ownable { function increment() public onlyOwner { count++; } + + function unsafeIncrement() public { + count++; + } }