@inco/lightning 0.7.10 → 0.8.0-devnet

package/manifest.yaml

@@ -1,3 +1,25 @@
+incoLightning_devnet_v3_976859633:
+  executor:
+    name: incoLightning_devnet_v3_976859633
+    majorVersion: 3
+    deployer: "0x8202D2D747784Cb7D48868E44C42C4bf162a70BC"
+    pepper: devnet
+    executorAddress: "0x4732520194584a04Cac0224e067658619F4086bD"
+    salt: "0x8202d2d747784cb7d48868e44c42c4bf162a70bc00ef1fab551c72a93b0637f1"
+  deployments:
+    - name: incoLightningPreview_3_0_0__976859633
+      chainId: "84532"
+      chainName: Base Sepolia
+      version:
+        major: 3
+        minor: 0
+        patch: 0
+        shortSalt: "976859633"
+      blockNumber: "36099996"
+      deployDate: 2026-01-09T14:18:04.212Z
+      commit: v0.7.9-7-g63b3d823-dirty
+      active: true
+      includesPreviewFeatures: true
 incoLightning_testnet_v2_889158349:
   executor:
     name: incoLightning_testnet_v2_889158349

package/package.json

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

package/src/Lib.devnet.sol

@@ -8,7 +8,7 @@ pragma solidity ^0.8;
 import { IncoLightning } from "./IncoLightning.sol";
 import { ebool, euint256, eaddress, ETypes } from "./Types.sol";
 
