@inco/lightning 0.1.30 → 0.1.31

package/src/lightning-parts/primitives/SignatureVerifier.sol

@@ -6,11 +6,13 @@ import {ECDSA} from "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
 
 contract SignatureVerifierStorage {
     struct StorageForSigVerifier {
-        address PubkeyAddress;
+        mapping(address => bool) isSigner;
     }
 
+    // State changelog:
+    // 0.2.0: Shifting state location to support multiple signers
     bytes32 private constant SignatureVerifierStorageLocation =
-        keccak256("inco.storage.SignatureVerifier");
+        keccak256("inco.storage.SignatureVerifier.v0.2.0");
 
     function getSigVerifierStorage()
         internal
@@ -27,21 +29,34 @@ contract SignatureVerifierStorage {
 contract SignatureVerifier is OwnableUpgradeable, SignatureVerifierStorage {
     using ECDSA for bytes32;
 
-    event PubkeyAddressChanged(address newPubkeyAddress);
+    error SignerNotFound(address signerAddress);
 
-    function editPubkeyAddress(address newPubkeyAddress) external onlyOwner {
-        getSigVerifierStorage().PubkeyAddress = newPubkeyAddress;
-        emit PubkeyAddressChanged(newPubkeyAddress);
+    event AddedSignatureVerifier(address signerAddress);
+    event RemovedSignatureVerifier(address signerAddress);
+
+    function addSigner(address signerAddress) external onlyOwner {
+        getSigVerifierStorage().isSigner[signerAddress] = true;
+        emit AddedSignatureVerifier(signerAddress);
+    }
+
+    function removeSigner(address signerAddress) external onlyOwner {
+        require(
+            getSigVerifierStorage().isSigner[signerAddress],
+            SignerNotFound(signerAddress)
+        );
+        getSigVerifierStorage().isSigner[signerAddress] = false;
+        emit AddedSignatureVerifier(signerAddress);
     }
 
-    function opSignerPubkeyAddress() public view returns (address) {
-        return getSigVerifierStorage().PubkeyAddress;
+    function isSigner(address signerAddress) public view returns (bool) {
+        return getSigVerifierStorage().isSigner[signerAddress];
     }
 
     function isValidSignature(
         bytes32 hash,
         bytes memory signature
     ) public view returns (bool) {
-        return hash.recover(signature) == getSigVerifierStorage().PubkeyAddress;
+        address signerAddress = hash.recover(signature);
+        return getSigVerifierStorage().isSigner[signerAddress];
     }
 }

package/src/test/AddTwo.sol

@@ -1,24 +1,27 @@
 // SPDX-License-Identifier: No License
 pragma solidity ^0.8;
 
-import {e, euint256} from "../Lib.sol";
+import {IncoLightning} from "../IncoLightning.sol";
+import {euint256} from "../Types.sol";
 
 contract AddTwo {
-    using e for euint256;
-    using e for uint256;
-    using e for bytes;
+    IncoLightning immutable inco;
+
+    constructor(IncoLightning _inco) {
+        inco = _inco;
+    }
 
     // Stores the result of the last callback.
     uint256 public lastResult;
 
     function addTwo(euint256 a) external returns (euint256) {
         uint256 two = 2;
-        return a.add(two.asEuint256());
+        return inco.eAdd(a, inco.asEuint256(two));
     }
 
     function addTwoScalar(euint256 a) external returns (euint256) {
         uint256 two = 2;
-        return a.add(two);
+        return inco.eAdd(a, inco.asEuint256(two));
     }
 
     // addTwoEOA is the equivalent of addTwo, but it allows an EOA to call it
@@ -26,13 +29,14 @@ contract AddTwo {
     function addTwoEOA(
         bytes memory uint256EInput
     ) external returns (uint256, euint256) {
-        euint256 value = uint256EInput.newEuint256(msg.sender);
+        euint256 value = inco.newEuint256(uint256EInput, msg.sender);
         euint256 result = this.addTwo(value);
-        e.allow(result, address(this));
-        e.allow(result, msg.sender);
-        uint256 requestId = e.requestDecryption(
-            result,
+        inco.allow(euint256.unwrap(result), address(this));
+        inco.allow(euint256.unwrap(result), msg.sender);
+        uint256 requestId = inco.requestDecryption(
             this.callback.selector,
+            block.timestamp + 2 hours,
+            euint256.unwrap(result),
             ""
         );
         return (requestId, result);

package/src/test/FakeIncoInfra/FakeIncoInfraBase.sol

@@ -25,7 +25,8 @@ contract FakeIncoInfraBase is TestUtils, KVStore {
     ) internal {
         DecryptionResult memory result = DecryptionResult({
             abiEncodedResult: get(handle),
-            requestId: requestId
+            requestId: requestId,
+            handle: handle
         });
         vm.prank(teePubkeyAddress);
         inco.fulfillRequest(result, "");

package/src/test/FibonacciDecrypt.sol

@@ -0,0 +1,48 @@
+// SPDX-License-Identifier: No License
+pragma solidity ^0.8;
+
+import {IncoLightning} from "../IncoLightning.sol";
+import {euint256} from "../Types.sol";
+
+contract FibonacciDecrypt {
+    IncoLightning immutable inco;
+
+    constructor(IncoLightning _inco) {
+        inco = _inco;
+    }
+
+    // Stores the result of the last callback.
+    uint256 public lastResult;
+
+    function fib(
+        uint256 n
+    ) external returns (uint256 lastRequestId, euint256 nthTerm) {
+        euint256 prev = inco.asEuint256(0);
+        lastRequestId = emitTerm(prev);
+        nthTerm = inco.asEuint256(1);
+        lastRequestId = emitTerm(nthTerm);
+        for (uint256 i = 0; i < n-2; i++) {
+            euint256 temp = nthTerm;
+            nthTerm = inco.eAdd(prev, nthTerm);
+            prev = temp;
+            lastRequestId = emitTerm(nthTerm);
+        }
+    }
+
+    function emitTerm(euint256 term) internal returns (uint256 requestId) {
+        requestId = inco.requestDecryption(
+            this.callback.selector,
+            block.timestamp + 2 hours,
+            euint256.unwrap(term),
+            ""
+        );
+    }
+
+    function callback(
+        uint256 /* requestId */,
+        uint256 result,
+        bytes memory /* data */
+    ) external {
+        lastResult = result;
+    }
+}

package/src/test/IncoTest.sol

@@ -27,8 +27,10 @@ contract IncoTest is MockOpHandler, DeployUtils {
         vm.startPrank(testDeployer);
         IncoLightning proxy = deployIncoLightningUsingConfig({
             deployer: testDeployer,
-        // The highest precedent deployment
-            pepper: "testnet"
+            // The highest precedent deployment
+            pepper: "testnet",
+            minorVersionForSalt: 1,
+            patchVersionForSalt: 29
         });
         proxy.transferOwnership(owner);
         vm.stopPrank();
@@ -40,10 +42,10 @@ contract IncoTest is MockOpHandler, DeployUtils {
         console.log("Generated inco address: %s", address(inco));
         require(
             address(proxy) == address(inco),
-            "hardcoded inco address does not match proxy deployed in test setup"
+            "generated inco address in Lib.sol does not match address of inco deployed by IncoTest"
         );
         vm.prank(owner);
-        inco.editPubkeyAddress(teePubkeyAddress);
+        inco.addSigner(teePubkeyAddress);
         vm.recordLogs();
     }
 }

package/src/test/TestAddTwo.t.sol

@@ -1,29 +1,27 @@
 // SPDX-License-Identifier: No License
 pragma solidity ^0.8;
 
-import {e, euint256} from "../Lib.sol";
+import {inco} from "../Lib.sol";
+import {euint256} from "../Types.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();
+        AddTwo addTwo = new AddTwo(inco);
         vm.label(address(addTwo), "addTwo");
-        euint256 a = e.asEuint256(3);
-        a.allow(address(addTwo));
+        euint256 a = inco.asEuint256(3);
+        inco.allow(euint256.unwrap(a), address(addTwo));
         euint256 b = addTwo.addTwo(a);
         processAllOperations();
         assertEq(getUint256Value(b), 5);
     }
 
     function testAddTwoScalar() public {
-        AddTwo addTwo = new AddTwo();
+        AddTwo addTwo = new AddTwo(inco);
         vm.label(address(addTwo), "addTwoScalar");
-        euint256 a = e.asEuint256(3);
-        a.allow(address(addTwo));
+        euint256 a = inco.asEuint256(3);
+        inco.allow(euint256.unwrap(a), address(addTwo));
         euint256 b = addTwo.addTwoScalar(a);
         processAllOperations();
         assertEq(getUint256Value(b), 5);

package/src/version/IncoLightningConfig.sol

@@ -9,5 +9,5 @@ pragma solidity ^0.8;
 
 string constant CONTRACT_NAME = "incoLightning";
 uint8 constant MAJOR_VERSION = 0;
-uint8 constant MINOR_VERSION = 1;
-uint8 constant PATCH_VERSION = 29;
+uint8 constant MINOR_VERSION = 2;
+uint8 constant PATCH_VERSION = 0;