@inco/lightning 0.1.32 → 0.2.3

package/src/lightning-parts/AccessControl/BaseAccessControlList.sol

@@ -2,6 +2,7 @@
 pragma solidity ^0.8;
 
 import {SenderNotAllowedForHandle} from "../../Types.sol";
+import {IBaseAccessControlListGen} from "./BaseAccessControlList.gen.sol";
 
 contract AccessControlListStorage {
     struct ACLStorage {
@@ -19,7 +20,7 @@ contract AccessControlListStorage {
 }
 
 // todo should add allowance events ?
-contract BaseAccessControlList is AccessControlListStorage {
+contract BaseAccessControlList is IBaseAccessControlListGen, AccessControlListStorage {
     /// @dev persistent
     function allow(bytes32 handle, address account) public {
         require(

package/src/lightning-parts/DecryptionHandler.gen.sol

@@ -0,0 +1,54 @@
+/// SPDX-License-Identifier: No License
+pragma solidity ^0.8;
+
+import "./DecryptionHandler.types.sol";
+import { BaseAccessControlList } from "./AccessControl/BaseAccessControlList.sol";
+import { EIP712 } from "@openzeppelin/contracts/utils/cryptography/EIP712.sol";
+import { EventCounter } from "./primitives/EventCounter.sol";
+import { IDecryptionHandlerEip712CheckerGen } from "./DecryptionHandler.gen.sol";
+import { SenderNotAllowedForHandle } from "../Types.sol";
+import { SignatureVerifier } from "./primitives/SignatureVerifier.sol";
+
+interface IDecryptionHandlerEip712CheckerGen {
+    function decryptionResultDigest(DecryptionResult memory result) external view returns (bytes32);
+}
+
+interface IDecryptionHandlerGen {
+    /// @dev callback function MUST be of form `function name(bytes32 requestId, bytes32 result, bytes memory data)`
+    function requestDecryption(bytes4 callbackSelector, uint256 maxTimestamp, bytes32 handle, bytes memory data) external returns (uint256 requestId);
+
+    function fulfillRequest(DecryptionResult memory result, bytes memory signature) external;
+
+    function fulfillRequestsBatch(SignedDecryptionResult[] memory results) external;
+
+    ///  @dev Get some pending requests.
+    ///  @param offset A parameter for paginating through the whole set of pending requests.
+    ///      Use zero for an initial query, then use the previous query's nextOffset to continue traversal.
+    ///  @param maxRequests The maximum number of pending to return.
+    ///  @param iterationBound The maximum number of non-pending requests to iterate over before returning.
+    ///  @return nextOffset The next offset to use to continue to scan through the pending request set.
+    ///      Returns the input offset if the whole set has been scanned.  Can re-query with this offset
+    ///      to see any new pending requests, or re-query with a zero offset to return the whole set again.
+    ///  @return requests Some pending requests.  May be fewer than requested, possibly zero.  There may be
+    ///      more requests available if the returned nextOffset is greater than the input offset.
+    function getPendingRequests(uint256 offset, uint256 maxRequests, uint256 iterationBound) external view returns (uint256 nextOffset, Request[] memory requests);
+
+    ///  @param offset A parameter for paginating through the whole set of pending requests.
+    ///      Use zero for an initial query, then use the previous query's nextOffset to continue traversal.
+    ///  @param maxRequests The maximum number of pending to return.
+    ///  @return nextOffset The next offset to use to continue to scan through the pending request set.
+    ///      Returns the input offset if the whole set has been scanned.  Can re-query with this offset
+    ///      to see any new pending requests, or re-query with a zero offset to return the whole set again.
+    ///  @return requests Some pending requests.  May be fewer than requested, possibly zero.  There may be
+    ///      more requests available if the returned nextOffset is greater than the input offset.
+    function getPendingRequests(uint256 offset, uint256 maxRequests) external view returns (uint256 nextOffset, Request[] memory requests);
+
+    function getNextRequestId() external view returns (uint256);
+
+    function getLowWatermarkRequestId() external view returns (uint256);
+
+    ///  @dev Advance the low watermark until we hit a pending request, the requestId counter, or iterationBound steps.
+    ///  @param iterationBound The maximum number of requests to iterate over.
+    ///  @notice This function is public so that we can externally drive the low watermark in extreme cases.
+    function advanceLowWatermark(uint256 iterationBound) external;
+}

package/src/lightning-parts/DecryptionHandler.sol

@@ -1,44 +1,15 @@
 // SPDX-License-Identifier: No License
 pragma solidity ^0.8;
 
-import {SenderNotAllowedForHandle} from "../Types.sol";
+import "./DecryptionHandler.gen.sol";
+import "./DecryptionHandler.types.sol";
 import {BaseAccessControlList} from "./AccessControl/BaseAccessControlList.sol";
 import {EIP712} from "@openzeppelin/contracts/utils/cryptography/EIP712.sol";
 import {EventCounter} from "./primitives/EventCounter.sol";
+import {IDecryptionHandlerEip712CheckerGen} from "./DecryptionHandler.gen.sol";
+import {SenderNotAllowedForHandle} from "../Types.sol";
 import {SignatureVerifier} from "./primitives/SignatureVerifier.sol";
 
-struct Request {
-    uint256 maxTimestamp;
-    address callbackContract;
-    bytes4 callbackSelector;
-    bool fulfilled;
-    bytes data;
-    // Adding at end of struct which should be unused state slot for version 0.2.0
-    bytes32 handle;
-    // This value is redundant for the contract but required for getPendingRequests, rather than duplicate this struct
-    // adding it here redundantly for now
-    uint256 requestId;
-}
-
-struct DecryptionResult {
-    bytes32 abiEncodedResult;
-    uint256 requestId;
-    // Added in 0.2.0 to offer an integrity check
-    bytes32 handle;
-}
-
-struct SignedDecryptionResult {
-    DecryptionResult result;
-    bytes signature;
-}
-
-event DecryptionRequested(
-    uint256 indexed requestId,
-    bytes32 indexed handle,
-    uint256 maxTimestamp,
-    uint256 eventId
-);
-
 contract DecryptionHandlerStorage {
     struct DecryptionStorage {
         // The next request ID to assign. This and higher numbers have never been used,
@@ -65,7 +36,7 @@ contract DecryptionHandlerStorage {
     }
 }
 
-abstract contract DecryptionHandlerEip712Checker is EIP712, SignatureVerifier {
+abstract contract DecryptionHandlerEip712Checker is IDecryptionHandlerEip712CheckerGen, EIP712, SignatureVerifier {
     bytes32 constant DecryptionResultStructHash =
         keccak256(
             "DecryptionResult(bytes32 abiEncodedResult,uint256 requestId)"
@@ -95,6 +66,7 @@ abstract contract DecryptionHandlerEip712Checker is EIP712, SignatureVerifier {
 }
 
 abstract contract DecryptionHandler is
+    IDecryptionHandlerGen,
     BaseAccessControlList,
     EventCounter,
     DecryptionHandlerStorage,
@@ -280,7 +252,7 @@ abstract contract DecryptionHandler is
     }
 
     /**
-     * @dev Get some pending requests with a bounded number of iterations.
+
      * @param offset A parameter for paginating through the whole set of pending requests.
      *     Use zero for an initial query, then use the previous query's nextOffset to continue traversal.
      * @param maxRequests The maximum number of pending to return.

package/src/lightning-parts/DecryptionHandler.types.sol

@@ -0,0 +1,34 @@
+// SPDX-License-Identifier: No License
+pragma solidity ^0.8;
+
+struct Request {
+    uint256 maxTimestamp;
+    address callbackContract;
+    bytes4 callbackSelector;
+    bool fulfilled;
+    bytes data;
+    // Adding at end of struct which should be unused state slot for version 0.2.0
+    bytes32 handle;
+    // This value is redundant for the contract but required for getPendingRequests, rather than duplicate this struct
+    // adding it here redundantly for now
+    uint256 requestId;
+}
+
+struct DecryptionResult {
+    bytes32 abiEncodedResult;
+    uint256 requestId;
+    // Added in 0.2.0 to offer an integrity check
+    bytes32 handle;
+}
+
+struct SignedDecryptionResult {
+    DecryptionResult result;
+    bytes signature;
+}
+
+event DecryptionRequested(
+    uint256 indexed requestId,
+    bytes32 indexed handle,
+    uint256 maxTimestamp,
+    uint256 eventId
+);

package/src/lightning-parts/EncryptedInput.gen.sol

@@ -0,0 +1,13 @@
+/// SPDX-License-Identifier: No License
+pragma solidity ^0.8;
+
+import { BaseAccessControlList } from "./AccessControl/BaseAccessControlList.sol";
+import { EventCounter } from "./primitives/EventCounter.sol";
+import { HandleGeneration } from "./primitives/HandleGeneration.sol";
+import { euint256, ebool, ETypes, EVM_HOST_CHAIN_PREFIX, HANDLE_VERSION, HANDLE_INDEX } from "../Types.sol";
+
+interface IEncryptedInputGen {
+    function newEuint256(bytes memory ciphertext, address user) external returns (euint256 newValue);
+
+    function newEbool(bytes memory ciphertext, address user) external returns (ebool newValue);
+}

package/src/lightning-parts/EncryptedInput.sol

@@ -3,11 +3,12 @@ pragma solidity ^0.8;
 
 import {BaseAccessControlList} from "./AccessControl/BaseAccessControlList.sol";
 import {EventCounter} from "./primitives/EventCounter.sol";
-// import {console} from "forge-std/console.sol";
-import {euint256, ebool, ETypes, EVM_HOST_CHAIN_PREFIX, HANDLE_VERSION, HANDLE_INDEX} from "../Types.sol";
 import {HandleGeneration} from "./primitives/HandleGeneration.sol";
+import {euint256, ebool, ETypes, EVM_HOST_CHAIN_PREFIX, HANDLE_VERSION, HANDLE_INDEX} from "../Types.sol";
+import {IEncryptedInputGen} from "./EncryptedInput.gen.sol";
 
 abstract contract EncryptedInput is
+    IEncryptedInputGen,
     BaseAccessControlList,
     EventCounter,
     HandleGeneration

package/src/lightning-parts/EncryptedOperations.gen.sol

@@ -0,0 +1,59 @@
+/// SPDX-License-Identifier: No License
+pragma solidity ^0.8;
+
+import { euint256, ebool, EOps, SenderNotAllowedForHandle, ETypes, isTypeSupported } from "../Types.sol";
+import { BaseAccessControlList } from "./AccessControl/BaseAccessControlList.sol";
+import { EventCounter } from "./primitives/EventCounter.sol";
+import { HandleGeneration } from "./primitives/HandleGeneration.sol";
+
+interface IEncryptedOperationsGen {
+    function eAdd(euint256 lhs, euint256 rhs) external returns (euint256 result);
+
+    function eSub(euint256 lhs, euint256 rhs) external returns (euint256 result);
+
+    function eMul(euint256 lhs, euint256 rhs) external returns (euint256 result);
+
+    function eDiv(euint256 lhs, euint256 rhs) external returns (euint256 result);
+
+    function eRem(euint256 lhs, euint256 rhs) external returns (euint256 result);
+
+    function eBitAnd(bytes32 lhs, bytes32 rhs) external returns (bytes32 result);
+
+    function eBitOr(bytes32 lhs, bytes32 rhs) external returns (bytes32 result);
+
+    function eBitXor(bytes32 lhs, bytes32 rhs) external returns (bytes32 result);
+
+    function eShl(euint256 lhs, euint256 rhs) external returns (euint256 result);
+
+    function eShr(euint256 lhs, euint256 rhs) external returns (euint256 result);
+
+    function eRotl(euint256 lhs, euint256 rhs) external returns (euint256 result);
+
+    function eRotr(euint256 lhs, euint256 rhs) external returns (euint256 result);
+
+    function eEq(euint256 lhs, euint256 rhs) external returns (ebool result);
+
+    function eNe(euint256 lhs, euint256 rhs) external returns (ebool result);
+
+    function eGe(euint256 lhs, euint256 rhs) external returns (ebool result);
+
+    function eGt(euint256 lhs, euint256 rhs) external returns (ebool result);
+
+    function eLe(euint256 lhs, euint256 rhs) external returns (ebool result);
+
+    function eLt(euint256 lhs, euint256 rhs) external returns (ebool result);
+
+    function eMin(euint256 lhs, euint256 rhs) external returns (euint256 result);
+
+    function eMax(euint256 lhs, euint256 rhs) external returns (euint256 result);
+
+    function eNot(ebool operand) external returns (ebool result);
+
+    function eCast(bytes32 ct, ETypes toType) external returns (bytes32 result);
+
+    function eRand(ETypes randType) external returns (bytes32 result);
+
+    function eRandBounded(bytes32 upperBound, ETypes randType) external returns (bytes32 result);
+
+    function eIfThenElse(ebool control, bytes32 ifTrue, bytes32 ifFalse) external returns (bytes32 result);
+}

package/src/lightning-parts/EncryptedOperations.sol

@@ -5,8 +5,10 @@ import {euint256, ebool, EOps, SenderNotAllowedForHandle, ETypes, isTypeSupporte
 import {BaseAccessControlList} from "./AccessControl/BaseAccessControlList.sol";
 import {EventCounter} from "./primitives/EventCounter.sol";
 import {HandleGeneration} from "./primitives/HandleGeneration.sol";
+import {IEncryptedOperationsGen} from "./EncryptedOperations.gen.sol";
 
 abstract contract EncryptedOperations is
+    IEncryptedOperationsGen,
     BaseAccessControlList,
     EventCounter,
     HandleGeneration
@@ -290,7 +292,7 @@ abstract contract EncryptedOperations is
     function eRem(
         euint256 lhs,
         euint256 rhs
-    ) external checked(lhs, rhs) returns (euint256 result) {
+    ) external virtual checked(lhs, rhs) returns (euint256 result) {
         result = euint256.wrap(
             createResultHandle(
                 EOps.Rem,

package/src/lightning-parts/TrivialEncryption.gen.sol

@@ -0,0 +1,13 @@
+/// SPDX-License-Identifier: No License
+pragma solidity ^0.8;
+
+import { EventCounter } from "./primitives/EventCounter.sol";
+import { euint256, ebool, ETypes } from "../Types.sol";
+import { BaseAccessControlList } from "./AccessControl/BaseAccessControlList.sol";
+import { HandleGeneration } from "./primitives/HandleGeneration.sol";
+
+interface ITrivialEncryptionGen {
+    function asEuint256(uint256 value) external returns (euint256 newEuint256);
+
+    function asEbool(bool value) external returns (ebool newEbool);
+}

package/src/lightning-parts/TrivialEncryption.sol

@@ -5,8 +5,10 @@ import {EventCounter} from "./primitives/EventCounter.sol";
 import {euint256, ebool, ETypes} from "../Types.sol";
 import {BaseAccessControlList} from "./AccessControl/BaseAccessControlList.sol";
 import {HandleGeneration} from "./primitives/HandleGeneration.sol";
+import {ITrivialEncryptionGen} from "./TrivialEncryption.gen.sol";
 
 abstract contract TrivialEncryption is
+    ITrivialEncryptionGen,
     BaseAccessControlList,
     EventCounter,
     HandleGeneration

package/src/lightning-parts/primitives/EventCounter.gen.sol

@@ -0,0 +1,6 @@
+/// SPDX-License-Identifier: No License
+pragma solidity ^0.8;
+
+interface IEventCounterGen {
+    function getEventCounter() external view returns (uint256);
+}

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

@@ -1,6 +1,8 @@
 // SPDX-License-Identifier: No License
 pragma solidity ^0.8;
 
+import {IEventCounterGen} from "./EventCounter.gen.sol";
+
 contract EventCounterStorage {
     struct Storage {
         uint256 eventCounter;
@@ -21,7 +23,7 @@ contract EventCounterStorage {
     }
 }
 
-contract EventCounter is EventCounterStorage {
+contract EventCounter is IEventCounterGen, EventCounterStorage {
     function getNewEventId() internal returns (uint256 newEventId) {
         newEventId = getEventCounterStorage().eventCounter++;
     }

package/src/lightning-parts/primitives/HandleGeneration.gen.sol

@@ -0,0 +1,19 @@
+/// SPDX-License-Identifier: No License
+pragma solidity ^0.8;
+
+import { ETypes, EOps, EVM_HOST_CHAIN_PREFIX, HANDLE_INDEX } from "../../Types.sol";
+import { HandleMetadata } from "./HandleMetadata.sol";
+
+interface IHandleGenerationGen {
+    function getTrivialEncryptHandle(bytes32 plaintextBytes, ETypes handleType) external view returns (bytes32 generatedHandle);
+
+    function getInputHandle(bytes memory ciphertext, address user, address contractAddress, ETypes inputType) external view returns (bytes32 generatedHandle);
+
+    function getOpResultHandle(EOps op, ETypes returnType, bytes32 lhs, bytes32 rhs) external pure returns (bytes32 generatedHandle);
+
+    function getOpResultHandle(EOps op, ETypes returnType, uint256 counter, bytes32 upperBound) external pure returns (bytes32 generatedHandle);
+
+    function getOpResultHandle(EOps op, ETypes returnType, bytes32 value) external pure returns (bytes32 generatedHandle);
+
+    function getOpResultHandle(EOps op, ETypes returnType, bytes32 inputA, bytes32 inputB, bytes32 inputC) external pure returns (bytes32 generatedHandle);
+}

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

@@ -3,8 +3,9 @@ pragma solidity ^0.8;
 
 import {ETypes, EOps, EVM_HOST_CHAIN_PREFIX, HANDLE_INDEX} from "../../Types.sol";
 import {HandleMetadata} from "./HandleMetadata.sol";
+import {IHandleGenerationGen} from "./HandleGeneration.gen.sol";
 
-contract HandleGeneration is HandleMetadata {
+contract HandleGeneration is IHandleGenerationGen, HandleMetadata {
     function getTrivialEncryptHandle(
         bytes32 plaintextBytes,
         ETypes handleType

package/src/lightning-parts/primitives/HandleMetadata.gen.sol

@@ -0,0 +1,4 @@
+/// SPDX-License-Identifier: No License
+pragma solidity ^0.8;
+
+import { HANDLE_VERSION, HANDLE_INDEX, ETypes } from "../../Types.sol";

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

@@ -0,0 +1,15 @@
+/// SPDX-License-Identifier: No License
+pragma solidity ^0.8;
+
+import { OwnableUpgradeable } from "@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol";
+import { ECDSA } from "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
+
+interface ISignatureVerifierGen {
+    function addSigner(address signerAddress) external;
+
+    function removeSigner(address signerAddress) external;
+
+    function isSigner(address signerAddress) external view returns (bool);
+
+    function isValidSignature(bytes32 hash, bytes memory signature) external view returns (bool);
+}

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

@@ -3,6 +3,7 @@ pragma solidity ^0.8;
 
 import {OwnableUpgradeable} from "@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol";
 import {ECDSA} from "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
+import {ISignatureVerifierGen} from "./SignatureVerifier.gen.sol";
 
 contract SignatureVerifierStorage {
     struct StorageForSigVerifier {
@@ -26,7 +27,7 @@ contract SignatureVerifierStorage {
     }
 }
 
-contract SignatureVerifier is OwnableUpgradeable, SignatureVerifierStorage {
+contract SignatureVerifier is ISignatureVerifierGen, OwnableUpgradeable, SignatureVerifierStorage {
     using ECDSA for bytes32;
 
     error SignerNotFound(address signerAddress);

package/src/test/AddTwo.sol

@@ -24,8 +24,6 @@ contract AddTwo {
         return inco.eAdd(a, inco.asEuint256(two));
     }
 
-    // addTwoEOA is the equivalent of addTwo, but it allows an EOA to call it
-    // with an encrypted input.
     function addTwoEOA(
         bytes memory uint256EInput
     ) external returns (uint256, euint256) {

package/src/test/IncoTest.sol

@@ -27,10 +27,11 @@ contract IncoTest is MockOpHandler, DeployUtils {
         vm.startPrank(testDeployer);
         IncoLightning proxy = deployIncoLightningUsingConfig({
             deployer: testDeployer,
-            // The highest precedent deployment
+        // The highest precedent deployment
             pepper: "testnet",
             minorVersionForSalt: 1,
-            patchVersionForSalt: 29
+            patchVersionForSalt: 29,
+            includePreviewFeatures: false
         });
         proxy.transferOwnership(owner);
         vm.stopPrank();

package/src/version/Version.gen.sol

@@ -0,0 +1,14 @@
+/// 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";
+
+interface IVersionGen {
+    function getVersionedName() external view returns (string memory);
+
+    function getVersion() external view returns (string memory);
+
+    function getName() external view returns (string memory);
+}

package/src/version/Version.sol

@@ -13,7 +13,7 @@ contract Version is EIP712 {
     uint8 public immutable minorVersion;
     uint8 public immutable patchVersion;
     bytes32 public immutable salt;
-    ShortString private immutable name;
+    ShortString internal immutable name;
 
     constructor(
         uint8 _majorVersion,