Skip to content

feat(transforms): impl. storage gates transform #126

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Jump to bottom
Draft
g4titanx wants to merge 4 commits into
base: master
Choose a base branch
from
Draft

feat(transforms): impl. storage gates transform #126

g4titanx wants to merge 4 commits into from

Conversation

@g4titanx
Copy link
Member

@g4titanx g4titanx commented Jan 6, 2026

No description provided.

@github-actions
Copy link
Contributor

github-actions bot commented Jan 6, 2026 •
edited
Loading

Decompile Diff Analysis

Statistics (50 iterations)

  • Total: 43 hunks, -146 removed, +227 added
  • Items: 16 total, 15 with changes
  • Selectors: 19 remapped
Metric Min Avg Max
Hunks 25 42.9 49
Lines removed 142 166.4 224
Lines added 115 233.3 277
Lines unchanged 58 115.6 140
Full Diff Output 
─── Storage ───
@@ -1,14 +1,21 @@
-    uint256 public constant unresolved_d4899a62 = 0;
-    uint256 public constant expectedAmount = 0;
-    uint256 public constant unresolved_8677ab23 = 0;
-    
-    uint256 public bondAmount;
-    address public unresolved_1aa7c0ec;
-    uint256 public executionDeadline;
-    uint256 public currentRewardAmount;
-    uint256 public unresolved_fe03a460;
-    uint256 public unresolved_8bd03d0a;
-    uint256 public unresolved_d415b3f9;
-    bool public unresolved_308657d7;
+    bytes32 store_c;
+    bytes32 store_f;
+    bytes32 store_o;
+    bytes32 store_m;
+    bytes32 store_p;
+    uint256 public unresolved_ce3cd947;
+    address store_k;
+    uint256 store_a;
+    uint256 public unresolved_7ec3d80b;
+    bytes32 store_b;
+    bytes32 store_e;
+    uint256 public unresolved_124ba425;
+    uint256 public unresolved_d71dc2dc;
+    uint256 public unresolved_517fea67;
+    bytes32 store_n;
+    bytes32 store_q;
+    bytes32 store_r;
+    bytes32 store_d;
     
+    error CustomError_00000000();
     

─── Function bond (0x9940686e → 0x99b43aa7) ───
@@ -1,60 +1,63 @@
     
-    /// @custom:selector    0x9940686e
-    /// @custom:signature   bond(uint256 arg0) public payable
+    /// @custom:selector    0x99b43aa7
+    /// @custom:signature   Unresolved_99b43aa7(uint256 arg0) public payable
     /// @param              arg0 ["uint256", "bytes32", "int256"]
