@inco/lightning 0.5.3 → 0.6.0

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

@@ -0,0 +1,65 @@
+// SPDX-License-Identifier: No License
+pragma solidity ^0.8;
+
+import {Test} from "forge-std/Test.sol";
+import {EncryptedInput} from "../EncryptedInput.sol";
+import {VerifierAddressGetter} from "../primitives/VerifierAddressGetter.sol";
+import {FEE, Fee} from "../Fee.sol";
+import {IncoTest} from "../../test/IncoTest.sol";
+
+contract InputsTester is EncryptedInput {
+    constructor() VerifierAddressGetter(address(0)) {}
+}
+
+contract TestInputsFee is IncoTest {
+    InputsTester inputsTester;
+
+    function setUp() public override {
+        inputsTester = new InputsTester();
+    }
+
+    function testPayOnInputs() public {
+        // should fail if no fee
+        vm.expectRevert(Fee.FeeNotPaid.selector);
+        inputsTester.newEuint256{value: 0}(
+            fakePrepareEuint256Ciphertext(12),
+            address(0)
+        );
+
+        // should fail if not enough fee
+        vm.expectRevert(Fee.FeeNotPaid.selector);
+        inputsTester.newEuint256{value: FEE - 1}(
+            fakePrepareEuint256Ciphertext(12),
+            address(0)
+        );
+
+        // should fail if too much fee
+        vm.expectRevert(Fee.FeeNotPaid.selector);
+        inputsTester.newEuint256{value: FEE + 1}(
+            fakePrepareEuint256Ciphertext(12),
+            address(0)
+        );
+
+        // should work with exact fee
+        inputsTester.newEuint256{value: FEE}(
+            fakePrepareEuint256Ciphertext(12),
+            address(0)
+        );
+    }
+
+    function testPayForNewEbool() public {
+        // should work with exact fee
+        inputsTester.newEbool{value: FEE}(
+            fakePrepareEboolCiphertext(true),
+            address(0)
+        );
+    }
+
+    function testPayForNewEaddress() public {
+        // should work with exact fee
+        inputsTester.newEaddress{value: FEE}(
+            fakePrepareEaddressCiphertext(address(this)),
+            address(0)
+        );
+    }
+}

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

