@inco/lightning 0.8.0-devnet-8 → 0.8.0-devnet-10

package/src/lightning-parts/test/Elist.t.sol

@@ -0,0 +1,67 @@
+// SPDX-License-Identifier: No License
+pragma solidity ^0.8;
+
+import {IncoTest} from "../../test/IncoTest.sol";
+import {ElistTester} from "../../test/EListTester.sol";
+import {inco, e} from "../../Lib.sol";
+import {ETypes, elist} from "../../Types.sol";
+import {FEE, Fee} from "../Fee.sol";
+import {EList} from "../EList.sol";
+import {VerifierAddressGetter} from "../primitives/VerifierAddressGetter.sol";
+
+contract ElistFeeTester is EList {
+
+    constructor() VerifierAddressGetter(address(0)) {}
+
+}
+
+contract TestEList is IncoTest {
+
+    ElistTester tester;
+    ElistFeeTester feeTester;
+
+    function setUp() public virtual override {
+        super.setUp();
+        tester = new ElistTester(inco);
+        vm.deal(address(tester), 1 ether);
+        feeTester = new ElistFeeTester();
+    }
+
+    function testNewElistFromInputs() public {
+        createList();
+        // todo test read the created list
+    }
+
+    function testListAppend() public {
+        createList();
+        bytes memory ctValue = fakePrepareEuint256Ciphertext(40, address(this), address(tester));
+        tester.listAppend(ctValue);
+    }
+
+    function createList() internal returns (elist list) {
+        bytes[] memory inputs = new bytes[](3);
+        inputs[0] = fakePrepareEuint256Ciphertext(10, address(this), address(tester));
+        inputs[1] = fakePrepareEuint256Ciphertext(20, address(this), address(tester));
+        inputs[2] = fakePrepareEuint256Ciphertext(30, address(this), address(tester));
+        list = tester.newEList(inputs, ETypes.Uint256, address(this));
+    }
+
+    function testRevertsOnBadFeeAmount() public {
+        // should fail if no fee
+        vm.expectRevert(Fee.FeeNotPaid.selector);
+        feeTester.listShuffle(elist.wrap(bytes32(0)));
+
+        // should fail if not enough fee
+        vm.expectRevert(Fee.FeeNotPaid.selector);
+        feeTester.listShuffle{value: FEE - 1}(elist.wrap(bytes32(0)));
+
+        // should fail if too much fee
+        vm.expectRevert(Fee.FeeNotPaid.selector);
+        feeTester.listShuffle{value: FEE + 1}(elist.wrap(bytes32(0)));
+
+        vm.expectRevert(Fee.FeeNotPaid.selector);
+        bytes[] memory inputs = new bytes[](3);
+        feeTester.newEList{value: FEE * 2}(inputs, ETypes.Uint256, address(this));
+    }
+
+}

package/src/misc/ABIHelper.sol

@@ -0,0 +1,15 @@
+// SPDX-License-Identifier: No License
+pragma solidity ^0.8;
+
+import {Session} from "@inco/lightning/src/periphery/SessionVerifier.sol";
+
+// @dev this contract is not used on-chain, it is only used to generate the
+// ABI of some symbols that are not exposed directly by the IncoLightning or
+// periphery contracts, but are needed for the JS SDK.
+contract ABIHelper {
+
+    function getSession() public pure returns (Session memory) {
+        revert("This function exists only to include Session struct in ABI");
+    }
+
+}

package/src/pasted-dependencies/ICreateX.sol