-    function bond(uint256 arg0) public payable {
+    function Unresolved_99b43aa7(uint256 arg0) public payable {
+        require(0x99 == msg.data[0]);
+        require(0 == 0x01);
         require(msg.value);
-        require((0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc + msg.data.length) < 0x20, "Bond must be at least half of reward amount");
-        require(!(bytes1(unresolved_308657d7 >> 0x08)), "Bond must be at least half of reward amount");
-        require(!(!bytes1(unresolved_308657d7)), "Bond must be at least half of reward amount");
-        require(!(!arg0 < (currentRewardAmount >> 0x01)), "Bond must be at least half of reward amount");
+        require((0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc + msg.data.length) < 0x20, "Cancellation requested");
+        require(!(bytes1(store_c >> 0x08)), "Cancellation requested");
+        require(!(!bytes1(store_c)), "Cancellation requested");
+        var_a = 0x08c379a000000000000000000000000000000000000000000000000000000000;
+        var_b = 0x20;
+        var_c = 0x16;
+        var_d = 0x43616e63656c6c6174696f6e2072657175657374656400000000000000000000;
+        require(!(!arg0 < (unresolved_d71dc2dc >> 0x01)), CustomError_0());
         var_a = 0x08c379a000000000000000000000000000000000000000000000000000000000;
         var_b = 0x20;
         var_c = 0x2b;
         var_d = 0x426f6e64206d757374206265206174206c656173742068616c66206f66207265;
-        var_e = 0x7761726420616d6f756e74000000000000000000000000000000000000000000;
-        require(executionDeadline, "Another executor is already bonded");
-        require(block.timestamp > executionDeadline, "Another executor is already bonded");
-        require(executionDeadline, "Another executor is already bonded");
-        require(!(block.timestamp > executionDeadline), "Another executor is already bonded");
+        uint256 var_e = (0x9d118d20cd65ed5077f8f7 - (0x451616462a81b753aaab6c - var_f)) << 0xaa;
+        require(unresolved_ce3cd947, CustomError_0());
+        require(block.timestamp > unresolved_ce3cd947, CustomError_0());
+        require(unresolved_ce3cd947, CustomError_0());
+        require(!(block.timestamp > unresolved_ce3cd947), CustomError_0());
         var_a = 0x08c379a000000000000000000000000000000000000000000000000000000000;
         var_b = 0x20;
         var_c = 0x22;
-        var_d = 0x416e6f74686572206578656375746f7220697320616c726561647920626f6e64;
-        var_e = 0x6564000000000000000000000000000000000000000000000000000000000000;
+        var_g = 0x416e6f74686572206578656375746f7220697320616c7265616479206acd8caa ^ var_f;
+        var_h = 0x6564000000000000000000000000000000000000000000000000000000000000;
         var_a = 0x23b872dd00000000000000000000000000000000000000000000000000000000;
         address var_b = msg.sender;
         address var_c = address(this);
         uint256 var_d = arg0;
         (bool success, bytes memory ret0) = address(0).Unresolved_23b872dd(var_b); // call
-        unresolved_1aa7c0ec = var_b | (uint96(unresolved_1aa7c0ec));
-        require(block.timestamp > (block.timestamp + 0x012c));
-        var_f = 0x4e487b7100000000000000000000000000000000000000000000000000000000;
-        var_g = 0x11;
-        executionDeadline = block.timestamp + 0x012c;
-        bondAmount = arg0;
-        require(0x20 > ret0.length);
-        require(((var_h + 0x20) > 0xffffffffffffffff) | ((var_h + 0x20) < var_h));
-        var_f = 0x4e487b7100000000000000000000000000000000000000000000000000000000;
-        var_g = 0x41;
-        uint256 var_h = var_h + 0x20;
-        require(((var_h + 0x20) - var_h) < 0x20);
-        require(var_h.length - var_h.length);
-        if (currentRewardAmount > (currentRewardAmount + bondAmount)) {
-            var_f = 0x4e487b7100000000000000000000000000000000000000000000000000000000;
-            var_g = 0x11;
-            currentRewardAmount = currentRewardAmount + bondAmount;
-            require(currentRewardAmount > (currentRewardAmount + bondAmount), "Cancellation requested");
-            var_f = 0x4e487b7100000000000000000000000000000000000000000000000000000000;
-            var_g = 0x11;
-            require(unresolved_fe03a460 > (unresolved_fe03a460 + bondAmount), "Cancellation requested");
+        store_k = var_b | (uint96(store_k));
+        require(block.timestamp > (block.timestamp + 0x012c), CustomError_4e487e19());
+        var_i = 0x4e487e1900000000000000000000000000000000000000000000000000000000;
+        var_j = 0x11;
+        unresolved_ce3cd947 = block.timestamp + 0x012c;
+        store_a = arg0;
+        require(0x20 > ret0.length, CustomError_4e487c11());
+        require(((var_f + 0x20) > 0xffffffffffffffff) | ((var_f + 0x20) < var_f), CustomError_4e487c11());
+        uint256 var_i = (0xca65674c + (0x83e31425 + (var_f + 0x20))) << 0xe0;
+        var_j = 0x41;
+        uint256 var_f = var_f + 0x20;
+        require(((var_f + 0x20) - var_f) < 0x20);
+        require(var_f.length - var_f.length);
+        require(unresolved_d71dc2dc > (unresolved_d71dc2dc + store_a), CustomError_4e487eea());
+        var_i = 0x4e487eea00000000000000000000000000000000000000000000000000000000;
+        var_j = 0x11;
+        unresolved_d71dc2dc = unresolved_d71dc2dc + store_a;
+        require(unresolved_517fea67 > (unresolved_517fea67 + store_a), CustomError_4e487edf());
+        var_i = 0x4e487edf00000000000000000000000000000000000000000000000000000000;
+        var_j = 0x11;
+        if (unresolved_ce3cd947) {
         }
         var_a = 0x08c379a000000000000000000000000000000000000000000000000000000000;
         var_b = 0x20;
-        var_c = 0x16;
-        var_d = 0x43616e63656c6c6174696f6e2072657175657374656400000000000000000000;
-        var_a = 0x08c379a000000000000000000000000000000000000000000000000000000000;
-        var_b = 0x20;
         var_c = 0x13;
-        var_d = 0x436f6e7472616374206e6f742066756e64656400000000000000000000000000;
+        var_k = this.code[12629:12629];
+        uint256 var_l = (uint248(0x1099 + ((0x2f87e914 ^ (0x7a393141 ^ (0x2743988a ^ (0x2fac4e30 ^ ((0x2c0000000440082840002420240014431c841a1843001f019c08119500885102 | (var_i + (0x2a79c5af7289d4cf7f8246a45498bc489100c9f92d9071674843da3d738235b7 + var_f))) - 0xcb33))))) ^ 0x0498))) << 0x6a;
     }

─── Function resume (0x046f7da2 → 0x8f667434) ───
@@ -1,13 +1,15 @@
     
-    /// @custom:selector    0x046f7da2
-    /// @custom:signature   resume() public payable
-    function resume() public payable {
+    /// @custom:selector    0x8f667434
+    /// @custom:signature   Unresolved_8f667434() public payable
+    function Unresolved_8f667434() public payable {
+        require(!store_e);
+        require(0 == 0x01);
         require(msg.value);
         require((0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc + msg.data.length) < 0);
         require(!(0 == msg.sender), "Only callable by the deployer");
         var_a = 0x08c379a000000000000000000000000000000000000000000000000000000000;
         var_b = 0x20;
         var_c = 0x1d;
         var_d = 0x4f6e6c792063616c6c61626c6520627920746865206465706c6f796572000000;
-        unresolved_308657d7 = uint248(unresolved_308657d7);
+        store_c = uint248(store_c);
     }

─── Function Unresolved_ede7f6a3 (0xede7f6a3 → 0x07a30b27) ───
@@ -1,61 +1,53 @@
-    /// @custom:selector    0xede7f6a3
-    /// @custom:signature   Unresolved_ede7f6a3(uint256 arg0, uint256 arg1) public view
+    
+    /// @custom:selector    0x07a30b27
+    /// @custom:signature   Unresolved_07a30b27(uint256 arg0, uint256 arg1) public view
     /// @param              arg0 ["uint256", "bytes32", "int256"]
     /// @param              arg1 ["uint256", "bytes32", "int256"]
-    function Unresolved_ede7f6a3(uint256 arg0, uint256 arg1) public view {
+    function Unresolved_07a30b27(uint256 arg0, uint256 arg1) public view {
+        require(!store_m);
+        require(0 == 0x01);
         require(msg.value);
         require((0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc + msg.data.length) < 0x40);
         require(arg0 > 0xffffffffffffffff);
         require(((msg.data.length - arg0) + 0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc) < 0xa0, "Only bonded executor can collect");
-        require(!(bytes1(unresolved_308657d7 >> 0x08)), "Only bonded executor can collect");
-        require(address(unresolved_1aa7c0ec) == msg.sender, "Only bonded executor can collect");
-        require(!(address(unresolved_1aa7c0ec) == msg.sender), "Only bonded executor can collect");
+        require(!(bytes1(store_c >> 0x08)), "Only bonded executor can collect");
+        require(address(store_k) == msg.sender, "Only bonded executor can collect");
+        require(!(address(store_k) == msg.sender), "Only bonded executor can collect");
         var_a = 0x08c379a000000000000000000000000000000000000000000000000000000000;
         var_b = 0x20;
         var_c = 0x20;
         var_d = 0x4f6e6c7920626f6e646564206578656375746f722063616e20636f6c6c656374;
-        require(!(!arg1 > block.number), "Target block is in the future");
+        require(!(!arg1 > block.number), CustomError_0());
         var_a = 0x08c379a000000000000000000000000000000000000000000000000000000000;
         var_b = 0x20;
         var_c = 0x1d;
-        var_d = 0x54617267657420626c6f636b20697320696e2074686520667574757265000000;
-        require((block.number - arg1) > block.number);
-        var_e = 0x4e487b7100000000000000000000000000000000000000000000000000000000;
-        var_f = 0x11;
+        uint256 var_e = 0x611a40b6b20411d2fe306a9e8e1fd9a10abddb7d7731337a5f6d4af0ab57242d ^ ((0x5c91fe6ce2699c3f9460b93cbcb39358 + (0xde1b49ba166a0bd717d05e8dbbde89bb + (0x357b32d1d77031b0925f09f5ae76aa822926b2e226806b057de827b855c5071a + var_f))) + 0x080f);
+        require((block.number - arg1) > block.number, CustomError_4e48736d());
+        var_g = 0x4e48736d00000000000000000000000000000000000000000000000000000000;
+        var_h = 0x11;
         require(0 < (block.number - arg1));
         require(!blockhash(arg1));
         require(arg0 + (arg0) > 0xffffffffffffffff);
-        require(arg0 + (arg0) > 0xffffffffffffffff, "Block header hash mismatch");
-        var_e = 0x4e487b7100000000000000000000000000000000000000000000000000000000;
-        var_f = 0x41;
-        require(((var_g + (uint248((0x20 + (0x1f + (arg0 + (arg0)))) + 0x1f))) > 0xffffffffffffffff) | ((var_g + (uint248((0x20 + (0x1f + (arg0 + (arg0)))) + 0x1f))) < var_g), "Block header hash mismatch");
-        var_e = 0x4e487b7100000000000000000000000000000000000000000000000000000000;
-        var_f = 0x41;
-        uint256 var_g = var_g + (uint248((0x20 + (0x1f + (arg0 + (arg0)))) + 0x1f));
-        uint256 var_a = (arg0 + (arg0));
-        var_h = msg.data[36:36];
-        uint256 var_i = 0;
-        require(!(keccak256(var_h) == blockhash(arg1)), "Block header hash mismatch");
-        var_i = 0x08c379a000000000000000000000000000000000000000000000000000000000;
-        var_c = 0x20;
-        var_d = 0x1a;
-        var_j = 0x426c6f636b206865616465722068617368206d69736d61746368000000000000;
+        require(arg0 + (arg0) > 0xffffffffffffffff);
+        uint256 var_g = (0xca65674c + (0x83e31425 + (arg0 + (arg0)))) << 0xe0;
+        var_h = 0x41;
         var_a = 0x08c379a000000000000000000000000000000000000000000000000000000000;
         var_b = 0x20;
         var_c = 0x1d;
-        var_d = 0x556e61626c6520746f20726574726965766520626c6f636b2068617368000000;
+        uint256 var_i = 0x41a5fe8dbeb8fd62849234d1a57e547a78d7de12a29fa6bf138b18572f018123 ^ (0x140a06ccc08d450083a00090d1083c0700a0c2408650c5143001712447010023 | (uint256(0x1cc9dfef3ed5bd166bb24eac1885a91e0f12fe30eeb344c26be3682520518122 + var_f)));
         var_a = 0x08c379a000000000000000000000000000000000000000000000000000000000;
         var_b = 0x20;
         var_c = 0x14;
         var_d = 0x54617267657420626c6f636b20746f6f206f6c64000000000000000000000000;
-        require(executionDeadline, "Only bonded executor can collect");
-        require(!(!block.timestamp > executionDeadline), "Only bonded executor can collect");
+        require(unresolved_ce3cd947, "Only bonded executor can collect");
+        require(!(!block.timestamp > unresolved_ce3cd947), "Only bonded executor can collect");
         var_a = 0x08c379a000000000000000000000000000000000000000000000000000000000;
         var_b = 0x20;
         var_c = 0x20;
         var_d = 0x4f6e6c7920626f6e646564206578656375746f722063616e20636f6c6c656374;
         var_a = 0x08c379a000000000000000000000000000000000000000000000000000000000;
         var_b = 0x20;
         var_c = 0x13;
-        var_d = 0x436f6e7472616374206e6f742066756e64656400000000000000000000000000;
+        var_j = this.code[12629:12629];
+        uint256 var_k = (uint248(0x1099 + ((0x2f87e914 ^ (0x7a393141 ^ (0x2743988a ^ (0x2fac4e30 ^ ((0x2c0000000440082840002420240014431c841a1843001f019c08119500885102 | (var_g + (0x2a79c5af7289d4cf7f8246a45498bc489100c9f92d9071674843da3d738235b7 + var_f))) - 0xcb33))))) ^ 0x07e0))) << 0x6a;
     }

─── Function fund (0xa65e2cfd → 0x4c2ff8bd) ───
@@ -1,49 +1,53 @@
     
-    /// @custom:selector    0xa65e2cfd
-    /// @custom:signature   fund(uint256 arg0, uint256 arg1) public payable
+    /// @custom:selector    0x4c2ff8bd
+    /// @custom:signature   Unresolved_4c2ff8bd(uint256 arg0, uint256 arg1) public payable
     /// @param              arg0 ["uint256", "bytes32", "int256"]
     /// @param              arg1 ["uint256", "bytes32", "int256"]
-    function fund(uint256 arg0, uint256 arg1) public payable {
+    function Unresolved_4c2ff8bd(uint256 arg0, uint256 arg1) public payable {
+        require(!store_f);
+        require(0 == 0x01);
         require(msg.value);
         require((0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc + msg.data.length) < 0x40, "Only callable by the deployer");
         require(!(msg.sender == 0), "Only callable by the deployer");
         var_a = 0x08c379a000000000000000000000000000000000000000000000000000000000;
         var_b = 0x20;
         var_c = 0x1d;
         var_d = 0x4f6e6c792063616c6c61626c6520627920746865206465706c6f796572000000;
-        require(!(!bytes1(unresolved_308657d7 >> 0x08)), "Contract already funded");
+        require(!(!bytes1(store_c >> 0x08)), "Contract already funded");
         var_a = 0x08c379a000000000000000000000000000000000000000000000000000000000;
         var_b = 0x20;
         var_c = 0x17;
         var_d = 0x436f6e747261637420616c72656164792066756e646564000000000000000000;
-        require(!arg0);
-        require(!arg1);
-        currentRewardAmount = arg0;
-        unresolved_d415b3f9 = arg0;
-        unresolved_8bd03d0a = arg1;
-        require(unresolved_d415b3f9 > (unresolved_d415b3f9 + unresolved_8bd03d0a));
-        var_e = 0x4e487b7100000000000000000000000000000000000000000000000000000000;
+        require(!arg0, CustomError_4e487d1f());
+        require(!arg1, CustomError_4e487d1f());
+        unresolved_d71dc2dc = arg0;
+        unresolved_7ec3d80b = arg0;
+        unresolved_124ba425 = arg1;
+        require(unresolved_7ec3d80b > (unresolved_7ec3d80b + unresolved_124ba425), CustomError_4e487d1f());
+        var_e = 0x4e487d1f00000000000000000000000000000000000000000000000000000000;
         var_f = 0x11;
         var_a = 0x23b872dd00000000000000000000000000000000000000000000000000000000;
         address var_b = msg.sender;
         address var_c = address(this);
-        uint256 var_d = unresolved_d415b3f9 + unresolved_8bd03d0a;
+        uint256 var_d = unresolved_7ec3d80b + unresolved_124ba425;
         (bool success, bytes memory ret0) = address(0).Unresolved_23b872dd(var_b); // call
-        unresolved_308657d7 = (uint248(unresolved_308657d7)) | 0x0100;
-        require(0x20 > ret0.length);
-        require(((var_g + 0x20) > 0xffffffffffffffff) | ((var_g + 0x20) < var_g));
-        var_e = 0x4e487b7100000000000000000000000000000000000000000000000000000000;
+        store_c = (uint248(store_c)) | 0x0100;
+        require(0x20 > ret0.length, CustomError_4e487c11());
+        require(((var_g + 0x20) > 0xffffffffffffffff) | ((var_g + 0x20) < var_g), CustomError_4e487c11());
+        uint256 var_e = (0xca65674c + (0x83e31425 + (var_g + 0x20))) << 0xe0;
         var_f = 0x41;
         uint256 var_g = var_g + 0x20;
         require(((var_g + 0x20) - var_g) < 0x20);
         require(var_g.length - var_g.length);
-        unresolved_308657d7 = (uint248(unresolved_308657d7)) | 0x0100;
+        store_c = (uint248(store_c)) | 0x0100;
         var_a = 0x08c379a000000000000000000000000000000000000000000000000000000000;
         var_b = 0x20;
         var_c = 0x1f;
-        var_d = 0x5061796d656e7420616d6f756e74206d757374206265206e6f6e2d7a65726f00;
+        var_h = this.code[12661:12661];
+        var_h = this.code[12693:12693];
+        uint256 var_i = (0x2a9888a1 + (0x1af8f231 + ((0x064d - (0x3aeb1323444c16af + (0x26a682c97d6c3472 + (uint256((0x4ae351269b8753dcd9af7cefc8b32301 - (0xdb6b3fcfeeb33da4eaf9c6f79b21035c - ((var_e ^ 0xad0bdfc7fd5d99563fc1b0c7bdc47b3fc6481022d9c849f9c00e6343b3ca68d9) / var_e))) + var_g))))) - 0xdcaa5d9957ef23f5be1411503f5059d2a1460b0be52797b92a6453e569eaf3bc))) + arg0;
         var_a = 0x08c379a000000000000000000000000000000000000000000000000000000000;
         var_b = 0x20;
         var_c = 0x1e;
         var_d = 0x52657761726420616d6f756e74206d757374206265206e6f6e2d7a65726f0000;
     }

─── Function withdraw (0x3ccfd60b → 0xf016d683) ───
@@ -1,55 +1,28 @@
     
-    /// @custom:selector    0x3ccfd60b
-    /// @custom:signature   withdraw() public payable
-    function withdraw() public payable {
+    /// @custom:selector    0xf016d683
+    /// @custom:signature   Unresolved_f016d683(uint256 arg0) public view
+    /// @param              arg0 ["uint256", "bytes32", "int256"]
+    function Unresolved_f016d683(uint256 arg0) public view {
+        require(0xd6 == msg.data[0]);
+        require(0 == 0x01);
         require(msg.value);
         require((0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc + msg.data.length) < 0);
-        require(!(bytes1(unresolved_308657d7 >> 0x08)), "Only callable by the deployer");
+        require(!(bytes1(store_c >> 0x08)), "Only callable by the deployer");
         require(!(msg.sender == 0), "Only callable by the deployer");
         var_a = 0x08c379a000000000000000000000000000000000000000000000000000000000;
         var_b = 0x20;
         var_c = 0x1d;
         var_d = 0x4f6e6c792063616c6c61626c6520627920746865206465706c6f796572000000;
-        require(!((bytes1(unresolved_308657d7 >> 0x08)) == 0x01), "Cannot reset while bond is active");
-        require(executionDeadline, "Cannot reset while bond is active");
-        require(!(block.timestamp > executionDeadline), "Cannot reset while bond is active");
-        var_a = 0x08c379a000000000000000000000000000000000000000000000000000000000;
-        var_b = 0x20;
-        var_c = 0x21;
-        var_d = 0x43616e6e6f74207265736574207768696c6520626f6e64206973206163746976;
-        var_e = 0x6500000000000000000000000000000000000000000000000000000000000000;
-        unresolved_1aa7c0ec = uint96(unresolved_1aa7c0ec);
-        bondAmount = 0;
-        executionDeadline = 0;
-        require(unresolved_8bd03d0a > (unresolved_8bd03d0a + unresolved_d415b3f9));
-        var_f = 0x4e487b7100000000000000000000000000000000000000000000000000000000;
-        var_g = 0x11;
-        unresolved_308657d7 = uint248(unresolved_308657d7);
-        unresolved_8bd03d0a = 0;
-        currentRewardAmount = 0;
-        require(!unresolved_8bd03d0a + unresolved_d415b3f9);
-        var_a = 0xa9059cbb00000000000000000000000000000000000000000000000000000000;
-        address var_b = msg.sender;
-        uint256 var_c = unresolved_8bd03d0a + unresolved_d415b3f9;
-        (bool success, bytes memory ret0) = address(0).Unresolved_a9059cbb(var_b); // call
-        require(0x20 > ret0.length);
-        require(((var_h + 0x20) > 0xffffffffffffffff) | ((var_h + 0x20) < var_h));
-        var_f = 0x4e487b7100000000000000000000000000000000000000000000000000000000;
-        var_g = 0x41;
-        uint256 var_h = var_h + 0x20;
-        require(((var_h + 0x20) - var_h) < 0x20);
-        require(var_h.length - var_h.length);
-        var_a = 0x08c379a000000000000000000000000000000000000000000000000000000000;
-        var_b = 0x20;
-        var_c = 0x15;
-        var_d = 0x4e6f20776974686472617761626c652066756e64730000000000000000000000;
+        require(!((bytes1(store_c >> 0x08)) == 0x01), "The contract was not funded or has been drained already");
+        require(unresolved_ce3cd947, "The contract was not funded or has been drained already");
         var_a = 0x08c379a000000000000000000000000000000000000000000000000000000000;
         var_b = 0x20;
         var_c = 0x37;
         var_d = 0x54686520636f6e747261637420776173206e6f742066756e646564206f722068;
         var_e = 0x6173206265656e20647261696e656420616c7265616479000000000000000000;
         var_a = 0x08c379a000000000000000000000000000000000000000000000000000000000;
         var_b = 0x20;
         var_c = 0x13;
-        var_d = 0x436f6e7472616374206e6f742066756e64656400000000000000000000000000;
+        var_f = this.code[12629:12629];
+        uint248 var_g = (uint248(0x1099 + ((0x2f87e914 ^ (0x7a393141 ^ (0x2743988a ^ (0x2fac4e30 ^ ((0x2c0000000440082840002420240014431c841a1843001f019c08119500885102 | (var_h + (0x2a79c5af7289d4cf7f8246a45498bc489100c9f92d9071674843da3d738235b7 + var_i))) - 0xcb33))))) ^ 0x0267))) << 0x6a;
     }

─── Function requestCancellation (0x81972d00 → 0x24f0ef46) ───
@@ -1,13 +1,15 @@
     
-    /// @custom:selector    0x81972d00
-    /// @custom:signature   requestCancellation() public payable
-    function requestCancellation() public payable {
+    /// @custom:selector    0x24f0ef46
+    /// @custom:signature   Unresolved_24f0ef46() public payable
+    function Unresolved_24f0ef46() public payable {
+        require(!store_d);
+        require(0 == 0x01);
         require(msg.value);
         require((0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc + msg.data.length) < 0);
         require(!(0 == msg.sender), "Only callable by the deployer");
         var_a = 0x08c379a000000000000000000000000000000000000000000000000000000000;
         var_b = 0x20;
         var_c = 0x1d;
         var_d = 0x4f6e6c792063616c6c61626c6520627920746865206465706c6f796572000000;
-        unresolved_308657d7 = 0x01 | (uint248(unresolved_308657d7));
+        store_c = 0x01 | (uint248(store_c));
     }

─── Added: Unresolved_80b26c51 (0x80b26c51) ───
@@ -1,0 +1,11 @@
+    /// @custom:selector    0x80b26c51
+    /// @custom:signature   Unresolved_80b26c51(uint256 arg0) public view returns (uint256)
+    /// @param              arg0 ["uint256", "bytes32", "int256"]
+    function Unresolved_80b26c51(uint256 arg0) public view returns (uint256) {
+        require(0x80 == msg.data[0]);
+        require(0 == 0x01);
+        require(msg.value);
+        require((0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc + msg.data.length) < 0);
+        var_a = store_a;
+        return store_a;
+    }

─── Added: Unresolved_7ff478de (0x7ff478de) ───
@@ -1,0 +1,11 @@
+    
+    /// @custom:selector    0x7ff478de
+    /// @custom:signature   Unresolved_7ff478de() public view returns (uint256)
+    function Unresolved_7ff478de() public view returns (uint256) {
+        require(!store_b);
+        require(0 == 0x01);
+        require(msg.value);
+        require((0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc + msg.data.length) < 0);
+        uint256 var_a = 0;
+        return 0;
+    }

─── Added: Unresolved_98c9ab15 (0x98c9ab15) ───
@@ -1,0 +1,12 @@
+    
+    /// @custom:selector    0x98c9ab15
+    /// @custom:signature   Unresolved_98c9ab15(uint256 arg0) public pure returns (uint256)
+    /// @param              arg0 ["uint256", "bytes32", "int256"]
+    function Unresolved_98c9ab15(uint256 arg0) public pure returns (uint256) {
+        require(0xab == msg.data[0]);
+        require(0 == 0x01);
+        require(msg.value);
+        require((0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc + msg.data.length) < 0);
+        uint256 var_a = 0;
+        return 0;
+    }

─── Added: Unresolved_9dc76a7d (0x9dc76a7d) ───
@@ -1,0 +1,16 @@
+    
+    /// @custom:selector    0x9dc76a7d
+    /// @custom:signature   Unresolved_9dc76a7d(uint256 arg0) public view returns (bool)
+    /// @param              arg0 ["uint256", "bytes32", "int256"]
+    function Unresolved_9dc76a7d(uint256 arg0) public view returns (bool) {
+        require(0x6a == msg.data[0]);
+        require(0 == 0x01);
+        require(msg.value);
+        require((0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc + msg.data.length) < 0);
+        if (unresolved_ce3cd947) {
+            uint256 var_a = !(block.timestamp > unresolved_ce3cd947);
+            return !(block.timestamp > unresolved_ce3cd947);
+            var_a = unresolved_ce3cd947;
+            return unresolved_ce3cd947;
+        }
+    }

─── Added: Unresolved_30db9b03 (0x30db9b03) ───
@@ -1,0 +1,12 @@
+    
+    /// @custom:selector    0x30db9b03
+    /// @custom:signature   Unresolved_30db9b03(uint256 arg0) public view returns (bool)
+    /// @param              arg0 ["uint256", "bytes32", "int256"]
+    function Unresolved_30db9b03(uint256 arg0) public view returns (bool) {
+        require(0x30 == msg.data[0]);
+        require(0 == 0x01);
+        require(msg.value);
+        require((0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc + msg.data.length) < 0);
+        bytes1 var_a = !(!bytes1(store_c));
+        return !(!bytes1(store_c));
+    }

─── Added: Unresolved_bd82c067 (0xbd82c067) ───
@@ -1,0 +1,12 @@
+    
+    /// @custom:selector    0xbd82c067
+    /// @custom:signature   Unresolved_bd82c067(uint256 arg0) public view returns (address)
+    /// @param              arg0 ["uint256", "bytes32", "int256"]
+    function Unresolved_bd82c067(uint256 arg0) public view returns (address) {
+        require(0xc0 == msg.data[0]);
+        require(0 == 0x01);
+        require(msg.value);
+        require((0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc + msg.data.length) < 0);
+        address var_a = address(store_k);
+        return address(store_k);
+    }

─── Added: Unresolved_07c604a0 (0x07c604a0) ───
@@ -1,0 +1,12 @@
+    
+    /// @custom:selector    0x07c604a0
+    /// @custom:signature   Unresolved_07c604a0(uint256 arg0) public view returns (bool)
+    /// @param              arg0 ["uint256", "bytes32", "int256"]
+    function Unresolved_07c604a0(uint256 arg0) public view returns (bool) {
+        require(0x04 == msg.data[0]);
+        require(0 == 0x01);
+        require(msg.value);
+        require((0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc + msg.data.length) < 0);
+        bytes1 var_a = !(!bytes1(store_c >> 0x08));
+        return !(!bytes1(store_c >> 0x08));
+    }

─── Added: Unresolved_d4d044ed (0xd4d044ed) ───
@@ -1,0 +1,12 @@
+    
+    /// @custom:selector    0xd4d044ed
+    /// @custom:signature   Unresolved_d4d044ed(uint256 arg0) public pure returns (uint256)
+    /// @param              arg0 ["uint256", "bytes32", "int256"]
+    function Unresolved_d4d044ed(uint256 arg0) public pure returns (uint256) {
+        require(0xd4 == msg.data[0]);
+        require(0 == 0x01);
+        require(msg.value);
+        require((0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc + msg.data.length) < 0);
+        uint256 var_a = 0;
+        return 0;
+    }

Commit b4e8dec

@g4titanx
Copy link
Member Author

g4titanx commented Jan 6, 2026

StorageGates decides eligible setters/checkers by scanning reachable blocks from controller nodes. After FunctionDispatcher, controller blocks are not direct function entries. They jump through randomized stub/decoy chains. Scanning often can’t resolve the real function body because the controller patch targets no longer map cleanly to CFG nodes (example log output: target pc … not found in CFG), and the traversal ends early.

Observed failures / flakes

When traversal finds zero eligible controllers, i addded a fallback that picks any controller as setter/checker and this breaks tests depending on call order. Example from e2e::test_counter::test_obfuscated_counter_deploys_and_counts

Log snippet:

StorageGates: traversal found 0 eligible controllers, but 2 state-mutating blocks exist; using fallback heuristic
StorageGates: gating selector 0xd09de08a with setter 0x3fb5c1cb

Here, increment() became checker, setNumber() setter. The test calls increment() before setNumber(), so it reverts (increment() reverted: 0x). This flakiness is random because pairing depends on RNG; running the same test multiple times flips pass/fail.

Why pre‑dispatcher metadata isn’t a good fix

Using selector→entry mapping captured before FunctionDispatcher would ignore obfuscation noise and defeat the purpose of routing/decoys. It would make StorageGates “see through” the obfuscation layer, which is not acceptable.

What do we need to make this work

  • Post‑dispatcher analysis that treats the obfuscated dispatcher as baseline:
    • Stack‑aware jump target recovery inside controllers/stubs (handle PUSH, PUSH+PUSH+ADD, etc.).
    • Traverse the recovered control‑flow graph to find reachable mutating opcodes
    • Only then classify controllers as eligible.

Conclusion

StorageGates is on hold because without robust post‑dispatcher tracing, it either: no‑ops (skips), or randomly gates and breaks call order. We should revisit this later

@g4titanx g4titanx force-pushed the transforms/storage_gates branch from bac9e5a to b4e8dec Compare January 23, 2026 04:55
@g4titanx
Copy link
Member Author

g4titanx commented Jan 23, 2026

earlier i mentioned that StorageGates couldn't trace through obfuscated dispatcher chains after FunctionDispatcher ran. the traversal-based detection failed to find function bodies, leading to no-op or broken gating.

so i added a gate policy and it solves most of the issue but because we are randomly selecting which selector is the setter or getter, it has made the transform flaky, we need to fix this, currently thinking of the best way to solve this, because once we do, it solves so many other issues we might have with transforms. the idea of a vm has crossed my mind too

Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Reviewers

No reviews

Assignees

No one assigned

Labels

None yet

Projects

None yet

Milestone

No milestone

Development

Successfully merging this pull request may close these issues.

2 participants

@g4titanx