@inco/lightning 0.1.20

package/src/test/IncoTest.sol

@@ -0,0 +1,48 @@
+// SPDX-License-Identifier: No License
+pragma solidity ^0.8;
+
+import {MockOpHandler} from "./FakeIncoInfra/MockOpHandler.sol";
+import {IncoLightning} from "../IncoLightning.sol";
+import {inco} from "../Lib.sol";
+import {DeployUtils} from "../DeployUtils.sol";
+import {deployedBy} from "../Lib.sol";
+import {console} from "forge-std/console.sol";
+
+contract IncoTest is MockOpHandler, DeployUtils {
+    address immutable owner;
+    address immutable testDeployer;
+
+    constructor() {
+        owner = getLabeledAddress("owner");
+        // extracted from the deploy script running as bare simulation with:
+        //  forge script src/script/Deploy.s.sol:Deploy
+        testDeployer = deployedBy;
+        vm.label(testDeployer, "testDeployer");
+        vm.label(address(this), "testRunner");
+        vm.label(address(inco), "inco");
+    }
+
+    function setUp() public virtual {
+        deployCreateX();
+        vm.startPrank(testDeployer);
+        IncoLightning proxy = deployIncoLightningUsingConfig({
+            deployer: testDeployer,
+            pepper: ""
+        });
+        proxy.transferOwnership(owner);
+        vm.stopPrank();
+        console.log(
+            "Deployed %s (proxy) to: %s",
+            proxy.getName(),
+            address(proxy)
+        );
+        console.log("Generated inco address: %s", address(inco));
+        require(
+            address(proxy) == address(inco),
+            "hardcoded inco address does not match proxy deployed in test setup"
+        );
+        vm.prank(owner);
+        inco.editPubkeyAddress(teePubkeyAddress);
+        vm.recordLogs();
+    }
+}

package/src/test/TestAddTwo.t.sol

@@ -0,0 +1,31 @@
+// SPDX-License-Identifier: No License
+pragma solidity ^0.8;
+
+import {e, euint256} from "../Lib.sol";
+import {IncoTest} from "./IncoTest.sol";
+import {AddTwo} from "./AddTwo.sol";
+
+contract TestAddTwo is IncoTest {
+    using e for euint256;
+    using e for uint256;
+
+    function testAddTwo() public {
+        AddTwo addTwo = new AddTwo();
+        vm.label(address(addTwo), "addTwo");
+        euint256 a = e.asEuint256(3);
+        a.allow(address(addTwo));
+        euint256 b = addTwo.addTwo(a);
+        processAllOperations();
+        assertEq(getUint256Value(b), 5);
+    }
+
+    function testAddTwoScalar() public {
+        AddTwo addTwo = new AddTwo();
+        vm.label(address(addTwo), "addTwoScalar");
+        euint256 a = e.asEuint256(3);
+        a.allow(address(addTwo));
+        euint256 b = addTwo.addTwoScalar(a);
+        processAllOperations();
+        assertEq(getUint256Value(b), 5);
+    }
+}

package/src/test/TestDeploy.t.sol

@@ -0,0 +1,39 @@
+// SPDX-License-Identifier: No License
+pragma solidity ^0.8;
+
+import {Test} from "forge-std/Test.sol";
+import {TrivialEncryption} from "../lightning-parts/TrivialEncryption.sol";
+import {ETypes} from "../Types.sol";
+import {UUPSUpgradeable} from "@openzeppelin/contracts/proxy/utils/UUPSUpgradeable.sol";
+import {inco} from "../Lib.sol";
+import {IncoTest} from "./IncoTest.sol";
+
+contract ReturnTwo is UUPSUpgradeable {
+    function getTwo() external pure returns (uint256) {
+        return 2;
+    }
+
+    function _authorizeUpgrade(address) internal override {}
+}
+
+contract TestDeploy is Test, IncoTest {
+    // todo test that inco gets deployed at the predicted address
+
+    function testDeployedCorrectly() public {
+        vm.expectEmit(false, false, true, false, address(inco));
+        emit TrivialEncryption.TrivialEncrypt(
+            bytes32(uint256(1)),
+            bytes32(uint256(1)),
+            ETypes.Bool,
+            0
+        );
+        inco.asEbool(true);
+    }
+
+    function testUpgrade() public {
+        ReturnTwo newImplem = new ReturnTwo();
+        vm.prank(owner);
+        inco.upgradeToAndCall(address(newImplem), "");
+        assertEq(ReturnTwo(address(inco)).getTwo(), 2);
+    }
+}