@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: AGPL-3.0-only
-pragma solidity ^0.8.4;
+pragma solidity ^0.8;
 
 /**
  * @title CreateX Factory Interface Definition

package/src/periphery/SessionVerifier.sol

@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: No License
-pragma solidity ^0.8;
+pragma solidity ^0.8.29;
 
 import {UUPSUpgradeable} from "@openzeppelin/contracts/proxy/utils/UUPSUpgradeable.sol";
 import {OwnableUpgradeable} from "@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol";
@@ -38,13 +38,13 @@ struct Session {
 contract SessionVerifier is UUPSUpgradeable, OwnableUpgradeable, Version {
 
     /// @notice Initializes the SessionVerifier with version information
-    /// @param salt Unique salt used for deterministic deployment via CreateX
-    constructor(bytes32 salt)
+    /// @param _salt Unique salt used for deterministic deployment via CreateX
+    constructor(bytes32 _salt)
         Version(
             SESSION_VERIFIER_MAJOR_VERSION,
             SESSION_VERIFIER_MINOR_VERSION,
             SESSION_VERIFIER_PATCH_VERSION,
-            salt,
+            _salt,
             SESSION_VERIFIER_NAME
         )
     {}

package/src/shared/IOwnable.sol

@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: MIT
-pragma solidity ^0.8.0;
+pragma solidity ^0.8;
 
 // OpenZeppelin doesn't export any interfaces for ownable so we define our own
 

package/src/shared/IUUPSUpgradable.sol

@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: MIT
-pragma solidity ^0.8.0;
+pragma solidity ^0.8;
 
 // OpenZeppelin doesn't export any interfaces for uupsUpgradeable so we define our own
 

package/src/shared/TestUtils.sol

@@ -3,8 +3,13 @@ pragma solidity ^0.8;
 
 import {Test} from "forge-std/Test.sol";
 
+/// @title TestUtils
+/// @notice WARNING: This contract contains TEST KEYS for LOCAL DEVELOPMENT ONLY.
+/// @dev These keys are publicly known Anvil accounts and have NO security value.
+///      NEVER use these keys on production networks - anyone can derive the private keys.
 contract TestUtils is Test {
 
+    // WARNING: Well-known Anvil account #0 - publicly known private key, DO NOT use in production
     address private constant ANVIL_ZEROTH_ADDRESS = 0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266;
     uint256 private constant ANVIL_ZEROTH_PRIVATE_KEY =
         0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80;
@@ -20,7 +25,9 @@ contract TestUtils is Test {
     uint256 internal evePrivKey;
     address internal immutable eve;
 
-    // it is convenient for e2e tests to use these well-known addresses for the TEE
+    // WARNING: These are well-known Anvil test keys with publicly known private keys.
+    // They are convenient for e2e tests but have NO security value.
+    // Deploy.s.sol has safeguards to prevent using these on non-test chains.
     address internal teeEOA = ANVIL_ZEROTH_ADDRESS;
     uint256 internal teePrivKey = ANVIL_ZEROTH_PRIVATE_KEY;
 

package/src/test/EListTester.sol

@@ -0,0 +1,148 @@
+// SPDX-License-Identifier: No License
+pragma solidity ^0.8;
+
+import {IIncoLightning} from "../interfaces/IIncoLightning.sol";
+/// forge-lint: disable-next-line(unused-import)
+import {ETypes, elist} from "../Types.sol";
+import {euint256} from "../Types.sol";
+import {IncoUtils, FEE} from "../periphery/IncoUtils.sol";
+
+contract ElistTester is IncoUtils {
+
+    /// forge-lint: disable-next-line(screaming-snake-case-immutable)
+    IIncoLightning immutable inco;
+
+    constructor(IIncoLightning _inco) {
+        inco = _inco;
+    }
+
+    elist public list;
+    elist public newRangeList;
+
+    function newEList(bytes[] memory inputs, ETypes listType, address user)
+        public
+        payable
+        refundUnspent
+        returns (elist)
+    {
+        list = inco.newEList{value: FEE * inputs.length}(inputs, listType, user);
+        inco.allow(elist.unwrap(list), address(this));
+        inco.allow(elist.unwrap(list), address(msg.sender));
+        return list;
+    }
+
+    function listAppend(bytes memory ctValue) public payable refundUnspent returns (elist) {
+        euint256 handle = inco.newEuint256{value: FEE}(ctValue, msg.sender);
+        inco.allow(euint256.unwrap(handle), address(this));
+        inco.allow(euint256.unwrap(handle), address(msg.sender));
+        list = inco.listAppend(list, euint256.unwrap(handle));
+        inco.allow(elist.unwrap(list), address(this));
+        inco.allow(elist.unwrap(list), address(msg.sender));
+        return list;
+    }
+
+    function listGet(uint16 index) public returns (bytes32) {
+        bytes32 res = inco.listGet(list, index);
+        inco.allow(res, msg.sender);
+        return res;
+    }
+
+    function newEList(bytes32[] memory handles, ETypes listType) public payable refundUnspent returns (elist) {
+        list = inco.newEList(handles, listType);
+        inco.allow(elist.unwrap(list), address(this));
+        inco.allow(elist.unwrap(list), address(msg.sender));
+        return list;
+    }
+
+    function listGetOr(bytes memory ctIndex, bytes memory ctDefaultValue)
+        public
+        payable
+        refundUnspent
+        returns (bytes32)
+    {
+        euint256 index = inco.newEuint256{value: FEE}(ctIndex, msg.sender);
+        euint256 defaultValue = inco.newEuint256{value: FEE}(ctDefaultValue, msg.sender);
+        bytes32 res = inco.listGetOr(list, euint256.unwrap(index), euint256.unwrap(defaultValue));
+        inco.allow(res, msg.sender);
+        return res;
+    }
+
+    function listSet(bytes memory ctIndex, bytes memory ctValue) public payable refundUnspent returns (elist) {
+        euint256 index = inco.newEuint256{value: FEE}(ctIndex, msg.sender);
+        euint256 value = inco.newEuint256{value: FEE}(ctValue, msg.sender);
+        list = inco.listSet(list, euint256.unwrap(index), euint256.unwrap(value));
+        inco.allow(elist.unwrap(list), address(this));
+        inco.allow(elist.unwrap(list), address(msg.sender));
+        return list;
+    }
+
+    function listInsert(bytes memory ctIndex, bytes memory ctValue) public payable refundUnspent returns (elist) {
+        euint256 index = inco.newEuint256{value: FEE}(ctIndex, msg.sender);
+        euint256 value = inco.newEuint256{value: FEE}(ctValue, msg.sender);
+        list = inco.listInsert(list, euint256.unwrap(index), euint256.unwrap(value));
+        inco.allow(elist.unwrap(list), address(this));
+        inco.allow(elist.unwrap(list), address(msg.sender));
+        return list;
+    }
+
+    function listConcat(bytes[] memory cts, ETypes listType, address user)
+        public
+        payable
+        refundUnspent
+        returns (elist)
+    {
+        elist rhs = inco.newEList{value: FEE * cts.length}(cts, listType, user);
+        inco.allow(elist.unwrap(rhs), address(this));
+        inco.allow(elist.unwrap(rhs), address(msg.sender));
+        list = inco.listConcat(list, rhs);
+        inco.allow(elist.unwrap(list), address(this));
+        inco.allow(elist.unwrap(list), address(msg.sender));
+        return list;
+    }
+
+    function listSlice(bytes memory ctStart, uint16 len, bytes memory ctDefaultValue)
+        public
+        payable
+        refundUnspent
+        returns (elist)
+    {
+        euint256 start = inco.newEuint256{value: FEE}(ctStart, msg.sender);
+        euint256 defaultValue = inco.newEuint256{value: FEE}(ctDefaultValue, msg.sender);
+        list = inco.listSlice(list, euint256.unwrap(start), len, euint256.unwrap(defaultValue));
+        inco.allow(elist.unwrap(list), address(this));
+        inco.allow(elist.unwrap(list), address(msg.sender));
+        return list;
+    }
+
+    function listRange(uint16 start, uint16 end) public returns (elist) {
+        newRangeList = inco.listRange(start, end);
+        inco.allow(elist.unwrap(newRangeList), address(this));
+        inco.allow(elist.unwrap(newRangeList), address(msg.sender));
+        return newRangeList;
+    }
+
+    function listGetRange(uint16 index) public returns (bytes32) {
+        bytes32 res = inco.listGet(newRangeList, index);
+        inco.allow(res, msg.sender);
+        return res;
+    }
+
+    function listShuffle() public payable refundUnspent returns (elist) {
+        list = inco.listShuffle{value: FEE}(list);
+        inco.allow(elist.unwrap(list), address(this));
+        inco.allow(elist.unwrap(list), address(msg.sender));
+        return list;
+    }
+
+    function listReverse() public returns (elist) {
+        list = inco.listReverse(list);
+        inco.allow(elist.unwrap(list), address(this));
+        inco.allow(elist.unwrap(list), address(msg.sender));
+        return list;
+    }
+
+    receive() external payable {
+        // Allow contract to receive ETH
+    }
+
+}

package/src/test/TEELifecycle/TEELifecycleMockTest.t.sol

@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: UNLICENSED
-pragma solidity ^0.8.0;
+pragma solidity ^0.8;
 
 import {TEELifecycle} from "../../lightning-parts/TEELifecycle.sol";
 import {BootstrapResult, AddNodeResult, UpgradeResult} from "../../lightning-parts/TEELifecycle.types.sol";

package/src/test/TestUpgrade.t.sol

@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: No License
-pragma solidity ^0.8.20;
+pragma solidity ^0.8;
 
 import {Strings} from "@openzeppelin/contracts/utils/Strings.sol";
 import {Safe} from "safe-smart-account/Safe.sol";

package/src/version/IncoLightningConfig.sol

@@ -7,7 +7,7 @@ pragma solidity ^0.8;
 // UPDATE the CHANGELOG on new versions
 
 string constant CONTRACT_NAME = "incoLightning";
-uint8 constant MAJOR_VERSION = 4;
+uint8 constant MAJOR_VERSION = 6;
 uint8 constant MINOR_VERSION = 0;
 // whenever a new version is deployed, we need to pump this up
 // otherwise make test_upgrade will fail