@inco/lightning 0.3.2 → 0.5.0

package/src/lightning-parts/TrivialEncryption.sol

@@ -5,10 +5,10 @@ import {EventCounter} from "./primitives/EventCounter.sol";
 import {euint256, ebool, eaddress, ETypes} from "../Types.sol";
 import {BaseAccessControlList} from "./AccessControl/BaseAccessControlList.sol";
 import {HandleGeneration} from "./primitives/HandleGeneration.sol";
-import {ITrivialEncryptionGen} from "./TrivialEncryption.gen.sol";
+import {ITrivialEncryption} from "./interfaces/ITrivialEncryption.sol";
 
 abstract contract TrivialEncryption is
-    ITrivialEncryptionGen,
+    ITrivialEncryption,
     BaseAccessControlList,
     EventCounter,
     HandleGeneration
@@ -31,7 +31,10 @@ abstract contract TrivialEncryption is
 
     function asEaddress(address value) external returns (eaddress newEaddress) {
         bytes32 castedValue = bytes32(uint256(uint160(value)));
-        return eaddress.wrap(newTrivialEncrypt(castedValue, ETypes.AddressOrUint160OrBytes20));
+        return
+            eaddress.wrap(
+                newTrivialEncrypt(castedValue, ETypes.AddressOrUint160OrBytes20)
+            );
     }
 
     function newTrivialEncrypt(
@@ -40,11 +43,8 @@ abstract contract TrivialEncryption is
     ) internal returns (bytes32 newHandle) {
         newHandle = getTrivialEncryptHandle(plainTextBytes, handleType);
         allowTransientInternal(newHandle, msg.sender);
-        emit TrivialEncrypt(
-            newHandle,
-            plainTextBytes,
-            handleType,
-            getNewEventId()
-        );
+        uint256 id = getNextEventId();
+        emit TrivialEncrypt(newHandle, plainTextBytes, handleType, id);
+        setDigest(abi.encodePacked(newHandle, id));
     }
 }

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

@@ -0,0 +1,9 @@
+// SPDX-License-Identifier: No License
+pragma solidity ^0.8;
+
+import { DecryptionAttestation } from "../DecryptionAttester.types.sol";
+
+interface IDecryptionAttester {
+    function decryptionAttestationDigest(DecryptionAttestation memory decryption) external view returns (bytes32);
+    function isValidDecryptionAttestation(DecryptionAttestation memory decryption, bytes memory signature) external view returns (bool);
+}

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

@@ -0,0 +1,19 @@
+// SPDX-License-Identifier: No License
+pragma solidity ^0.8;
+
+import {euint256, ebool, eaddress} from "../../Types.sol";
+
+interface IEncryptedInput {
+    function newEuint256(
+        bytes memory ciphertext,
+        address user
+    ) external returns (euint256 newValue);
+    function newEbool(
+        bytes memory ciphertext,
+        address user
+    ) external returns (ebool newValue);
+    function newEaddress(
+        bytes memory ciphertext,
+        address user
+    ) external returns (eaddress newValue);
+}

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

@@ -0,0 +1,31 @@
+// SPDX-License-Identifier: No License
+pragma solidity ^0.8;
+
+import {euint256} from "../../Types.sol";
+
+interface IEncryptedOperations {
+    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);
+}

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

@@ -0,0 +1,26 @@
+/// SPDX-License-Identifier: No License
+pragma solidity ^0.8.19;
+
+import {BootstrapResult} from "../TEELifecycle.types.sol";
+import {IQuoteVerifier} from "../../interfaces/automata-interfaces/IQuoteVerifier.sol";
+import {TD10ReportBody} from "../../interfaces/automata-interfaces/Types.sol";
+
+interface ITEELifecycle {
+    function verifyBootstrapResult(
+        BootstrapResult calldata bootstrapResult,
+        bytes calldata quote,
+        bytes calldata signature
+    ) external;
+    function approveNewTEEVersion(bytes calldata newMRTD) external;
+    function addNewCovalidator(bytes calldata quote) external;
+    function parseTD10ReportBody(
+        bytes calldata rawQuote
+    ) external pure returns (TD10ReportBody memory report);
+    function parseReport(
+        TD10ReportBody memory tdReport
+    ) external pure returns (address, bytes memory);
+    function bootstrapResultDigest(
+        BootstrapResult memory bootstrapResult
+    ) external view returns (bytes32);
+    function quoteVerifier() external view returns (IQuoteVerifier);
+}

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

