@inco/lightning 0.8.0-devnet-20 → 0.8.0-devnet-23

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@inco/lightning",
-  "version": "0.8.0-devnet-20",
+  "version": "0.8.0-devnet-23",
   "repository": "https://github.com/Inco-fhevm/inco-monorepo",
   "files": [
     "src/",

package/src/lightning-parts/DecryptionAttester.sol

@@ -1,8 +1,13 @@
 // SPDX-License-Identifier: No License
 pragma solidity ^0.8;
 
-import {DecryptionAttestation, ElementAttestationWithProof} from "./DecryptionAttester.types.sol";
+import {
+    DecryptionAttestation,
+    ElementAttestationWithProof,
+    ReencryptionAttestation
+} from "./DecryptionAttester.types.sol";
 import {EIP712Upgradeable} from "@openzeppelin/contracts-upgradeable/utils/cryptography/EIP712Upgradeable.sol";
+import {ECDSA} from "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
 import {SignatureVerifier} from "./primitives/SignatureVerifier.sol";
 import {IDecryptionAttester} from "./interfaces/IDecryptionAttester.sol";
 
@@ -14,10 +19,20 @@ import {IDecryptionAttester} from "./interfaces/IDecryptionAttester.sol";
 /// on-chain verification that a decryption was performed correctly by authorized covalidators.
 abstract contract DecryptionAttester is IDecryptionAttester, SignatureVerifier, EIP712Upgradeable {
 
+    using ECDSA for bytes32;
+
+    /// @dev Thrown when attestations and signatures arrays have different lengths.
+    error AttestationsSignaturesLengthMismatch(uint256 attestationsLength, uint256 signaturesLength);
+
     /// @dev EIP-712 type hash for DecryptionAttestation struct.
     bytes32 constant DECRYPTION_ATTESTATION_STRUCT_HASH =
         keccak256("DecryptionAttestation(bytes32 handle,bytes32 value)");
 
+    /// @dev EIP-712 type hash for Reencryption struct.
+    /// Matches the Go-side definition in eip712.go: Reencryption(bytes user_ciphertext,bytes32 handle,bytes signature)
+    bytes32 constant REENCRYPTION_ATTESTATION_STRUCT_HASH =
+        keccak256("Reencryption(bytes user_ciphertext,bytes32 handle,bytes signature)");
+
     /// @notice Computes the EIP-712 digest for a decryption attestation.
     /// @dev Used to verify signatures from covalidators attesting to a decryption result.
     /// @param decryption The decryption attestation containing the handle and decrypted value.
@@ -28,6 +43,22 @@ abstract contract DecryptionAttester is IDecryptionAttester, SignatureVerifier,
         );
     }
 
+    /// @notice Computes the EIP-712 digest for a reencryption attestation.
+    /// @param attestation The reencryption attestation containing handle, userCiphertext, and encryptedSignature.
+    /// @return The EIP-712 typed data hash.
+    function reencryptionAttestationDigest(ReencryptionAttestation memory attestation) public view returns (bytes32) {
+        return _hashTypedDataV4(
+            keccak256(
+                abi.encode(
+                    REENCRYPTION_ATTESTATION_STRUCT_HASH,
+                    keccak256(attestation.userCiphertext),
+                    attestation.handle,
+                    keccak256(attestation.encryptedSignature)
+                )
+            )
+        );
+    }
+
     /// @notice Validates a decryption attestation against covalidator signatures.
     /// @dev Verifies that the attestation was signed by the required threshold of covalidators.
     /// @param decryption The decryption attestation to validate.
@@ -77,4 +108,59 @@ abstract contract DecryptionAttester is IDecryptionAttester, SignatureVerifier,
         return isValidDecryptionAttestation(attestation, signatures);
     }
 
+    /// @notice Validates reencryption attestations from multiple covalidators against the threshold.
+    /// @dev Each covalidator produces a different ciphertext (X-Wing encryption is randomized),
+    ///      so each attestation has a unique digest. Each is verified individually and the function
+    ///      checks that at least `threshold` unique authorized signers attested.
+    /// @param attestations Array of reencryption attestations, one per covalidator.
+    /// @param signatures Array of envelope signatures, one per attestation (same order).
+    /// @return True if at least `threshold` unique authorized covalidators signed valid attestations.
+    function isValidReencryptionAttestation(
+        ReencryptionAttestation[] calldata attestations,
+        bytes[] calldata signatures
+    ) public view returns (bool) {
+        if (attestations.length != signatures.length) {
+            revert AttestationsSignaturesLengthMismatch(attestations.length, signatures.length);
+        }
+
+        uint256 threshold = getThreshold();
+        if (threshold == 0 || attestations.length < threshold) {
+            return false;
+        }
+
+        address[] memory recoveredSigners = new address[](attestations.length);
+        address lastSigner = address(0);
+        uint256 correctSignaturesCount = 0;
+        uint256 validCount = 0;
+
+        for (uint256 i = 0; i < attestations.length && correctSignaturesCount < threshold; i++) {
+            bytes32 digest = reencryptionAttestationDigest(attestations[i]);
+            (address currentSigner, ECDSA.RecoverError err,) = digest.tryRecover(signatures[i]);
+
+            if (err != ECDSA.RecoverError.NoError) {
+                continue;
+            }
+
+            // Duplicate detection (same pattern as SignatureVerifier.isValidSignature)
+            if (currentSigner > lastSigner) {
+                lastSigner = currentSigner;
+            } else {
+                for (uint256 j = 0; j < validCount; ++j) {
+                    if (currentSigner == recoveredSigners[j]) {
+                        return false;
+                    }
+                }
+            }
+
+            recoveredSigners[validCount] = currentSigner;
+            validCount++;
+
+            if (isSigner(currentSigner)) {
+                correctSignaturesCount++;
+            }
+        }
+
+        return correctSignaturesCount >= threshold;
+    }
+
 }

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

@@ -19,3 +19,9 @@ struct ElementAttestationWithProof {
     bytes32 commitment;
     bytes32 value;
 }
+
+struct ReencryptionAttestation {
+    bytes32 handle;
+    bytes userCiphertext;
+    bytes encryptedSignature;
+}

package/src/lightning-parts/interfaces/IDecryptionAttester.sol

@@ -1,7 +1,11 @@
 // SPDX-License-Identifier: No License
 pragma solidity ^0.8;
 
-import {DecryptionAttestation, ElementAttestationWithProof} from "../DecryptionAttester.types.sol";
+import {
+    DecryptionAttestation,
+    ElementAttestationWithProof,
+    ReencryptionAttestation
+} from "../DecryptionAttester.types.sol";
 
 interface IDecryptionAttester {
 
@@ -16,5 +20,10 @@ interface IDecryptionAttester {
         bytes32 proof,
         bytes[] memory signatures
     ) external view returns (bool);
+    function reencryptionAttestationDigest(ReencryptionAttestation memory attestation) external view returns (bytes32);
+    function isValidReencryptionAttestation(
+        ReencryptionAttestation[] calldata attestations,
+        bytes[] calldata signatures
+    ) external view returns (bool);
 
 }