package/src/test/TestExtractDataOfEventTooLarge.t.sol

@@ -0,0 +1,43 @@
+// SPDX-License-Identifier: No License
+pragma solidity ^0.8;
+
+import {Test, Vm, console} from "forge-std/Test.sol";
+
+event EventTooLarge(
+    bytes32 control, // can't index >3 fields
+    bytes32 indexed ifTrue,
+    bytes32 indexed ifFalse,
+    bytes32 indexed result,
+    uint256 eventId
+);
+
+contract Emitter {
+    function emitEventTooLarge() external {
+        emit EventTooLarge(
+            bytes32(uint256(1)),
+            bytes32(uint256(2)),
+            bytes32(uint256(3)),
+            bytes32(uint256(4)),
+            5
+        );
+    }
+}
+
+contract TestExtractDataOfEventTooLarge is Test {
+    function testEmit() public {
+        Emitter emitter = new Emitter();
+        vm.recordLogs();
+        emitter.emitEventTooLarge();
+        Vm.Log[] memory logs = vm.getRecordedLogs();
+        console.logBytes(logs[0].data);
+        bytes32 first32Bytes;
+        bytes32 second32Bytes;
+        bytes memory logData = logs[0].data;
+        assembly {
+            first32Bytes := mload(add(logData, 0x20))
+            second32Bytes := mload(add(logData, 0x40))
+        }
+        assertEq(first32Bytes, bytes32(uint256(1)));
+        assertEq(second32Bytes, bytes32(uint256(5)));
+    }
+}

package/src/test/TestFakeInfra.t.sol