@@ -0,0 +1,10 @@
+// SPDX-License-Identifier: No License
+pragma solidity ^0.8;
+
+import {euint256, ebool, eaddress} from "../../Types.sol";
+
+interface ITrivialEncryption {
+    function asEuint256(uint256 value) external returns (euint256 newEuint256);
+    function asEbool(bool value) external returns (ebool newEbool);
+    function asEaddress(address value) external returns (eaddress newEaddress);
+}

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

@@ -1,10 +1,11 @@
 // SPDX-License-Identifier: No License
 pragma solidity ^0.8;
 
-import {IEventCounterGen} from "./EventCounter.gen.sol";
+import {IEventCounter} from "./interfaces/IEventCounter.sol";
 
 contract EventCounterStorage {
     struct Storage {
+        // TODO: change type to bytes32 when we rename away from "counter".
         uint256 eventCounter;
     }
 
@@ -23,12 +24,23 @@ contract EventCounterStorage {
     }
 }
 
-contract EventCounter is IEventCounterGen, EventCounterStorage {
+contract EventCounter is IEventCounter, EventCounterStorage {
     function getNewEventId() internal returns (uint256 newEventId) {
         newEventId = getEventCounterStorage().eventCounter++;
     }
 
-    function getEventCounter() external view returns (uint256) {
+    function setDigest(bytes memory serialization) internal {
+        getEventCounterStorage().eventCounter = uint256(keccak256(serialization));
+    }
+
+    // @notice Gives the next event ID value to use.
+    function getNextEventId() public view returns (uint256) {
         return getEventCounterStorage().eventCounter;
     }
+
+    // @notice Gives the current value of the event counter.
+    // @dev DEPRECATED: use getNextEventId() instead.
+    function getEventCounter() public view returns (uint256) {
+        return getNextEventId();
+    }
 }

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

@@ -1,11 +1,16 @@
 // SPDX-License-Identifier: No License
 pragma solidity ^0.8;
 
-import {ETypes, EOps, EVM_HOST_CHAIN_PREFIX, HANDLE_INDEX} from "../../Types.sol";
+import {
+    ETypes,
+    EOps,
+    EVM_HOST_CHAIN_PREFIX,
+    HANDLE_INDEX
+} from "../../Types.sol";
 import {HandleMetadata} from "./HandleMetadata.sol";
-import {IHandleGenerationGen} from "./HandleGeneration.gen.sol";
+import {IHandleGeneration} from "./interfaces/IHandleGeneration.sol";
 
-contract HandleGeneration is IHandleGenerationGen, HandleMetadata {
+contract HandleGeneration is IHandleGeneration, HandleMetadata {
     function getTrivialEncryptHandle(
         bytes32 plaintextBytes,
         ETypes handleType

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

@@ -1,7 +1,7 @@
 // SPDX-License-Identifier: No License
 pragma solidity ^0.8;
 
-import {HANDLE_VERSION, HANDLE_INDEX, ETypes} from "../../Types.sol";
+import { HANDLE_VERSION, HANDLE_INDEX, ETypes } from "../../Types.sol";
 
 contract HandleMetadata {
     function embedIndexTypeVersion(

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

@@ -0,0 +1,10 @@
+// SPDX-License-Identifier: No License
+pragma solidity ^0.8;
+
+abstract contract LightningAddressGetter {
+    address internal immutable incoLightningAddress;
+
+    constructor(address _incoLightningAddress) {
+        incoLightningAddress = _incoLightningAddress;
+    }
+}

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

@@ -3,7 +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";
+import {ISignatureVerifier} from "./interfaces/ISignatureVerifier.sol";
 import {TEELifecycle} from "../TEELifecycle.sol";
 
 contract SignatureVerifierStorage {
@@ -28,7 +28,7 @@ contract SignatureVerifierStorage {
     }
 }
 
-contract SignatureVerifier is ISignatureVerifierGen, OwnableUpgradeable, SignatureVerifierStorage {
+abstract contract SignatureVerifier is ISignatureVerifier, OwnableUpgradeable, SignatureVerifierStorage {
     using ECDSA for bytes32;
 
     error SignerNotFound(address signerAddress);
@@ -36,13 +36,6 @@ contract SignatureVerifier is ISignatureVerifierGen, OwnableUpgradeable, Signatu
     event AddedSignatureVerifier(address signerAddress);
     event RemovedSignatureVerifier(address signerAddress);
 
-    // Reference to the TEELifecycle contract, to get the list of EOA signers
-    TEELifecycle teeLifecycle;
-
-    function __SignatureVerifier_init(address _teeLifecycleAddress) internal {
-        teeLifecycle = TEELifecycle(_teeLifecycleAddress);
-    }
-
     // @todo: This function should be removed once we have a way to read the signers from the TEELifecycle contract
     function addSigner(address signerAddress) external onlyOwner {
         getSigVerifierStorage().isSigner[signerAddress] = true;

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

@@ -0,0 +1,13 @@
+// SPDX-License-Identifier: No License
+pragma solidity ^0.8;
+
+import {IIncoVerifier} from "../../interfaces/IIncoVerifier.sol";
+import {IVerifierAddressGetter} from "./interfaces/IVerifierAddressGetter.sol";
+
+abstract contract VerifierAddressGetter is IVerifierAddressGetter {
+    IIncoVerifier public immutable incoVerifier;
+
+    constructor(address _incoVerifier) {
+        incoVerifier = IIncoVerifier(_incoVerifier);
+    }
+}

package/src/lightning-parts/primitives/{EventCounter.gen.sol → interfaces/IEventCounter.sol}

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

package/src/lightning-parts/primitives/interfaces/IHandleGeneration.sol

@@ -0,0 +1,41 @@
+// SPDX-License-Identifier: No License
+pragma solidity ^0.8;
+
+import {ETypes, EOps} from "../../../Types.sol";
+
+interface IHandleGeneration {
+    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/interfaces/ISignatureVerifier.sol

@@ -0,0 +1,9 @@
+// SPDX-License-Identifier: No License
+pragma solidity ^0.8;
+
+interface ISignatureVerifier {
+    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/interfaces/IVerifierAddressGetter.sol

@@ -0,0 +1,8 @@
+// SPDX-License-Identifier: No License
+pragma solidity ^0.8;
+
+import {IIncoVerifier} from "../../../interfaces/IIncoVerifier.sol";
+
+interface IVerifierAddressGetter {
+    function incoVerifier() external view returns (IIncoVerifier);
+}

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

@@ -7,7 +7,14 @@ import {TrivialEncryption} from "../TrivialEncryption.sol";
 import {EncryptedOperations} from "../EncryptedOperations.sol";
 import {EncryptedInput} from "../EncryptedInput.sol";
 import {EIP712} from "@openzeppelin/contracts/utils/cryptography/EIP712.sol";
-import {ETypes, ebool, euint256, eaddress, typeToBitMask} from "../../Types.sol";
+import {
+    ETypes,
+    ebool,
+    euint256,
+    eaddress,
+    typeToBitMask
+} from "../../Types.sol";
+import {VerifierAddressGetter} from "../primitives/VerifierAddressGetter.sol";
 
 contract TestHandleMetadata is
     EIP712,
@@ -17,7 +24,7 @@ contract TestHandleMetadata is
     EncryptedOperations,
     EncryptedInput
 {
-    constructor() EIP712("", "") {}
+    constructor() EIP712("", "") VerifierAddressGetter(address(0)) {}
 
     function testTypeAssignment() public pure {
         bytes32 someHandle = bytes32(keccak256("someHandle"));
@@ -30,8 +37,12 @@ contract TestHandleMetadata is
                 ETypes.Uint256
         );
         assert(
-            typeOf(embedIndexTypeVersion(someHandle, ETypes.AddressOrUint160OrBytes20)) ==
-                ETypes.AddressOrUint160OrBytes20
+            typeOf(
+                embedIndexTypeVersion(
+                    someHandle,
+                    ETypes.AddressOrUint160OrBytes20
+                )
+            ) == ETypes.AddressOrUint160OrBytes20
         );
     }
 
@@ -40,7 +51,9 @@ contract TestHandleMetadata is
         assert(typeOf(boolHandle) == ETypes.Bool);
         bytes32 uintHandle = euint256.unwrap(this.asEuint256(42));
         assert(typeOf(uintHandle) == ETypes.Uint256);
-        bytes32 addressHandle = eaddress.unwrap(this.asEaddress(address(0xdeadbeef)));
+        bytes32 addressHandle = eaddress.unwrap(
+            this.asEaddress(address(0xdeadbeef))
+        );
         assert(typeOf(addressHandle) == ETypes.AddressOrUint160OrBytes20);
     }
 
@@ -70,7 +83,13 @@ contract TestHandleMetadata is
                 this.eIfThenElse(control, ebool.unwrap(c), ebool.unwrap(d))
             ) == ETypes.Bool
         );
-        assert(typeOf(ebool.unwrap(this.eEq(eaddress.unwrap(addr1), eaddress.unwrap(addr2)))) == ETypes.Bool);
+        assert(
+            typeOf(
+                ebool.unwrap(
+                    this.eEq(eaddress.unwrap(addr1), eaddress.unwrap(addr2))
+                )
+            ) == ETypes.Bool
+        );
     }
 
     function testEIfThenElseChecksTypeCoherence() public {

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

@@ -0,0 +1,78 @@
+// SPDX-License-Identifier: No License
+pragma solidity ^0.8;
+
+import {IncoTest} from "../../test/IncoTest.sol";
+import {DemoToken} from "@inco/confidential-token-demo/src/DemoToken.sol";
+import {DecryptionAttestation} from "../DecryptionAttester.types.sol";
+import {GWEI} from "@inco/shared/src/TypeUtils.sol";
+import {euint256} from "@inco/lightning/src/Lib.sol"; // import via remapping or compiler fails
+import {AllowanceProof} from "../AccessControl/AdvancedAccessControl.sol";
+import {inco} from "../../Lib.sol";
+import {euint256 as remappedEuint256} from "@inco/lightning/src/Lib.sol";
+
+contract TokenBurnCurrentBalance is DemoToken {
+    function burnFullCurrentBalance(
+        DecryptionAttestation memory decryption,
+        bytes memory signature
+    ) public {
+        euint256 currentBalance = confidentialBalanceOf(msg.sender);
+        require(
+            inco.incoVerifier().isValidDecryptionAttestation(
+                decryption,
+                signature
+            ),
+            "Invalid Signature"
+        );
+        require(
+            euint256.unwrap(currentBalance) == decryption.handle,
+            "Handle mismatch"
+        );
+        publicBurn(msg.sender, uint256(decryption.value));
+    }
+}
+
+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();
+        token.confidentialTransfer(
+            alice,
+            fakePrepareEuint256Ciphertext(10 * GWEI),
+            ""
+        );
+        processAllOperations(); // saves Alice's balance
+        bytes32 aliceCurrentBalanceHandle = euint256.unwrap(
+            token.confidentialBalanceOf(alice)
+        );
+        // simulates Alice requesting for a decryption attestation of Ge op on her balance and the amount
+        // she intends to burn, therefore proving to the token contract that the operation will succeed
+        (
+            DecryptionAttestation memory decryption,
+            bytes memory signature
+        ) = getDecryptionAttestation(
+                alice,
+                HandleWithProof({
+                    handle: aliceCurrentBalanceHandle,
+                    proof: emptyProof
+                })
+            );
+        vm.prank(alice);
+
+        // the decryption attestation is passed to the token burn method
+        token.burnFullCurrentBalance(decryption, signature);
+
+        processAllOperations();
+
+        remappedEuint256 remappedFinalAliceBalance = token
+            .confidentialBalanceOf(alice);
+        bytes32 finalAliceBalance = remappedEuint256.unwrap(
+            remappedFinalAliceBalance
+        ); // compilation trick
+
+        assertEq(
+            uint256(get(finalAliceBalance)),
+            0,
+            "Alice should have burned all her tokens"
+        );
+    }
+}

package/src/periphery/SessionVerifier.sol

@@ -0,0 +1,63 @@
+// SPDX-License-Identifier: No License
+pragma solidity ^0.8;
+
+import {UUPSUpgradeable} from "@openzeppelin/contracts/proxy/utils/UUPSUpgradeable.sol";
+import {OwnableUpgradeable} from "@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol";
+import {
+    SESSION_VERIFIER_NAME,
+    SESSION_VERIFIER_MAJOR_VERSION,
+    SESSION_VERIFIER_MINOR_VERSION,
+    SESSION_VERIFIER_PATCH_VERSION
+} from "../version/SessionVerifierConfig.sol";
+import {Version} from "../version/Version.sol";
+import {ALLOWANCE_GRANTED_MAGIC_VALUE} from "../Types.sol";
+
+/// @notice a Session grants a temporary access to a decrypter to all data held by the sharer
+/// @dev abi encode this struct in the sharerArgData field of the voucher
+struct Session {
+    address decrypter;
+    uint256 expiresAt;
+}
+
+/// @notice Inco access sharing verifier mainly meant for browser dapp sessions, grants access to all data held by
+/// the sharer to one decrypter for a limited time.
+/// @dev define the selector of canUseSession in the voucher to use this verifier
+contract SessionVerifier is UUPSUpgradeable, OwnableUpgradeable, Version {
+    constructor(
+        bytes32 salt
+    )
+        Version(
+            SESSION_VERIFIER_MAJOR_VERSION,
+            SESSION_VERIFIER_MINOR_VERSION,
+            SESSION_VERIFIER_PATCH_VERSION,
+            salt,
+            SESSION_VERIFIER_NAME
+        )
+    {}
+
+    // todo add text mention of what is being signed
+    function canUseSession(
+        bytes32 /* handle */,
+        address account,
+        bytes memory sharerArgData,
+        bytes memory /* requesterArgData */
+    ) external view returns (bytes32) {
+        Session memory session = abi.decode(sharerArgData, (Session));
+        if (
+            session.expiresAt >= block.timestamp && session.decrypter == account
+        ) {
+            return ALLOWANCE_GRANTED_MAGIC_VALUE;
+        }
+        return bytes32(0);
+    }
+
+    function _authorizeUpgrade(address) internal view override {
+        require(msg.sender == owner());
+    }
+
+    function initialize(address owner) public initializer {
+        __Ownable_init(owner);
+    }
+
+    fallback() external {} // must be included for createX deploy
+}

package/src/test/AddTwo.sol

@@ -1,11 +1,15 @@
 // SPDX-License-Identifier: No License
 pragma solidity ^0.8;
 
-import {IncoLightning} from "../IncoLightning.sol";
 import {euint256} from "../Types.sol";
+import {IncoLightning} from "../IncoLightning.sol";
+
+// import {console} from "forge-std/console.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 {
-    IncoLightning immutable inco;
+    IncoLightning inco;
 
     constructor(IncoLightning _inco) {
         inco = _inco;
@@ -14,37 +18,29 @@ contract AddTwo {
     // Stores the result of the last callback.
     uint256 public lastResult;
 
-    function addTwo(euint256 a) external returns (euint256) {
-        uint256 two = 2;
-        return inco.eAdd(a, inco.asEuint256(two));
+    function addTwo(euint256 a) public returns (euint256) {
+        euint256 two = inco.asEuint256(2);
+        return inco.eAdd(a, two);
     }
 
-    function addTwoScalar(euint256 a) external returns (euint256) {
-        uint256 two = 2;
-        return inco.eAdd(a, inco.asEuint256(two));
+    // To generate a different handle with the same result, instead of adding 2 we add 1 + 1
+    function addTwoAlt(euint256 a) public returns (euint256) {
+        euint256 one = inco.asEuint256(1);
+        return inco.eAdd(a, inco.eAdd(one, one));
     }
 
     function addTwoEOA(
         bytes memory uint256EInput
-    ) external returns (uint256, euint256) {
+    ) external returns (euint256 result, euint256 resultRevealed) {
         euint256 value = inco.newEuint256(uint256EInput, msg.sender);
-        euint256 result = this.addTwo(value);
+        result = addTwo(value);
+
         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);
-    }
 
-    function callback(
-        uint256 /* requestId */,
-        uint256 result,
-        bytes memory /* data */
-    ) external {
-        lastResult = result;
+        // Used to test attested reveal functionality.
+        // Note that msg.sender is not allowed, instead we call .reveal() that gives permission to anyone.
+        resultRevealed = addTwoAlt(value);
+        inco.reveal(euint256.unwrap(resultRevealed));
     }
 }