@inco/lightning 0.1.20 → 0.1.21

package/dumps/incoLightning_0_1_26__444235330.env

@@ -0,0 +1,15 @@
+DEPLOYER_ADDRESS=0x8202D2D747784Cb7D48868E44C42C4bf162a70BC
+STATE_DUMP=incoLightning_0_1_26__444235330.dump.json
+SESSION_VERIFIER_ADDRESS=0x3D4eB5f90E6d996c2b45b0BEb4110b5be98e243F
+ADD_TWO_ADDRESS=0x723c2be5E61e7bBec4684DEfEaE63656ad3eaa10
+EXECUTOR_ADDRESS=0xdc8eD938ff2eB900bD5f86A88555a9f1956994fC
+ECIES_PUBLIC_KEY=0x037eb9320ccde2bf8f19cb3d9fae7f46f63ca79455326cfc82ac4f1da8b527f5dd
+CALLBACK_ADDRESS=0xa511628F4519C75B1Afc761e70389BE67B8F97AB
+SENDER_ADDRESS=0x389B617D3E1241010d0D23BC4c430729f2f14436
+SENDER_PRIVATE_KEY=0x79aae91f68fb2235ebcc9553c35c79606a543d47c2b92d85bebb3e579529caef
+COVALIDATOR_ECIES_PRIVATE_KEY=0xbe70572bf559ee69509b8cce3d433509b7449ea26f32a92a90972044d86d2f96
+COVALIDATOR_CALLBACK_PRIVATE_KEY=0xb79cfd1429e47f49d4f50d5ee3a8cf483f4456c0ae237b81b45e53760934da0b
+COVALIDATOR_ACL_ADDR=0xdc8eD938ff2eB900bD5f86A88555a9f1956994fC
+COVALIDATOR_INCO_EXECUTOR_ADDR=0xdc8eD938ff2eB900bD5f86A88555a9f1956994fC
+COVALIDATOR_DECRYPTION_HANDLER_ADDR=0xdc8eD938ff2eB900bD5f86A88555a9f1956994fC
+

package/manifest.yaml