@@ -0,0 +1,301 @@
+// SPDX-License-Identifier: No License
+pragma solidity ^0.8;
+
+import {IncoTest} from "./IncoTest.sol";
+import {e, euint256, ebool} from "../Lib.sol";
+import {SenderNotAllowedForHandle} from "../Types.sol";
+
+contract TakesEInput {
+    using e for bytes;
+    using e for euint256;
+
+    euint256 public a;
+    ebool public b;
+    uint256 public decryptedA;
+
+    function setA(bytes memory uint256EInput) external {
+        a = uint256EInput.newEuint256(msg.sender);
+        a.allowThis();
+    }
+
+    function setB(bytes memory boolEInput) external {
+        b = boolEInput.newEbool(msg.sender);
+    }
+
+    function decryptA() external {
+        a.requestDecryption(this.aDecryptionCallback.selector, "");
+    }
+
+    function aDecryptionCallback(
+        uint256,
+        uint256 _decryptedA,
+        bytes memory
+    ) external {
+        decryptedA = _decryptedA;
+    }
+}
+
+// its meta: this is testing correct behavior of our testing infrastructure
+contract TestFakeInfra is IncoTest {
+    using e for euint256;
+    using e for ebool;
+    using e for uint256;
+    using e for bool;
+
+    function testTrivialEncrypt() public {
+        euint256 a = e.asEuint256(3);
+        assertEq(getUint256Value(a), 0); // operations not processed yet
+        processAllOperations();
+        assertEq(getUint256Value(a), 3);
+        ebool b = e.asEbool(true);
+        processAllOperations();
+        assertEq(getBoolValue(b), true);
+    }
+
+    function testEAdd() public {
+        euint256 a = e.asEuint256(3);
+        euint256 b = e.asEuint256(4);
+        euint256 c = a.add(b);
+        processAllOperations();
+        assertEq(getUint256Value(c), 7);
+    }
+
+    function testEAddScalar() public {
+        euint256 a = e.asEuint256(3);
+        euint256 c = a.add(uint256(4));
+        euint256 c256 = uint256(4).add(a);
+        processAllOperations();
+        assertEq(getUint256Value(c), 7);
+        assertEq(getUint256Value(c256), 7);
+    }
+
+    function testESub() public {
+        euint256 a = e.asEuint256(10);
+        euint256 b = e.asEuint256(4);
+        euint256 c = a.sub(b);
+        processAllOperations();
+        assertEq(getUint256Value(c), 6);
+    }
+
+    function testEMul() public {
+        euint256 a = e.asEuint256(10);
+        euint256 b = e.asEuint256(4);
+        euint256 c = a.mul(b);
+        processAllOperations();
+        assertEq(getUint256Value(c), 40);
+    }
+
+    function testEDiv() public {
+        euint256 a = e.asEuint256(10);
+        euint256 b = e.asEuint256(4);
+        euint256 c = a.div(b);
+        processAllOperations();
+        assertEq(getUint256Value(c), 2);
+    }
+
+    function testERem() public {
+        euint256 a = e.asEuint256(10);
+        euint256 b = e.asEuint256(4);
+        euint256 c = a.rem(b);
+        processAllOperations();
+        assertEq(getUint256Value(c), 2);
+    }
+
+    function testEAnd() public {
+        euint256 a = e.asEuint256(10);
+        euint256 b = e.asEuint256(4);
+        euint256 c = a.and(b);
+        processAllOperations();
+        assertEq(getUint256Value(c), 0);
+    }
+
+    function testEOr() public {
+        euint256 a = e.asEuint256(10);
+        euint256 b = e.asEuint256(4);
+        euint256 c = a.or(b);
+        processAllOperations();
+        assertEq(getUint256Value(c), 14);
+    }
+
+    function testEXor() public {
+        euint256 a = e.asEuint256(10);
+        euint256 b = e.asEuint256(4);
+        euint256 c = a.xor(b);
+        processAllOperations();
+        assertEq(getUint256Value(c), 14);
+    }
+
+    function testEShl() public {
+        euint256 a = e.asEuint256(10);
+        euint256 b = e.asEuint256(4);
+        euint256 c = a.shl(b);
+        processAllOperations();
+        assertEq(getUint256Value(c), 160);
+    }
+
+    function testEShr() public {
+        euint256 a = e.asEuint256(10);
+        euint256 b = e.asEuint256(4);
+        euint256 c = a.xor(b);
+        processAllOperations();
+        assertEq(getUint256Value(c), 14);
+    }
+
+    function testERotl() public {
+        euint256 a = e.asEuint256(10);
+        euint256 b = e.asEuint256(4);
+        euint256 c = a.rotl(b);
+        processAllOperations();
+        assertEq(getUint256Value(c), 160);
+    }
+
+    function testERotr() public {
+        euint256 a = e.asEuint256(10);
+        euint256 b = e.asEuint256(4);
+        euint256 c = a.rotr(b);
+        processAllOperations();
+        assertEq(
+            getUint256Value(c),
+            72370055773322622139731865630429942408293740416025352524660990004945706024960
+        );
+    }
+
+    function testEEq() public {
+        euint256 a = e.asEuint256(10);
+        euint256 b = e.asEuint256(4);
+        ebool c = a.eq(b);
+        processAllOperations();
+        assertEq(getBoolValue(c), false);
+    }
+
+    function testENe() public {
+        euint256 a = e.asEuint256(10);
+        euint256 b = e.asEuint256(4);
+        ebool c = a.ne(b);
+        processAllOperations();
+        assertEq(getBoolValue(c), true);
+    }
+
+    function testEGe() public {
+        euint256 a = e.asEuint256(10);
+        euint256 b = e.asEuint256(4);
+        ebool c = a.ge(b);
+        processAllOperations();
+        assertEq(getBoolValue(c), true);
+    }
+
+    function testEGt() public {
+        euint256 a = e.asEuint256(10);
+        euint256 b = e.asEuint256(4);
+        ebool c = a.gt(b);
+        processAllOperations();
+        assertEq(getBoolValue(c), true);
+    }
+
+    function testELe() public {
+        euint256 a = e.asEuint256(10);
+        euint256 b = e.asEuint256(4);
+        ebool c = a.le(b);
+        processAllOperations();
+        assertEq(getBoolValue(c), false);
+    }
+
+    function testELt() public {
+        euint256 a = e.asEuint256(10);
+        euint256 b = e.asEuint256(4);
+        ebool c = a.lt(b);
+        processAllOperations();
+        assertEq(getBoolValue(c), false);
+    }
+
+    function testEMin() public {
+        euint256 a = e.asEuint256(10);
+        euint256 b = e.asEuint256(4);
+        euint256 c = a.min(b);
+        processAllOperations();
+        assertEq(getUint256Value(c), 4);
+    }
+
+    function testEMax() public {
+        euint256 a = e.asEuint256(10);
+        euint256 b = e.asEuint256(4);
+        euint256 c = a.max(b);
+        processAllOperations();
+        assertEq(getUint256Value(c), 10);
+    }
+
+    function testENot() public {
+        ebool a = e.asEbool(true);
+        ebool b = a.not();
+        processAllOperations();
+        assertEq(getBoolValue(b), false);
+    }
+
+    function testERand() public {
+        euint256 a = e.rand();
+        processAllOperations();
+        assertEq(getUint256Value(a), 1);
+    }
+
+    function testERandBounded() public {
+        euint256 a = e.randBounded(10);
+        processAllOperations();
+        assertEq(getUint256Value(a), 1);
+    }
+
+    function testEIfThenElse() public {
+        ebool controlA = e.asEbool(true);
+        ebool controlB = e.asEbool(false);
+        euint256 a = e.asEuint256(10);
+        euint256 b = e.asEuint256(4);
+        euint256 resA = controlA.select(a, b);
+        euint256 resB = controlB.select(a, b);
+        processAllOperations();
+        assertEq(getUint256Value(resA), 10);
+        assertEq(getUint256Value(resB), 4);
+    }
+
+    function testECastToEBool() public {
+        euint256 a = e.asEuint256(1);
+        ebool b = a.asEbool();
+        processAllOperations();
+        assertEq(getBoolValue(b), true);
+    }
+
+    function testECastToFromEBool() public {
+        ebool a = e.asEbool(true);
+        euint256 b = a.asEuint256();
+        processAllOperations();
+        assertEq(getUint256Value(b), 1);
+    }
+
+    function testEInput() public {
+        TakesEInput inputContract = new TakesEInput();
+        inputContract.setA(fakePrepareEuint256Ciphertext(12));
+        inputContract.setB(fakePrepareEboolCiphertext(true));
+        processAllOperations();
+        assertEq(getUint256Value(inputContract.a()), 12);
+        assertEq(getBoolValue(inputContract.b()), true);
+    }
+
+    function testDecryption() public {
+        TakesEInput inputContract = new TakesEInput();
+        inputContract.setA(fakePrepareEuint256Ciphertext(37));
+        inputContract.decryptA();
+        processAllOperations();
+        assertEq(inputContract.decryptedA(), 37);
+    }
+
+    function testUninitializedHandleIsDisallowed() public {
+        bytes32 randomHandle = keccak256("random handle");
+        euint256 a = e.asEuint256(12);
+        vm.expectRevert(
+            abi.encodeWithSelector(
+                SenderNotAllowedForHandle.selector,
+                randomHandle,
+                address(this)
+            )
+        );
+        a.add(euint256.wrap(randomHandle));
+    }
+}