-IncoLightning constant inco = IncoLightning(0xC64BB070D6F5aa796e79fA19c1008647ffF736ED);
+IncoLightning constant inco = IncoLightning(0x4732520194584a04Cac0224e067658619F4086bD);
 address constant deployedBy = 0x8202D2D747784Cb7D48868E44C42C4bf162a70BC;
 
 function typeOf(bytes32 handle) pure returns (ETypes) {

package/src/Lib.sol

@@ -8,7 +8,7 @@ pragma solidity ^0.8;
 import { IncoLightning } from "./IncoLightning.sol";
 import { ebool, euint256, eaddress, ETypes } from "./Types.sol";
 
-IncoLightning constant inco = IncoLightning(0x168FDc3Ae19A5d5b03614578C58974FF30FCBe92);
+IncoLightning constant inco = IncoLightning(0x4732520194584a04Cac0224e067658619F4086bD);
 address constant deployedBy = 0x8202D2D747784Cb7D48868E44C42C4bf162a70BC;
 
 function typeOf(bytes32 handle) pure returns (ETypes) {

package/src/libs/incoLightning_devnet_v3_976859633.sol

@@ -0,0 +1,478 @@
+// AUTOGENERATED FILE. DO NOT EDIT.
+// This file was generated by the IncoLightning library generator.
+// The original template is located at Lib.template.sol
+
+/// SPDX-License-Identifier: No License
+pragma solidity ^0.8;
+
+import { IncoLightning } from "../IncoLightning.sol";
+import { ebool, euint256, eaddress, ETypes } from "../Types.sol";
+
+IncoLightning constant inco = IncoLightning(0x4732520194584a04Cac0224e067658619F4086bD);
+address constant deployedBy = 0x8202D2D747784Cb7D48868E44C42C4bf162a70BC;
+
+function typeOf(bytes32 handle) pure returns (ETypes) {
+    return ETypes(uint8(uint256(handle) >> 8));
+}
+
+library e {
+    function sanitize(euint256 a) internal returns (euint256) {
+        if (euint256.unwrap(a) == bytes32(0)) {
+            return asEuint256(0);
+        }
+        return a;
+    }
+
+    function sanitize(ebool a) internal returns (ebool) {
+        if (ebool.unwrap(a) == bytes32(0)) {
+            return asEbool(false);
+        }
+        return a;
+    }
+
+    function sanitize(eaddress a) internal returns (eaddress) {
+        if (eaddress.unwrap(a) == bytes32(0)) {
+            return asEaddress(address(0));
+        }
+        return a;
+    }
+
+    function s(euint256 a) internal returns (euint256) {
+        return sanitize(a);
+    }
+
+    function s(ebool a) internal returns (ebool) {
+        return sanitize(a);
+    }
+
+    function s(eaddress a) internal returns (eaddress) {
+        return sanitize(a);
+    }
+
+    function add(euint256 a, euint256 b) internal returns (euint256) {
+        return inco.eAdd(s(a), s(b));
+    }
+
+    function add(euint256 a, uint256 b) internal returns (euint256) {
+        return inco.eAdd(s(a), asEuint256(b));
+    }
+
+    function add(uint256 a, euint256 b) internal returns (euint256) {
+        return inco.eAdd(asEuint256(a), s(b));
+    }
+
+    function sub(euint256 a, euint256 b) internal returns (euint256) {
+        return inco.eSub(s(a), s(b));
+    }
+
+    function sub(euint256 a, uint256 b) internal returns (euint256) {
+        return inco.eSub(s(a), asEuint256(b));
+    }
+
+    function sub(uint256 a, euint256 b) internal returns (euint256) {
+        return inco.eSub(asEuint256(a), s(b));
+    }
+
+    function mul(euint256 a, euint256 b) internal returns (euint256) {
+        return inco.eMul(s(a), s(b));
+    }
+
+    function mul(euint256 a, uint256 b) internal returns (euint256) {
+        return inco.eMul(s(a), asEuint256(b));
+    }
+
+    function mul(uint256 a, euint256 b) internal returns (euint256) {
+        return inco.eMul(asEuint256(a), s(b));
+    }
+
+    function div(euint256 a, euint256 b) internal returns (euint256) {
+        return inco.eDiv(s(a), s(b));
+    }
+
+    function div(euint256 a, uint256 b) internal returns (euint256) {
+        return inco.eDiv(s(a), asEuint256(b));
+    }
+
+    function div(uint256 a, euint256 b) internal returns (euint256) {
+        return inco.eDiv(asEuint256(a), s(b));
+    }
+
+    function rem(euint256 a, euint256 b) internal returns (euint256) {
+        return inco.eRem(s(a), s(b));
+    }
+
+    function rem(euint256 a, uint256 b) internal returns (euint256) {
+        return inco.eRem(s(a), asEuint256(b));
+    }
+
+    function rem(uint256 a, euint256 b) internal returns (euint256) {
+        return inco.eRem(asEuint256(a), s(b));
+    }
+
+    function and(euint256 a, euint256 b) internal returns (euint256) {
+        return euint256.wrap(inco.eBitAnd(euint256.unwrap(s(a)), euint256.unwrap(s(b))));
+    }
+
+    function and(euint256 a, uint256 b) internal returns (euint256) {
+        return euint256.wrap(inco.eBitAnd(euint256.unwrap(s(a)), euint256.unwrap(asEuint256(b))));
+    }
+
+    function and(uint256 a, euint256 b) internal returns (euint256) {
+        return euint256.wrap(inco.eBitAnd(euint256.unwrap(asEuint256(a)), euint256.unwrap(s(b))));
+    }
+
+    function and(ebool a, ebool b) internal returns (ebool) {
+        return ebool.wrap(inco.eBitAnd(ebool.unwrap(s(a)), ebool.unwrap(s(b))));
+    }
+
+    function and(ebool a, bool b) internal returns (ebool) {
+        return ebool.wrap(inco.eBitAnd(ebool.unwrap(s(a)), ebool.unwrap(asEbool(b))));
+    }
+
+    function and(bool a, ebool b) internal returns (ebool) {
+        return ebool.wrap(inco.eBitAnd(ebool.unwrap(asEbool(a)), ebool.unwrap(s(b))));
+    }
+
+    function or(euint256 a, euint256 b) internal returns (euint256) {
+        return euint256.wrap(inco.eBitOr(euint256.unwrap(s(a)), euint256.unwrap(s(b))));
+    }
+
+    function or(euint256 a, uint256 b) internal returns (euint256) {
+        return euint256.wrap(inco.eBitOr(euint256.unwrap(s(a)), euint256.unwrap(asEuint256(b))));
+    }
+
+    function or(uint256 a, euint256 b) internal returns (euint256) {
+        return euint256.wrap(inco.eBitOr(euint256.unwrap(asEuint256(a)), euint256.unwrap(s(b))));
+    }
+
+    function or(ebool a, ebool b) internal returns (ebool) {
+        return ebool.wrap(inco.eBitOr(ebool.unwrap(s(a)), ebool.unwrap(s(b))));
+    }
+
+    function or(ebool a, bool b) internal returns (ebool) {
+        return ebool.wrap(inco.eBitOr(ebool.unwrap(s(a)), ebool.unwrap(asEbool(b))));
+    }
+
+    function or(bool a, ebool b) internal returns (ebool) {
+        return ebool.wrap(inco.eBitOr(ebool.unwrap(asEbool(a)), ebool.unwrap(s(b))));
+    }
+
+    function xor(euint256 a, euint256 b) internal returns (euint256) {
+        return euint256.wrap(inco.eBitXor(euint256.unwrap(s(a)), euint256.unwrap(s(b))));
+    }
+
+    function xor(euint256 a, uint256 b) internal returns (euint256) {
+        return euint256.wrap(inco.eBitXor(euint256.unwrap(s(a)), euint256.unwrap(asEuint256(b))));
+    }
+
+    function xor(uint256 a, euint256 b) internal returns (euint256) {
+        return euint256.wrap(inco.eBitXor(euint256.unwrap(asEuint256(a)), euint256.unwrap(s(b))));
+    }
+
+    function xor(ebool a, ebool b) internal returns (ebool) {
+        return ebool.wrap(inco.eBitXor(ebool.unwrap(s(a)), ebool.unwrap(s(b))));
+    }
+
+    function xor(ebool a, bool b) internal returns (ebool) {
+        return ebool.wrap(inco.eBitXor(ebool.unwrap(s(a)), ebool.unwrap(asEbool(b))));
+    }
+
+    function xor(bool a, ebool b) internal returns (ebool) {
+        return ebool.wrap(inco.eBitXor(ebool.unwrap(asEbool(a)), ebool.unwrap(s(b))));
+    }
+
+    function shl(euint256 a, euint256 b) internal returns (euint256) {
+        return inco.eShl(s(a), s(b));
+    }
+
+    function shl(euint256 a, uint256 b) internal returns (euint256) {
+        return inco.eShl(s(a), asEuint256(b));
+    }
+
+    function shl(uint256 a, euint256 b) internal returns (euint256) {
+        return inco.eShl(asEuint256(a), s(b));
+    }
+
+    function shr(euint256 a, euint256 b) internal returns (euint256) {
+        return inco.eShr(s(a), s(b));
+    }
+
+    function shr(euint256 a, uint256 b) internal returns (euint256) {
+        return inco.eShr(s(a), asEuint256(b));
+    }
+
+    function shr(uint256 a, euint256 b) internal returns (euint256) {
+        return inco.eShr(asEuint256(a), s(b));
+    }
+
+    function rotl(euint256 a, euint256 b) internal returns (euint256) {
+        return inco.eRotl(s(a), s(b));
+    }
+
+    function rotl(euint256 a, uint256 b) internal returns (euint256) {
+        return inco.eRotl(s(a), asEuint256(b));
+    }
+
+    function rotl(uint256 a, euint256 b) internal returns (euint256) {
+        return inco.eRotl(asEuint256(a), s(b));
+    }
+
+    function rotr(euint256 a, euint256 b) internal returns (euint256) {
+        return inco.eRotr(s(a), s(b));
+    }
+
+    function rotr(euint256 a, uint256 b) internal returns (euint256) {
+        return inco.eRotr(s(a), asEuint256(b));
+    }
+
+    function rotr(uint256 a, euint256 b) internal returns (euint256) {
+        return inco.eRotr(asEuint256(a), s(b));
+    }
+
+    function eq(euint256 a, euint256 b) internal returns (ebool) {
+        return inco.eEq(euint256.unwrap(s(a)), euint256.unwrap(s(b)));
+    }
+
+    function eq(euint256 a, uint256 b) internal returns (ebool) {
+        return inco.eEq(euint256.unwrap(s(a)), euint256.unwrap(asEuint256(b)));
+    }
+
+    function eq(uint256 a, euint256 b) internal returns (ebool) {
+        return inco.eEq(euint256.unwrap(asEuint256(a)), euint256.unwrap(s(b)));
+    }
+
+    function eq(eaddress a, address b) internal returns (ebool) {
+        return inco.eEq(eaddress.unwrap(s(a)), eaddress.unwrap(asEaddress(b)));
+    }
+
+    function eq(eaddress a, eaddress b) internal returns (ebool) {
+        return inco.eEq(eaddress.unwrap(s(a)), eaddress.unwrap(s(b)));
+    }
+
+    function eq(address a, eaddress b) internal returns (ebool) {
+        return inco.eEq(eaddress.unwrap(asEaddress(a)), eaddress.unwrap(s(b)));
+    }
+
+    function ne(euint256 a, euint256 b) internal returns (ebool) {
+        return inco.eNe(euint256.unwrap(s(a)), euint256.unwrap(s(b)));
+    }
+
+    function ne(euint256 a, uint256 b) internal returns (ebool) {
+        return inco.eNe(euint256.unwrap(s(a)), euint256.unwrap(asEuint256(b)));
+    }
+
+    function ne(uint256 a, euint256 b) internal returns (ebool) {
+        return inco.eNe(euint256.unwrap(asEuint256(a)), euint256.unwrap(s(b)));
+    }
+
+    function ne(eaddress a, eaddress b) internal returns (ebool) {
+        return inco.eNe(eaddress.unwrap(s(a)), eaddress.unwrap(s(b)));
+    }
+
+    function ne(eaddress a, address b) internal returns (ebool) {
+        return inco.eNe(eaddress.unwrap(s(a)), eaddress.unwrap(asEaddress(b)));
+    }
+
+    function ne(address a, eaddress b) internal returns (ebool) {
+        return inco.eNe(eaddress.unwrap(asEaddress(a)), eaddress.unwrap(s(b)));
+    }
+
+    function ge(euint256 a, euint256 b) internal returns (ebool) {
+        return inco.eGe(s(a), s(b));
+    }
+
+    function ge(euint256 a, uint256 b) internal returns (ebool) {
+        return inco.eGe(s(a), asEuint256(b));
+    }
+
+    function ge(uint256 a, euint256 b) internal returns (ebool) {
+        return inco.eGe(asEuint256(a), s(b));
+    }
+
+    function gt(euint256 a, euint256 b) internal returns (ebool) {
+        return inco.eGt(s(a), s(b));
+    }
+
+    function gt(euint256 a, uint256 b) internal returns (ebool) {
+        return inco.eGt(s(a), asEuint256(b));
+    }
+
+    function gt(uint256 a, euint256 b) internal returns (ebool) {
+        return inco.eGt(asEuint256(a), s(b));
+    }
+
+    function le(euint256 a, euint256 b) internal returns (ebool) {
+        return inco.eLe(s(a), s(b));
+    }
+
+    function le(euint256 a, uint256 b) internal returns (ebool) {
+        return inco.eLe(s(a), asEuint256(b));
+    }
+
+    function le(uint256 a, euint256 b) internal returns (ebool) {
+        return inco.eLe(asEuint256(a), s(b));
+    }
+
+    function lt(euint256 a, euint256 b) internal returns (ebool) {
+        return inco.eLt(s(a), s(b));
+    }
+
+    function lt(euint256 a, uint256 b) internal returns (ebool) {
+        return inco.eLt(s(a), asEuint256(b));
+    }
+
+    function lt(uint256 a, euint256 b) internal returns (ebool) {
+        return inco.eLt(asEuint256(a), s(b));
+    }
+
+    function min(euint256 a, euint256 b) internal returns (euint256) {
+        return inco.eMin(s(a), s(b));
+    }
+
+    function min(euint256 a, uint256 b) internal returns (euint256) {
+        return inco.eMin(s(a), asEuint256(b));
+    }
+
+    function min(uint256 a, euint256 b) internal returns (euint256) {
+        return inco.eMin(asEuint256(a), s(b));
+    }
+
+    function max(euint256 a, euint256 b) internal returns (euint256) {
+        return inco.eMax(s(a), s(b));
+    }
+
+    function max(euint256 a, uint256 b) internal returns (euint256) {
+        return inco.eMax(s(a), asEuint256(b));
+    }
+
+    function max(uint256 a, euint256 b) internal returns (euint256) {
+        return inco.eMax(asEuint256(a), s(b));
+    }
+
+    function not(ebool a) internal returns (ebool) {
+        return inco.eNot(s(a));
+    }
+
+    /// @dev costs the inco fee
+    function rand() internal returns (euint256) {
+        return euint256.wrap(inco.eRand{value: inco.getFee()}(ETypes.Uint256));
+    }
+
+    /// @dev costs the inco fee
+    function randBounded(uint256 upperBound) internal returns (euint256) {
+        return euint256.wrap(inco.eRandBounded{value: inco.getFee()}(euint256.unwrap(asEuint256(upperBound)), ETypes.Uint256));
+    }
+
+    /// @dev costs the inco fee
+    function randBounded(euint256 upperBound) internal returns (euint256) {
+        return euint256.wrap(inco.eRandBounded{value: inco.getFee()}(euint256.unwrap(s(upperBound)), ETypes.Uint256));
+    }
+
+    function asEuint256(uint256 a) internal returns (euint256) {
+        return inco.asEuint256(a);
+    }
+
+    function asEbool(bool a) internal returns (ebool) {
+        return inco.asEbool(a);
+    }
+
+    function asEaddress(address a) internal returns (eaddress) {
+        return inco.asEaddress(a);
+    }
+
+    function asEbool(euint256 a) internal returns (ebool) {
+        return ebool.wrap(inco.eCast(euint256.unwrap(a), ETypes.Bool));
+    }
+
+    function asEuint256(ebool a) internal returns (euint256) {
+        return euint256.wrap(inco.eCast(ebool.unwrap(a), ETypes.Uint256));
+    }
+
+    /// @notice Creates a new encrypted uint256 assuming msg.sender is the user
+    ///  @dev costs the inco fee
+    function newEuint256(bytes memory ciphertext) internal returns (euint256) {
+        return newEuint256(ciphertext, msg.sender);
+    }
+
+    /// @notice Creates a new encrypted uint256 for the given user.
+    ///  @dev costs the inco fee
+    function newEuint256(bytes memory ciphertext, address user) internal returns (euint256) {
+        return inco.newEuint256{value: inco.getFee()}(ciphertext, user);
+    }
+
+    /// @notice Creates a new encrypted bool assuming msg.sender is the user
+    ///  @dev costs the inco fee
+    function newEbool(bytes memory ciphertext) internal returns (ebool) {
+        return newEbool(ciphertext, msg.sender);
+    }
+
+    /// @notice Creates a new encrypted bool for the given user.
+    ///  @dev costs the inco fee
+    function newEbool(bytes memory ciphertext, address user) internal returns (ebool) {
+        return inco.newEbool{value: inco.getFee()}(ciphertext, user);
+    }
+
+    /// @notice Creates a new encrypted address assuming msg.sender is the user
+    ///  @dev costs the inco fee
+    function newEaddress(bytes memory ciphertext) internal returns (eaddress) {
+        return newEaddress(ciphertext, msg.sender);
+    }
+
+    /// @notice Creates a new encrypted address for the given user.
+    ///  @dev costs the inco fee
+    function newEaddress(bytes memory ciphertext, address user) internal returns (eaddress) {
+        return inco.newEaddress{value: inco.getFee()}(ciphertext, user);
+    }
+
+    function allow(euint256 a, address to) internal {
+        inco.allow(euint256.unwrap(a), to);
+    }
+
+    function allow(ebool a, address to) internal {
+        inco.allow(ebool.unwrap(a), to);
+    }
+
+    function allow(eaddress a, address to) internal {
+        inco.allow(eaddress.unwrap(a), to);
+    }
+
+    function reveal(euint256 a) internal {
+        inco.reveal(euint256.unwrap(a));
+    }
+
+    function reveal(ebool a) internal {
+        inco.reveal(ebool.unwrap(a));
+    }
+
+    function reveal(eaddress a) internal {
+        inco.reveal(eaddress.unwrap(a));
+    }
+
+    function allowThis(euint256 a) internal {
+        allow(a, address(this));
+    }
+
+    function allowThis(ebool a) internal {
+        allow(a, address(this));
+    }
+
+    function allowThis(eaddress a) internal {
+        allow(a, address(this));
+    }
+
+    function isAllowed(address user, euint256 a) internal view returns (bool) {
+        return inco.isAllowed(euint256.unwrap(a), user);
+    }
+
+    function select(ebool control, euint256 ifTrue, euint256 ifFalse) internal returns (euint256) {
+        return euint256.wrap(inco.eIfThenElse(s(control), euint256.unwrap(s(ifTrue)), euint256.unwrap(s(ifFalse))));
+    }
+
+    function select(ebool control, ebool ifTrue, ebool ifFalse) internal returns (ebool) {
+        return ebool.wrap(inco.eIfThenElse(s(control), ebool.unwrap(s(ifTrue)), ebool.unwrap(s(ifFalse))));
+    }
+
+    function select(ebool control, eaddress ifTrue, eaddress ifFalse) internal returns (eaddress) {
+        return eaddress.wrap(inco.eIfThenElse(s(control), eaddress.unwrap(s(ifTrue)), eaddress.unwrap(s(ifFalse))));
+    }
+}

package/src/lightning-parts/Fee.sol

@@ -2,7 +2,7 @@
 pragma solidity ^0.8;
 
 // the fee should be modified through upgrades to limit gas cost
-uint256 constant FEE = 0.0001 ether;
+uint256 constant FEE = 0.000001 ether;
 
 /// @notice Fee utils for lightning functions that require a fee
 /// @dev the fee may be changed through upgrades, develop your apps accordingly!

package/src/lightning-parts/TEELifecycle.sol

@@ -29,8 +29,7 @@ contract TEELifecycleStorage {
         // @dev The index of the TEE version is the version number
         bytes32[] approvedTeeVersions;
         // @notice The Network key
-        // @todo rename to NetworkPubkey https://github.com/Inco-fhevm/inco-monorepo/issues/983
-        bytes eciesPubkey;
+        bytes networkPubkey;
     }
 
     bytes32 private constant TEE_LIFECYCLE_STORAGE_LOCATION = keccak256("inco.storage.TEELifecycle");
@@ -80,9 +79,9 @@ abstract contract TEELifecycle is
     event SignerHasUpdatedTDX(address indexed eoaSigner, bytes32 indexed mrAggregated);
 
     // Constants
-    bytes32 public constant BOOTSTRAP_RESULT_STRUCT_HASH = keccak256(bytes("BootstrapResult(bytes ecies_pubkey)"));
-    bytes32 public constant UPGRADE_RESULT_STRUCT_HASH = keccak256(bytes("UpgradeResult(bytes network_pubkey)"));
-    bytes32 public constant ADD_NODE_RESULT_STRUCT_HASH = keccak256(bytes("AddNodeResult(bytes network_pubkey)"));
+    bytes32 public constant BOOTSTRAP_RESULT_STRUCT_HASH = keccak256(bytes("BootstrapResult(bytes networkPubkey)"));
+    bytes32 public constant UPGRADE_RESULT_STRUCT_HASH = keccak256(bytes("UpgradeResult(bytes networkPubkey)"));
+    bytes32 public constant ADD_NODE_RESULT_STRUCT_HASH = keccak256(bytes("AddNodeResult(bytes networkPubkey)"));
 
     uint16 public constant QUOTE_VERIFIER_VERSION = 4;
 
@@ -141,7 +140,7 @@ abstract contract TEELifecycle is
 
         // Update contract publicly viewable state
         addSigner(reportDataSigner);
-        $.eciesPubkey = bootstrapResult.ecies_pubkey;
+        $.networkPubkey = bootstrapResult.networkPubkey;
 
         emit BootstrapStageComplete(reportDataSigner, bootstrapResult);
     }
@@ -163,7 +162,7 @@ abstract contract TEELifecycle is
 
         require(isBootstrapComplete(), BootstrapNotComplete());
         // Make sure the quote's network pubkey is the same as the one in the bootstrap result
-        require(keccak256($.eciesPubkey) == keccak256(upgradeResult.networkPubkey), InvalidNetworkPubkey());
+        require(keccak256($.networkPubkey) == keccak256(upgradeResult.networkPubkey), InvalidNetworkPubkey());
         // Make sure the new MR_AGGREGATED has been pre-approved.
         bool isApproved = _isApprovedTeeVersion(newMrAggregated);
         require(isApproved, TEEVersionNotFound());
@@ -188,7 +187,7 @@ abstract contract TEELifecycle is
 
         require(isBootstrapComplete(), BootstrapNotComplete());
         // Make sure the quote's network pubkey is the same as the one in the bootstrap result
-        require(keccak256($.eciesPubkey) == keccak256(addNodeResult.networkPubkey), InvalidNetworkPubkey());
+        require(keccak256($.networkPubkey) == keccak256(addNodeResult.networkPubkey), InvalidNetworkPubkey());
         // Make sure the new MR_AGGREGATED has been pre-approved.
         bool isApproved = _isApprovedTeeVersion(newMrAggregated);
         require(isApproved, TEEVersionNotFound());
@@ -257,7 +256,7 @@ abstract contract TEELifecycle is
     function isBootstrapComplete() public view returns (bool) {
         // The network pubkey is set once and once only, during the bootstrap process
         // So we can use the length of the network pubkey to check if the bootstrap is complete
-        return getTeeLifecycleStorage().eciesPubkey.length > 0;
+        return getTeeLifecycleStorage().networkPubkey.length > 0;
     }
 
     /**
@@ -384,14 +383,14 @@ abstract contract TEELifecycle is
         return $.approvedTeeVersions[index];
     }
 
-    function eciesPubkey() external view returns (bytes memory) {
-        return getTeeLifecycleStorage().eciesPubkey;
+    function networkPubkey() external view returns (bytes memory) {
+        return getTeeLifecycleStorage().networkPubkey;
     }
 
     function bootstrapResultDigest(BootstrapResult memory bootstrapResult) public view returns (bytes32) {
         return
             _hashTypedDataV4(
-                keccak256(abi.encode(BOOTSTRAP_RESULT_STRUCT_HASH, keccak256(bootstrapResult.ecies_pubkey)))
+                keccak256(abi.encode(BOOTSTRAP_RESULT_STRUCT_HASH, keccak256(bootstrapResult.networkPubkey)))
             );
     }
 

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

@@ -5,10 +5,7 @@ pragma solidity ^0.8.19;
  * @notice A struct representing what the TDX EOA signs during the bootstrap process.
  */
 struct BootstrapResult {
-    // TODO: rename to networkPubkey
-    // https://github.com/Inco-fhevm/inco-monorepo/issues/983
-    // forge-lint: disable-next-line(mixed-case-variable)
-    bytes ecies_pubkey;
+    bytes networkPubkey;
 }
 
 /**

package/src/test/FakeIncoInfra/MockRemoteAttestation.sol

@@ -43,7 +43,7 @@ contract MockRemoteAttestation is TestUtils {
     // Helper function to create a successful bootstrap result
     function successfulBootstrapResult(
         ITEELifecycle teeLifecycle,
-        bytes memory eciesPublicKey,
+        bytes memory networkPubkey,
         address signer,
         uint256 signerPrivKey
     )
@@ -55,14 +55,13 @@ contract MockRemoteAttestation is TestUtils {
             bytes32 mrAggregated
         )
     {
-        bytes memory eciesPubkey = eciesPublicKey;
         // See DEFAULT_MRTD in attestation/src/remote_attestation.rs
         bytes memory mrtd =
             hex"010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101";
         // See DEFAULT_MR_AGGREGATED in attestation/src/remote_attestation.rs to
         // see the calculation of the default value.
         mrAggregated = hex"c3a67bac251d4946d7b17481d39631676042fe3afab06e70c22105ad8383c19f";
-        bootstrapResult = BootstrapResult({ecies_pubkey: eciesPubkey});
+        bootstrapResult = BootstrapResult({networkPubkey: networkPubkey});
 
         quote = createQuote(mrtd, signer);
         signature = signBootstrapResult(bootstrapResult, signerPrivKey, teeLifecycle);

package/src/test/IncoTest.sol

@@ -39,12 +39,12 @@ contract IncoTest is MockOpHandler, DeployUtils, FakeDecryptionAttester, MockRem
     function setUp() public virtual {
         deployCreateX();
         vm.startPrank(testDeployer);
-        vm.setEnv("USE_TDX_HW", "false"); // results in the test deployment using the FakeQuoteVerifier
+        vm.setEnv("SHOULD_SETUP_TEE_SIGNER", "true"); // results in a network pubkey and decrypt signer being populated in the TEE Lifecycle
         (IIncoLightning proxy,) = deployIncoLightningUsingConfig({
             deployer: testDeployer,
             // The highest precedent deployment
             // We select the pepper that will be used that will be generated in the lib.sol (usually "testnet"), but currently "alphanet" has higher major version
-            pepper: "testnet",
+            pepper: "devnet",
             quoteVerifier: new FakeQuoteVerifier()
         });
         IOwnable(address(proxy)).transferOwnership(owner);

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

@@ -138,7 +138,7 @@ contract TEELifecycleMockTest is MockRemoteAttestation, TEELifecycle {
     {
         (bootstrapPartyPrivkey, bootstrapPartyAddress) = getLabeledKeyPair("bootstrapParty");
         mrAggregated = testMrAggregated;
-        bootstrapResult = BootstrapResult({ecies_pubkey: testNetworkPubkey});
+        bootstrapResult = BootstrapResult({networkPubkey: testNetworkPubkey});
 
         quote = createQuote(testMrtd, bootstrapPartyAddress);
         signature = signBootstrapResult(bootstrapResult, bootstrapPartyPrivkey);

package/src/version/IncoLightningConfig.sol

@@ -7,12 +7,12 @@ pragma solidity ^0.8;
 // UPDATE the CHANGELOG on new versions
 
 string constant CONTRACT_NAME = "incoLightning";
-uint8 constant MAJOR_VERSION = 2;
+uint8 constant MAJOR_VERSION = 3;
 uint8 constant MINOR_VERSION = 0;
 // whenever a new version is deployed, we need to pump this up
 // otherwise make test_upgrade will fail
 // consequently, when we do a patch release, we don't need to pump it as it's already pumped
 // when the previous release was done
-uint8 constant PATCH_VERSION = 1;
+uint8 constant PATCH_VERSION = 2;
 
 string constant VERIFIER_NAME = "incoVerifier";