@@ -35,6 +35,7 @@ contract TestDecryptionAttestationInSynchronousFlow is IncoTest {
     AllowanceProof emptyProof; // no proof needed when requester has the handle in persisted allowed pairs
     function testSynchronousBurning() public {
         TokenBurnCurrentBalance token = new TokenBurnCurrentBalance();
+        vm.deal(address(token), 100 ether);
         token.confidentialTransfer(
             alice,
             fakePrepareEuint256Ciphertext(10 * GWEI),

package/src/test/AddTwo.sol

@@ -1,14 +1,13 @@
 // SPDX-License-Identifier: No License
 pragma solidity ^0.8;
 
-import {euint256} from "../Types.sol";
+import {euint256, ebool} from "../Types.sol";
 import {IncoLightning} from "../IncoLightning.sol";
-
-// import {console} from "forge-std/console.sol";
+import {Fee} from "../lightning-parts/Fee.sol";
 
 // To implement such a contract, we would normally import e form Lib.sol. For test purposes, we take inco as
 // a constructor argument instead, so we can test it from other deployment addresses.
-contract AddTwo {
+contract AddTwo is Fee {
     IncoLightning inco;
 
     constructor(IncoLightning _inco) {
@@ -31,8 +30,11 @@ contract AddTwo {
 
     function addTwoEOA(
         bytes memory uint256EInput
-    ) external returns (euint256 result, euint256 resultRevealed) {
-        euint256 value = inco.newEuint256(uint256EInput, msg.sender);
+    ) external payable refundUnspent returns (euint256 result, euint256 resultRevealed) {
+        euint256 value = inco.newEuint256{value: getFee()}(
+            uint256EInput,
+            msg.sender
+        );
         result = addTwo(value);
 
         inco.allow(euint256.unwrap(result), address(this));
@@ -43,4 +45,14 @@ contract AddTwo {
         resultRevealed = addTwoAlt(value);
         inco.reveal(euint256.unwrap(resultRevealed));
     }
+
+    function getTrue() external returns (ebool) {
+        ebool trueHandle = inco.asEbool(true);
+        inco.reveal(ebool.unwrap(trueHandle));
+        return trueHandle;
+    }
+
+    receive() external payable {
+        // Accept ETH payments
+    }
 }

package/src/test/FakeIncoInfra/FakeIncoInfraBase.sol

@@ -47,6 +47,18 @@ contract FakeIncoInfraBase is TestUtils, KVStore {
         ciphertext = abi.encode(value);
     }
 
+    function fakePrepareEaddressCiphertext(
+        address value
+    ) internal pure returns (bytes memory ciphertext) {
+        ciphertext = abi.encode(value);
+    }
+
+    function fakeDecryptEaddressCiphertext(
+        bytes memory ciphertext
+    ) internal pure returns (address value) {
+        value = abi.decode(ciphertext, (address));
+    }
+
     function fakeDecryptEboolCiphertext(
         bytes memory ciphertext
     ) internal pure returns (bool value) {

package/src/test/FakeIncoInfra/getOpForSelector.sol

@@ -63,8 +63,10 @@ function getOpForSelector(bytes32 opEventSelector) pure returns (EOps) {
         return EOps.Rand;
     } else if (opEventSelector == EncryptedOperations.ERandBounded.selector) {
         return EOps.RandBounded;
-    } else if (opEventSelector == BaseAccessControlList.EAllow.selector) {
+    } else if (opEventSelector == BaseAccessControlList.Allow.selector) {
         return EOps.Allow;
+    } else if (opEventSelector == BaseAccessControlList.Reveal.selector) {
+        return EOps.Reveal;
     } else {
         revert("getOpForSelector: Unsupported selector");
     }

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

@@ -67,7 +67,7 @@ contract TEELifecycleMockTest is Test, MockRemoteAttestation, TEELifecycle {
         );
         vm.startPrank(this.owner());
         this.approveNewTEEVersion(mrAggregated);
-        vm.expectRevert(TEELifecycle.InvalidBootstrapDataSignature.selector);
+        vm.expectRevert(TEELifecycle.InvalidEIP712Signature.selector);
         this.verifyBootstrapResult(bootstrapResult, quote, signatureInvalid);
         vm.stopPrank();
     }
@@ -117,7 +117,7 @@ contract TEELifecycleMockTest is Test, MockRemoteAttestation, TEELifecycle {
         (, address newCoval) = getLabeledKeyPair("newCoval");
         bytes memory quoteNew = createQuote(badMrtd, newCoval);
 
-        vm.expectRevert(TEELifecycle.InvalidReportMrAggregated.selector);
+        vm.expectRevert(TEELifecycle.TEEVersionNotFound.selector);
         this.addNewCovalidator(quoteNew);
         vm.stopPrank();
     }

package/src/test/TestAddTwo.t.sol

@@ -2,7 +2,7 @@
 pragma solidity ^0.8;
 
 import {inco} from "../Lib.sol";
-import {euint256} from "../Types.sol";
+import {euint256, ebool} from "../Types.sol";
 import {IncoTest} from "./IncoTest.sol";
 import {AddTwo} from "./AddTwo.sol";
 
@@ -12,6 +12,7 @@ contract TestAddTwo is IncoTest {
     function setUp() public override {
         super.setUp();
         addTwo = new AddTwo(inco);
+        vm.deal(address(addTwo), 1 ether);
         vm.label(address(addTwo), "addTwo");
     }
 
@@ -33,4 +34,11 @@ contract TestAddTwo is IncoTest {
         assertFalse(inco.isAllowed(euint256.unwrap(result), bob));
         assertTrue(inco.isAllowed(euint256.unwrap(revealedResult), bob));
     }
+
+    function testTrueHandleReveal() public {
+        ebool trueVal = addTwo.getTrue();
+        processAllOperations();
+        assertEq(getBoolValue(trueVal), true);
+        assertTrue(inco.isAllowed(ebool.unwrap(trueVal), bob));
+    }
 }

package/src/test/TestFakeInfra.t.sol

@@ -270,6 +270,7 @@ contract TestFakeInfra is IncoTest, MockRemoteAttestation {
 
     function testEInput() public {
         TakesEInput inputContract = new TakesEInput();
+        vm.deal(address(inputContract), 1 ether);
         inputContract.setA(fakePrepareEuint256Ciphertext(12));
         inputContract.setB(fakePrepareEboolCiphertext(true));
         processAllOperations();
@@ -290,16 +291,25 @@ contract TestFakeInfra is IncoTest, MockRemoteAttestation {
         a.add(euint256.wrap(randomHandle));
     }
 
-    function testCreateQuote() public {
+    function testCreateQuote() public view {
         bytes
             memory mrtd = hex"1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef";
         address signer = address(0x1234567890123456789012345678901234567890);
         bytes memory quote = createQuote(mrtd, signer);
         TEELifecycle lifecycle = TEELifecycle(address(inco.incoVerifier()));
         TD10ReportBody memory tdReport = lifecycle.parseTD10ReportBody(quote);
-        (address reportDataSigner, bytes32 reportMrAggregated) = lifecycle.parseReport(tdReport);
+        (address reportDataSigner, bytes32 reportMrAggregated) = lifecycle
+            .parseReport(tdReport);
         assertEq(reportDataSigner, signer);
-        assertEq(reportMrAggregated, lifecycle.computeMrAggregated(tdReport.mrTd, tdReport.rtMr0, tdReport.rtMr1, tdReport.rtMr2));
+        assertEq(
+            reportMrAggregated,
+            lifecycle.computeMrAggregated(
+                tdReport.mrTd,
+                tdReport.rtMr0,
+                tdReport.rtMr1,
+                tdReport.rtMr2
+            )
+        );
         assertEq(quote.length, MINIMUM_QUOTE_LENGTH);
     }
 }

package/src/version/IncoLightningConfig.sol

@@ -11,6 +11,6 @@ uint8 constant MAJOR_VERSION = 1;
 uint8 constant MINOR_VERSION = 0;
 // whenever a new major version is deployed, we need to pump this up
 // otherwise make test_upgrade will fail
-uint8 constant PATCH_VERSION = 1; 
+uint8 constant PATCH_VERSION = 2;
 
 string constant VERIFIER_NAME = "incoVerifier";