@inco/lightning 0.1.29 → 0.1.30

package/package.json

@@ -1,21 +1,20 @@
 {
   "name": "@inco/lightning",
-  "version": "0.1.29",
+  "version": "0.1.30",
   "repository": "https://github.com/Inco-fhevm/inco-monorepo",
   "files": [
     "src/",
-    "foundry.toml",
     "dumps/",
     "CHANGELOG.md",
-    "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",
-    "generate:libraries": "bun run ../pega/lib/deployment/cmd/generate-libraries.ts"
+    "publish:npm": "bun publish --access public"
   },
   "dependencies": {
+    "@inco/shared": "^0.1.0",
     "@openzeppelin/contracts": "^5.2.0",
     "@openzeppelin/contracts-upgradeable": "^5.2.0",
     "ds-test": "https://github.com/dapphub/ds-test",

package/src/Lib.sol

@@ -6,9 +6,11 @@
 pragma solidity ^0.8;
 
 import "./IncoLightning.sol";
-import { ebool, euint256, ETypes } from "./Types.sol";
+import {ebool, euint256, ETypes} from "./Types.sol";
 
-IncoLightning constant inco = IncoLightning(0x63D8135aF4D393B1dB43B649010c8D3EE19FC9fd);
+IncoLightning constant inco = IncoLightning(
+    0x63D8135aF4D393B1dB43B649010c8D3EE19FC9fd
+);
 address constant deployedBy = 0x8202D2D747784Cb7D48868E44C42C4bf162a70BC;
 uint256 constant defaultDecryptionDelayLimit = 2 hours;
 
@@ -96,15 +98,30 @@ library e {
     }
 
     function and(euint256 a, euint256 b) internal returns (euint256) {
-        return euint256.wrap(inco.eBitAnd(euint256.unwrap(s(a)), euint256.unwrap(s(b))));
+        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))));
+        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))));
+        return
+            euint256.wrap(
+                inco.eBitAnd(
+                    euint256.unwrap(asEuint256(a)),
+                    euint256.unwrap(s(b))
+                )
+            );
     }
 
     function and(ebool a, ebool b) internal returns (ebool) {
@@ -112,23 +129,44 @@ library e {
     }
 
     function and(ebool a, bool b) internal returns (ebool) {
-        return ebool.wrap(inco.eBitAnd(ebool.unwrap(s(a)), ebool.unwrap(asEbool(b))));
+        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))));
+        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))));
+        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))));
+        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))));
+        return
+            euint256.wrap(
+                inco.eBitOr(
+                    euint256.unwrap(asEuint256(a)),
+                    euint256.unwrap(s(b))
+                )
+            );
     }
 
     function or(ebool a, ebool b) internal returns (ebool) {
@@ -136,23 +174,44 @@ library e {
     }
 
     function or(ebool a, bool b) internal returns (ebool) {
-        return ebool.wrap(inco.eBitOr(ebool.unwrap(s(a)), ebool.unwrap(asEbool(b))));
+        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))));
+        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))));
+        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))));
+        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))));
+        return
+            euint256.wrap(
+                inco.eBitXor(
+                    euint256.unwrap(asEuint256(a)),
+                    euint256.unwrap(s(b))
+                )
+            );
     }
 
     function xor(ebool a, ebool b) internal returns (ebool) {
@@ -160,11 +219,17 @@ library e {
     }
 
     function xor(ebool a, bool b) internal returns (ebool) {
-        return ebool.wrap(inco.eBitXor(ebool.unwrap(s(a)), ebool.unwrap(asEbool(b))));
+        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))));
+        return
+            ebool.wrap(
+                inco.eBitXor(ebool.unwrap(asEbool(a)), ebool.unwrap(s(b)))
+            );
     }
 
     function shl(euint256 a, euint256 b) internal returns (euint256) {
@@ -320,11 +385,23 @@ library e {
     }
 
     function randBounded(uint256 upperBound) internal returns (euint256) {
-        return euint256.wrap(inco.eRandBounded(euint256.unwrap(asEuint256(upperBound)), ETypes.Uint256));
+        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));
+        return
+            euint256.wrap(
+                inco.eRandBounded(
+                    euint256.unwrap(s(upperBound)),
+                    ETypes.Uint256
+                )
+            );
     }
 
     function asEuint256(uint256 a) internal returns (euint256) {
@@ -343,11 +420,17 @@ library e {
         return euint256.wrap(inco.eCast(ebool.unwrap(a), ETypes.Uint256));
     }
 
-    function newEuint256(bytes memory ciphertext, address user) internal returns (euint256) {
+    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) {
+    function newEbool(
+        bytes memory ciphertext,
+        address user
+    ) internal returns (ebool) {
         return inco.newEbool(ciphertext, user);
     }
 
@@ -371,19 +454,59 @@ library e {
         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);
-    }
-}
+    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
+        );
+    }
+}

package/foundry.toml

@@ -1,20 +0,0 @@
-[profile.default]
-src = 'src'
-test = 'src'
-cache_path = 'out/foundry-cache'
-allow_paths = ['../../', "out/*", "broadcast/*"]
-evm_version = 'cancun'
-solc = '0.8.28'
-extra_output = ["storageLayout", "abi", "evm.methodIdentifiers"]
-ffi = true
-ast = true
-build_info = true
-fs_permissions = [
-    { access = "read", path = "./" },
-    { access = "read-write", path = "./fixtures" },
-    { access = "write", path = "out/" },
-    { access = "read-write", path = "deployments/" },
-    { access = "read-write", path = "src/generated/" },
-]
-optimizer = true
-optimizer-runs = 10_000_000

package/remappings.txt

@@ -1,4 +0,0 @@
-@openzeppelin/=../../node_modules/@openzeppelin/
-forge-std/=../../node_modules/forge-std/src/
-ds-test/=../../node_modules/ds-test/src/
-@inco/=../