package/src/test/TestVersion.t.sol

@@ -0,0 +1,36 @@
+// SPDX-License-Identifier: No License
+pragma solidity ^0.8;
+
+import {Test} from "forge-std/Test.sol";
+import {Version} from "../version/Version.sol";
+
+contract SomeContract is Version {
+    constructor() Version(1, 2, 3, bytes32(uint(12345678)), "SomeContract") {}
+}
+
+contract TestVersion is Test {
+    SomeContract someContract;
+
+    function setUp() public {
+        someContract = new SomeContract();
+    }
+
+    function testVersion() public view {
+        assertEq(someContract.majorVersion(), 1);
+        assertEq(someContract.minorVersion(), 2);
+        assertEq(someContract.patchVersion(), 3);
+        assertEq(someContract.getName(), "SomeContract");
+        assertEq(someContract.getVersion(), "1_2_3");
+        assertEq(
+            someContract.getVersionedName(),
+            "SomeContract_1_2_3__12345678"
+        );
+    }
+
+    function testVersionEip712() public view {
+        (, string memory name, string memory version, , , , ) = someContract
+            .eip712Domain();
+        assertEq(name, "SomeContract");
+        assertEq(version, "1_2_3");
+    }
+}

package/src/version/IncoLightningConfig.sol

@@ -0,0 +1,13 @@
+// SPDX-License-Identifier: No License
+pragma solidity ^0.8;
+
+// Change these constants for new contracts
+// Since this file only contains these constants, it could be generated reacting to cli inputs
+
+// IMPORTANT if you are changing this file, run `make update_config` afterwards for it to take effect
+// UPDATE the CHANGELOG on new versions
+
+string constant CONTRACT_NAME = "incoLightning";
+uint8 constant MAJOR_VERSION = 0;
+uint8 constant MINOR_VERSION = 1;
+uint8 constant PATCH_VERSION = 25;