@@ -0,0 +1,92 @@
+incoLightning_0_1_26__18043964:
+  release:
+    name: incoLightning_0_1_26__18043964
+    executorAddress: "0x69Ef6a59f9eE2d6f3b49eA3F79bcF1553512DF0e"
+    deployer: "0x8202D2D747784Cb7D48868E44C42C4bf162a70BC"
+    pepper: testnet
+    version:
+      major: 0
+      minor: 1
+      patch: 26
+      shortSalt: "18043964"
+    salt: "0x8202d2d747784cb7d48868e44c42c4bf162a70bc00858064cb0f58c7ef7a843c"
+  deployments:
+    - decryptSigner: "0x000000000000000000000000000000000000baBe"
+      eciesPublicKey: "0x000000000000000000000000000000000000000000000000000000000000\
+        000000000000000000000000000000000000000000000000000000000000000000babe"
+      chainId: "7311099111"
+      blockNumber: "1"
+      chainName: Inco Release Chain
+      active: true
+      deployDate: 2025-04-22T12:14:50.447Z
+      commit: v3-26-g623cec72-dirty
+      sessionVerifierAddress: "0x0F508B0Fb940595046AB0eceB7A4C8b3e20Cb674"
+      addTwoAddress: "0x70fC34B18B12E945cb2204FA77E5f8e1581890C3"
+    - decryptSigner: "0xA8822DE8910f66D3d03F1eAfe2C0141dBc327Ee0"
+      eciesPublicKey: "0x048a582d29083c2f3fefe024bf4dd9ab913ab8973716977da5f01106e0b8\
+        4095b1e647a9e377175fcb66bda05087c93b05e1fd53a704d0914bb23a0b2a69e9f235"
+      chainId: "10143"
+      blockNumber: "13439069"
+      chainName: Monad Testnet
+      active: true
+      deployDate: 2025-04-22T12:14:42.391Z
+      commit: v3-26-g623cec72-dirty
+      sessionVerifierAddress: "0x0F508B0Fb940595046AB0eceB7A4C8b3e20Cb674"
+      addTwoAddress: "0x4A49112FB866F6d5D05845D264b430cD3bbAb9f6"
+    - decryptSigner: "0xA8822DE8910f66D3d03F1eAfe2C0141dBc327Ee0"
+      eciesPublicKey: "0x048a582d29083c2f3fefe024bf4dd9ab913ab8973716977da5f01106e0b8\
+        4095b1e647a9e377175fcb66bda05087c93b05e1fd53a704d0914bb23a0b2a69e9f235"
+      chainId: "84532"
+      blockNumber: "24777885"
+      chainName: Base Sepolia
+      active: true
+      deployDate: 2025-04-22T12:14:25.354Z
+      commit: v3-26-g623cec72-dirty
+      sessionVerifierAddress: "0x0F508B0Fb940595046AB0eceB7A4C8b3e20Cb674"
+      addTwoAddress: "0x2b5E34844997681168049783D30CD84B5962cb50"
+incoLightning_0_1_26__444235330:
+  release:
+    name: incoLightning_0_1_26__444235330
+    executorAddress: "0xdc8eD938ff2eB900bD5f86A88555a9f1956994fC"
+    deployer: "0x8202D2D747784Cb7D48868E44C42C4bf162a70BC"
+    pepper: devnet
+    version:
+      major: 0
+      minor: 1
+      patch: 26
+      shortSalt: "444235330"
+    salt: "0x8202d2d747784cb7d48868e44c42c4bf162a70bc001bab4c5927c52fbea0d042"
+  deployments:
+    - decryptSigner: "0x000000000000000000000000000000000000baBe"
+      eciesPublicKey: "0x000000000000000000000000000000000000000000000000000000000000\
+        000000000000000000000000000000000000000000000000000000000000000000babe"
+      chainId: "7311099111"
+      blockNumber: "1"
+      chainName: Inco Release Chain
+      active: true
+      deployDate: 2025-04-22T09:11:15.398Z
+      commit: v3-24-gc9716e6c-dirty
+      sessionVerifierAddress: "0x3D4eB5f90E6d996c2b45b0BEb4110b5be98e243F"
+      addTwoAddress: "0x70fC34B18B12E945cb2204FA77E5f8e1581890C3"
+    - decryptSigner: "0xA8822DE8910f66D3d03F1eAfe2C0141dBc327Ee0"
+      eciesPublicKey: "0x048a582d29083c2f3fefe024bf4dd9ab913ab8973716977da5f01106e0b8\
+        4095b1e647a9e377175fcb66bda05087c93b05e1fd53a704d0914bb23a0b2a69e9f235"
+      chainId: "10143"
+      blockNumber: "13418528"
+      chainName: Monad Testnet
+      active: true
+      deployDate: 2025-04-22T09:11:06.223Z
+      commit: v3-24-gc9716e6c-dirty
+      sessionVerifierAddress: "0x3D4eB5f90E6d996c2b45b0BEb4110b5be98e243F"
+      addTwoAddress: "0xfeE9C1E41b2268a4ad8EaDA35f510b8d89Cd041c"
+    - decryptSigner: "0xA8822DE8910f66D3d03F1eAfe2C0141dBc327Ee0"
+      eciesPublicKey: "0x048a582d29083c2f3fefe024bf4dd9ab913ab8973716977da5f01106e0b8\
+        4095b1e647a9e377175fcb66bda05087c93b05e1fd53a704d0914bb23a0b2a69e9f235"
+      chainId: "84532"
+      blockNumber: "24772369"
+      chainName: Base Sepolia
+      active: true
+      deployDate: 2025-04-22T09:10:33.275Z
+      commit: v3-24-gc9716e6c-dirty
+      sessionVerifierAddress: "0x3D4eB5f90E6d996c2b45b0BEb4110b5be98e243F"
+      addTwoAddress: "0xeEa387f7c866A81c2AF532D9ed48c60F179C9827"

package/package.json

