all: convert to geas-ffi

Author: lightclient

.gitignore

@@ -1,3 +1,2 @@
 cache/
 out/
-test/*.t.sol

foundry.toml

@@ -1,4 +1,6 @@
 [profile.default]
+evm_version = 'prague'
 src = 'src'
 out = 'out'
+ffi = true
 libs = ['lib']

test/BeaconRoot.t.sol.in renamed to test/BeaconRoot.t.sol

@@ -2,9 +2,10 @@
 pragma solidity ^0.8.13;
 
 import "forge-std/Test.sol";
+import "geas-ffi/Geas.sol";
 import "../src/Contract.sol";
 
-address constant addr = 0x000000000000000000000000000000000000000b;
+address constant addr = 0x0000000000000000000000000000000000000bBB;
 address constant sysaddr = 0xffffFFFfFFffffffffffffffFfFFFfffFFFfFFfE;
 uint256 constant buflen = 8191;
 bytes32 constant root    = hex"88e96d4537bea4d9c05d12549907b32561d3bf31f45aae734cdc119f13406cb6";
@@ -25,7 +26,7 @@ contract ContractTest is Test {
     address unit;
 
     function setUp() public {
-        vm.etch(addr, hex"@bytecode@");
+        vm.etch(addr, Geas.compile("src/beacon_root/main.eas"));
         unit = addr;
     }
 

test/Consolidation.t.sol.in renamed to test/Consolidation.t.sol

@@ -1,6 +1,7 @@
 // SPDX-License-Identifier: UNLICENSED
 pragma solidity ^0.8.13;
 
+import "geas-ffi/Geas.sol";
 import "./Test.sol";
 
 uint256 constant target_per_block = 1;
@@ -10,8 +11,8 @@ uint256 constant inhibitor = uint256(bytes32(0xfffffffffffffffffffffffffffffffff
 contract ConsolidationTest is Test {
 
   function setUp() public {
-    vm.etch(addr, hex"@bytecode@");
-    vm.etch(fakeExpo, hex"@bytecode_expo@");
+    vm.etch(addr, Geas.compile("src/consolidations/main.eas"));
+    vm.etch(fakeExpo, Geas.compile("src/common/fake_expo_test.eas"));
   }
 
   // testInvalidRequest checks that common invalid requests are rejected.

test/ExecutionHash.t.sol.in renamed to test/ExecutionHash.t.sol

@@ -2,6 +2,7 @@
 pragma solidity ^0.8.13;
 
 import "forge-std/Test.sol";
+import "geas-ffi/Geas.sol";
 import "../src/Contract.sol";
 
 address constant addr = 0x000000000000000000000000000000000000aaaa;
@@ -18,40 +19,37 @@ function hash_idx() view returns (bytes32) {
 }
 
 contract ContractTest is Test {
-    address unit;
-
     function setUp() public {
-        vm.etch(addr, hex"@bytecode@");
-        unit = addr;
+        vm.etch(addr, Geas.compile("src/execution_hash/main.eas"));
     }
 
     // testRead verifies the contract returns the expected execution hash.
     function testExecRead() public {
         // Store hash at expected indexes.
-        vm.store(unit, hash_idx(), hash);
+        vm.store(addr, hash_idx(), hash);
 
         // Read hash associated with current timestamp.
-        (bool ret, bytes memory data) = unit.call(bytes.concat(lastBlockNumber()));
+        (bool ret, bytes memory data) = addr.call(bytes.concat(lastBlockNumber()));
         assertTrue(ret);
         assertEq(data, bytes.concat(hash));
     }
 
     function testReadBadCalldataSize() public {
         // Store hash at expected indexes.
-        vm.store(unit, hash_idx(), hash);
+        vm.store(addr, hash_idx(), hash);
 
         // Call with 0 byte arguement.
-        (bool ret, bytes memory data) = unit.call(hex"");
+        (bool ret, bytes memory data) = addr.call(hex"");
         assertFalse(ret);
         assertEq(data, hex"");
 
         // Call with 31 byte arguement.
-        (ret, data) = unit.call(hex"00000000000000000000000000000000000000000000000000000000001337");
+        (ret, data) = addr.call(hex"00000000000000000000000000000000000000000000000000000000001337");
         assertFalse(ret);
         assertEq(data, hex"");
 
         // Call with 33 byte arguement.
-        (ret, data) = unit.call(hex"000000000000000000000000000000000000000000000000000000000000001337");
+        (ret, data) = addr.call(hex"000000000000000000000000000000000000000000000000000000000000001337");
         assertFalse(ret);
         assertEq(data, hex"");
     }
@@ -62,25 +60,25 @@ contract ContractTest is Test {
         uint256 number = block.number-1;
 
         // Store hash at expected indexes.
-        vm.store(unit, hash_idx(), hash);
+        vm.store(addr, hash_idx(), hash);
 
         // Request current block.
-        (bool ret, bytes memory data) = unit.call(bytes.concat(bytes32(block.number)));
+        (bool ret, bytes memory data) = addr.call(bytes.concat(bytes32(block.number)));
         assertFalse(ret);
         assertEq(data, hex"");
 
         // Wrap around buflen once forward.
-        (ret, data) = unit.call(bytes.concat(bytes32(number+buflen)));
+        (ret, data) = addr.call(bytes.concat(bytes32(number+buflen)));
         assertFalse(ret);
         assertEq(data, hex"");
 
         // Wrap around buflen once backward.
-        (ret, data) = unit.call(bytes.concat(bytes32(number-buflen)));
+        (ret, data) = addr.call(bytes.concat(bytes32(number-buflen)));
         assertFalse(ret);
         assertEq(data, hex"");
 
         // Block number zero should fail.
-        (ret, data) = unit.call(bytes.concat(bytes32(0)));
+        (ret, data) = addr.call(bytes.concat(bytes32(0)));
         assertFalse(ret);
         assertEq(data, hex"");
     }
@@ -89,12 +87,12 @@ contract ContractTest is Test {
     function testUpdate() public {
         // Simulate pre-block call to set hash.
         vm.prank(sysaddr);
-        (bool ret, bytes memory data) = unit.call(bytes.concat(hash));
+        (bool ret, bytes memory data) = addr.call(bytes.concat(hash));
         assertTrue(ret);
         assertEq(data, hex"");
 
         // Verify hash.
-        bytes32 got = vm.load(unit, hash_idx());
+        bytes32 got = vm.load(addr, hash_idx());
         assertEq(got, hash);
     }
 
@@ -110,13 +108,13 @@ contract ContractTest is Test {
 
             // Simulate pre-block call to set hash.
             vm.prank(sysaddr);
-            (bool ret, bytes memory data) = unit.call(bytes.concat(pbbr));
+            (bool ret, bytes memory data) = addr.call(bytes.concat(pbbr));
             assertTrue(ret);
             assertEq(data, hex"");
 
             // Call contract as normal account to get exeuction hash associated
             // with current timestamp.
-            (ret, data) = unit.call(bytes.concat(lastBlockNumber()));
+            (ret, data) = addr.call(bytes.concat(lastBlockNumber()));
             assertTrue(ret);
             assertEq(data, bytes.concat(pbbr));
 
@@ -136,7 +134,7 @@ contract ContractTest is Test {
         for (uint256 i = 0; i < buflen; i += 1) {
             bytes32 pbbr = bytes32(i*1337);
             vm.prank(sysaddr);
-            (bool ret, bytes memory data) = unit.call(bytes.concat(pbbr));
+            (bool ret, bytes memory data) = addr.call(bytes.concat(pbbr));
             assertTrue(ret);
             assertEq(data, hex"");
             if (i+1 < buflen) {
@@ -152,7 +150,7 @@ contract ContractTest is Test {
         // Attempt to read all values in same block context.
         for (uint256 i = 0; i < buflen; i += 1) {
             bytes32 num = bytes32(uint256(base+i));
-            (bool ret, bytes memory got) = unit.call(bytes.concat(num));
+            (bool ret, bytes memory got) = addr.call(bytes.concat(num));
             assertTrue(ret);
             assertEq(got, bytes.concat(bytes32(i*1337)));
         }

test/FakeExpo.t.sol.in renamed to test/FakeExpo.t.sol

@@ -1,11 +1,12 @@
 // SPDX-License-Identifier: UNLICENSED
 pragma solidity ^0.8.13;
 
+import "geas-ffi/Geas.sol";
 import "./Test.sol";
 
 contract FakeExpoTest is Test {
   function setUp() public {
-    vm.etch(fakeExpo, hex"@bytecode@");
+    vm.etch(fakeExpo, Geas.compile("src/common/fake_expo_test.eas"));
   }
 
   // testFakeExpo calls the fake exponentiation logic with specific values.

test/Withdrawal.t.sol.in renamed to test/Withdrawal.t.sol

@@ -1,19 +1,17 @@
 // SPDX-License-Identifier: UNLICENSED
 pragma solidity ^0.8.13;
 
+import "geas-ffi/Geas.sol";
 import "./Test.sol";
 
 uint256 constant target_per_block = 2;
 uint256 constant max_per_block = 16;
 uint256 constant inhibitor = uint256(bytes32(0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff));
 
 contract WithdrawalsTest is Test {
-  address unit;
-
   function setUp() public {
-    vm.etch(addr, hex"@bytecode@");
-    vm.etch(fakeExpo, hex"@bytecode_expo@");
-    unit = addr;
+    vm.etch(addr, Geas.compile("src/withdrawals/main.eas"));
+    vm.etch(fakeExpo, Geas.compile("src/common/fake_expo_test.eas"));
   }
 
   // testInvalidWithdrawal checks that common invalid withdrawal requests are rejected.