package/src/version/Version.sol

@@ -0,0 +1,76 @@
+// SPDX-License-Identifier: No License
+pragma solidity ^0.8;
+
+import {Strings} from "@openzeppelin/contracts/utils/Strings.sol";
+import {EIP712} from "@openzeppelin/contracts/utils/cryptography/EIP712.sol";
+import {ShortStrings, ShortString} from "@openzeppelin/contracts/utils/ShortStrings.sol";
+
+contract Version is EIP712 {
+    using ShortStrings for ShortString;
+    using ShortStrings for string;
+
+    uint8 public immutable majorVersion;
+    uint8 public immutable minorVersion;
+    uint8 public immutable patchVersion;
+    bytes32 public immutable salt;
+    ShortString private immutable name;
+
+    constructor(
+        uint8 _majorVersion,
+        uint8 _minorVersion,
+        uint8 _patchVersion,
+        bytes32 _salt,
+        string memory _name
+    )
+        EIP712(
+            _name,
+            versionString(_majorVersion, _minorVersion, _patchVersion)
+        )
+    {
+        majorVersion = _majorVersion;
+        minorVersion = _minorVersion;
+        patchVersion = _patchVersion;
+        salt = _salt;
+        name = _name.toShortString();
+    }
+
+    function getVersionedName() public view virtual returns (string memory) {
+        uint256 shortSalt = uint256(salt) % 10e8;
+        return
+            string(
+                abi.encodePacked(
+                    getName(),
+                    "_",
+                    getVersion(),
+                    "__",
+                    // avoids name collision for deployments of the same version
+                    Strings.toString(shortSalt)
+                )
+            );
+    }
+
+    function getVersion() public view virtual returns (string memory) {
+        return versionString(majorVersion, minorVersion, patchVersion);
+    }
+
+    function versionString(
+        uint8 major,
+        uint8 minor,
+        uint8 patch
+    ) internal pure returns (string memory) {
+        return
+            string(
+                abi.encodePacked(
+                    Strings.toString(major),
+                    "_",
+                    Strings.toString(minor),
+                    "_",
+                    Strings.toString(patch)
+                )
+            );
+    }
+
+    function getName() public view virtual returns (string memory) {
+        return name.toString();
+    }
+}