@@ -1,18 +1,20 @@
 {
   "name": "@inco/lightning",
-  "version": "0.1.20",
+  "version": "0.1.21",
   "repository": "https://github.com/Inco-fhevm/inco-monorepo",
   "files": [
     "src/",
     "foundry.toml",
     "dumps/",
     "CHANGELOG.md",
-    "remappings.txt"
+    "remappings.txt",
+    "foundry.toml",
+    "manifest.yaml"
   ],
   "scripts": {
-    "generate:libraries": "bun run ../pega/lib/deployment/cmd/generate-libraries.ts",
     "publish:github": "bun publish --registry=https://npm.pkg.github.com",
-    "publish:npm": "bun publish --access public"
+    "publish:npm": "bun publish",
+    "generate:libraries": "bun run ../pega/lib/deployment/cmd/generate-libraries.ts"
   },
   "dependencies": {
     "@openzeppelin/contracts": "^5.2.0",

package/src/Lib.sol

@@ -8,7 +8,7 @@ pragma solidity ^0.8;
 import "./IncoLightning.sol";
 import { ebool, euint256, ETypes } from "./Types.sol";
 
-IncoLightning constant inco = IncoLightning(0xc3c81F7Bf86Af7ed3a5f5Bb1924A063a1c126cDd);
+IncoLightning constant inco = IncoLightning(0x69Ef6a59f9eE2d6f3b49eA3F79bcF1553512DF0e);
 address constant deployedBy = 0x8202D2D747784Cb7D48868E44C42C4bf162a70BC;
 uint256 constant defaultDecryptionDelayLimit = 2 hours;
 

package/src/libs/incoLightning_0_1_25__861473222.sol

@@ -0,0 +1,389 @@
+// 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.sol";
+import { ebool, euint256, ETypes } from "../Types.sol";
+
+IncoLightning constant inco = IncoLightning(0xbfb55e2E217edAD49910C3E8c411FbdD4bF9aaA5);
+address constant deployedBy = 0x8202D2D747784Cb7D48868E44C42C4bf162a70BC;
+uint256 constant defaultDecryptionDelayLimit = 2 hours;
+
+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 s(euint256 a) internal returns (euint256) {
+        return sanitize(a);
+    }
+
+    function s(ebool a) internal returns (ebool) {
+        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(s(a), s(b));
+    }
+
+    function eq(euint256 a, uint256 b) internal returns (ebool) {
+        return inco.eEq(s(a), asEuint256(b));
+    }
+
+    function eq(uint256 a, euint256 b) internal returns (ebool) {
+        return inco.eEq(asEuint256(a), s(b));
+    }
+
+    function ne(euint256 a, euint256 b) internal returns (ebool) {
+        return inco.eNe(s(a), s(b));
+    }
+
+    function ne(euint256 a, uint256 b) internal returns (ebool) {
+        return inco.eNe(s(a), asEuint256(b));
+    }
+
+    function ne(uint256 a, euint256 b) internal returns (ebool) {
+        return inco.eNe(asEuint256(a), 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));
+    }
+
+    function rand() internal returns (euint256) {
+        return euint256.wrap(inco.eRand(ETypes.Uint256));
+    }
+
+    function randBounded(uint256 upperBound) internal returns (euint256) {
+        return euint256.wrap(inco.eRandBounded(euint256.unwrap(asEuint256(upperBound)), ETypes.Uint256));
+    }
+
+    function randBounded(euint256 upperBound) internal returns (euint256) {
+        return euint256.wrap(inco.eRandBounded(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 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));
+    }
+
+    function newEuint256(bytes memory ciphertext, address user) internal returns (euint256) {
+        return inco.newEuint256(ciphertext, user);
+    }
+
+    function newEbool(bytes memory ciphertext, address user) internal returns (ebool) {
+        return inco.newEbool(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 allowThis(euint256 a) internal {
+        allow(a, address(this));
+    }
+
+    function allowThis(ebool 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 requestDecryption(euint256 a, bytes4 callbackSelector, bytes memory callbackData) internal returns (uint256 requestId) {
+        requestId = inco.requestDecryption(callbackSelector, block.timestamp + defaultDecryptionDelayLimit, euint256.unwrap(s(a)), callbackData);
+    }
+
+    function requestDecryption(ebool a, bytes4 callbackSelector, bytes memory callbackData) internal returns (uint256 requestId) {
+        requestId = inco.requestDecryption(callbackSelector, block.timestamp + defaultDecryptionDelayLimit, ebool.unwrap(s(a)), callbackData);
+    }
+}