@inco/lightning 0.8.0-devnet-3 → 0.8.0-devnet-5

package/src/Lib.template.sol

@@ -10,6 +10,9 @@ IncoLightning constant inco = IncoLightning(0x0000000000000000000000000000000000
 // forge-lint: disable-next-line(screaming-snake-case-const)
 address constant deployedBy = 0x000000000000000000000000000000000000baBe;
 
+/// @notice Returns the ETypes enum value encoded in a handle
+/// @param handle The handle to decode
+/// @return The ETypes value
 function typeOf(bytes32 handle) pure returns (ETypes) {
     return ETypes(uint8(uint256(handle) >> 8));
 }
@@ -18,6 +21,9 @@ library e {
 
     error CallFailedAfterFeeRefresh();
 
+    /// @notice Returns a sanitized euint256, replacing zero with asEuint256(0)
+    /// @param a The euint256 to sanitize
+    /// @return The sanitized euint256
     function sanitize(euint256 a) internal returns (euint256) {
         if (euint256.unwrap(a) == bytes32(0)) {
             return asEuint256(0);
@@ -25,6 +31,9 @@ library e {
         return a;
     }
 
+    /// @notice Returns a sanitized ebool, replacing zero with asEbool(false)
+    /// @param a The ebool to sanitize
+    /// @return The sanitized ebool
     function sanitize(ebool a) internal returns (ebool) {
         if (ebool.unwrap(a) == bytes32(0)) {
             return asEbool(false);
@@ -32,6 +41,9 @@ library e {
         return a;
     }
 
+    /// @notice Returns a sanitized eaddress, replacing zero with asEaddress(address(0))
+    /// @param a The eaddress to sanitize
+    /// @return The sanitized eaddress
     function sanitize(eaddress a) internal returns (eaddress) {
         if (eaddress.unwrap(a) == bytes32(0)) {
             return asEaddress(address(0));
@@ -39,329 +51,646 @@ library e {
         return a;
     }
 
+    /// @notice Alias for sanitize(euint256)
+    /// @param a The euint256 to sanitize
+    /// @return The sanitized euint256
     function s(euint256 a) internal returns (euint256) {
         return sanitize(a);
     }
 
+    /// @notice Alias for sanitize(ebool)
+    /// @param a The ebool to sanitize
+    /// @return The sanitized ebool
     function s(ebool a) internal returns (ebool) {
         return sanitize(a);
     }
 
+    /// @notice Alias for sanitize(eaddress)
+    /// @param a The eaddress to sanitize
+    /// @return The sanitized eaddress
     function s(eaddress a) internal returns (eaddress) {
         return sanitize(a);
     }
 
+    /// @notice Adds two encrypted uint256 values
+    /// @param a First operand
+    /// @param b Second operand
+    /// @return The encrypted sum
     function add(euint256 a, euint256 b) internal returns (euint256) {
         return inco.eAdd(s(a), s(b));
     }
 
+    /// @notice Adds an encrypted uint256 and a plaintext uint256
+    /// @param a Encrypted operand
+    /// @param b Plaintext operand
+    /// @return The encrypted sum
     function add(euint256 a, uint256 b) internal returns (euint256) {
         return inco.eAdd(s(a), asEuint256(b));
     }
 
+    /// @notice Adds a plaintext uint256 and an encrypted uint256
+    /// @param a Plaintext operand
+    /// @param b Encrypted operand
+    /// @return The encrypted sum
     function add(uint256 a, euint256 b) internal returns (euint256) {
         return inco.eAdd(asEuint256(a), s(b));
     }
 
+    /// @notice Subtracts two encrypted uint256 values
+    /// @param a Encrypted minuend
+    /// @param b Encrypted subtrahend
+    /// @return The encrypted difference
     function sub(euint256 a, euint256 b) internal returns (euint256) {
         return inco.eSub(s(a), s(b));
     }
 
+    /// @notice Subtracts a plaintext uint256 from an encrypted uint256
+    /// @param a Encrypted minuend
+    /// @param b Plaintext subtrahend
+    /// @return The encrypted difference
     function sub(euint256 a, uint256 b) internal returns (euint256) {
         return inco.eSub(s(a), asEuint256(b));
     }
 
+    /// @notice Subtracts an encrypted uint256 from a plaintext uint256
+    /// @param a Plaintext minuend
+    /// @param b Encrypted subtrahend
+    /// @return The encrypted difference
     function sub(uint256 a, euint256 b) internal returns (euint256) {
         return inco.eSub(asEuint256(a), s(b));
     }
 
+    /// @notice Multiplies two encrypted uint256 values
+    /// @param a Encrypted operand
+    /// @param b Encrypted operand
+    /// @return The encrypted product
     function mul(euint256 a, euint256 b) internal returns (euint256) {
         return inco.eMul(s(a), s(b));
     }
 
+    /// @notice Multiplies an encrypted uint256 and a plaintext uint256
+    /// @param a Encrypted operand
+    /// @param b Plaintext operand
+    /// @return The encrypted product
     function mul(euint256 a, uint256 b) internal returns (euint256) {
         return inco.eMul(s(a), asEuint256(b));
     }
 
+    /// @notice Multiplies a plaintext uint256 and an encrypted uint256
+    /// @param a Plaintext operand
+    /// @param b Encrypted operand
+    /// @return The encrypted product
     function mul(uint256 a, euint256 b) internal returns (euint256) {
         return inco.eMul(asEuint256(a), s(b));
     }
 
+    /// @notice Divides two encrypted uint256 values
+    /// @param a Encrypted Dividend
+    /// @param b Encrypted Divisor
+    /// @return The encrypted quotient
     function div(euint256 a, euint256 b) internal returns (euint256) {
         return inco.eDiv(s(a), s(b));
     }
 
+    /// @notice Divides an encrypted uint256 by a plaintext uint256
+    /// @param a Encrypted dividend
+    /// @param b Plaintext divisor
+    /// @return The encrypted quotient
     function div(euint256 a, uint256 b) internal returns (euint256) {
         return inco.eDiv(s(a), asEuint256(b));
     }
 
+    /// @notice Divides a plaintext uint256 by an encrypted uint256
+    /// @param a Plaintext dividend
+    /// @param b Encrypted divisor
+    /// @return The encrypted quotient
     function div(uint256 a, euint256 b) internal returns (euint256) {
         return inco.eDiv(asEuint256(a), s(b));
     }
 
+    /// @notice Remainder of two encrypted uint256 values
+    /// @param a Encrypted dividend
+    /// @param b Encrypted divisor
+    /// @return The encrypted remainder
     function rem(euint256 a, euint256 b) internal returns (euint256) {
         return inco.eRem(s(a), s(b));
     }
 
+    /// @notice Remainder of an encrypted uint256 and a plaintext uint256
+    /// @param a Encrypted dividend
+    /// @param b Plaintext divisor
+    /// @return The encrypted remainder
     function rem(euint256 a, uint256 b) internal returns (euint256) {
         return inco.eRem(s(a), asEuint256(b));
     }
 
+    /// @notice Remainder of a plaintext uint256 and an encrypted uint256
+    /// @param a Plaintext dividend
+    /// @param b Encrypted divisor
+    /// @return The encrypted remainder
     function rem(uint256 a, euint256 b) internal returns (euint256) {
         return inco.eRem(asEuint256(a), s(b));
     }
 
+    /// @notice Bitwise AND of two encrypted uint256 values
+    /// @param a Encrypted operand
+    /// @param b Encrypted operand
+    /// @return The encrypted result
     function and(euint256 a, euint256 b) internal returns (euint256) {
         return euint256.wrap(inco.eBitAnd(euint256.unwrap(s(a)), euint256.unwrap(s(b))));
     }
 
+    /// @notice Bitwise AND of an encrypted uint256 and a plaintext uint256
+    /// @param a Encrypted operand
+    /// @param b Plaintext operand
+    /// @return The encrypted result
     function and(euint256 a, uint256 b) internal returns (euint256) {
         return euint256.wrap(inco.eBitAnd(euint256.unwrap(s(a)), euint256.unwrap(asEuint256(b))));
     }
 
+    /// @notice Bitwise AND of a plaintext uint256 and an encrypted uint256
+    /// @param a Plaintext operand
+    /// @param b Encrypted operand
+    /// @return The encrypted result
     function and(uint256 a, euint256 b) internal returns (euint256) {
         return euint256.wrap(inco.eBitAnd(euint256.unwrap(asEuint256(a)), euint256.unwrap(s(b))));
     }
 
+    /// @notice Bitwise AND of two encrypted bool values
+    /// @param a Encrypted operand
+    /// @param b Encrypted operand
+    /// @return The encrypted result
     function and(ebool a, ebool b) internal returns (ebool) {
         return ebool.wrap(inco.eBitAnd(ebool.unwrap(s(a)), ebool.unwrap(s(b))));
     }
 
+    /// @notice Bitwise AND of an encrypted bool and a plaintext bool
+    /// @param a Encrypted operand
+    /// @param b Plaintext operand
+    /// @return The encrypted result
     function and(ebool a, bool b) internal returns (ebool) {
         return ebool.wrap(inco.eBitAnd(ebool.unwrap(s(a)), ebool.unwrap(asEbool(b))));
     }
 
+    /// @notice Bitwise AND of a plaintext bool and an encrypted bool
+    /// @param a Plaintext operand
+    /// @param b Encrypted operand
+    /// @return The encrypted result
     function and(bool a, ebool b) internal returns (ebool) {
         return ebool.wrap(inco.eBitAnd(ebool.unwrap(asEbool(a)), ebool.unwrap(s(b))));
     }
 
+    /// @notice Bitwise OR of two encrypted uint256 values
+    /// @param a Encrypted operand
+    /// @param b Encrypted operand
+    /// @return The encrypted result
     function or(euint256 a, euint256 b) internal returns (euint256) {
         return euint256.wrap(inco.eBitOr(euint256.unwrap(s(a)), euint256.unwrap(s(b))));
     }
 
+    /// @notice Bitwise OR of an encrypted uint256 and a plaintext uint256
+    /// @param a Encrypted operand
+    /// @param b Plaintext operand
+    /// @return The encrypted result
     function or(euint256 a, uint256 b) internal returns (euint256) {
         return euint256.wrap(inco.eBitOr(euint256.unwrap(s(a)), euint256.unwrap(asEuint256(b))));
     }
 
+    /// @notice Bitwise OR of a plaintext uint256 and an encrypted uint256
+    /// @param a Plaintext operand
+    /// @param b Encrypted operand
+    /// @return The encrypted result
     function or(uint256 a, euint256 b) internal returns (euint256) {
         return euint256.wrap(inco.eBitOr(euint256.unwrap(asEuint256(a)), euint256.unwrap(s(b))));
     }
 
+    /// @notice Bitwise OR of two encrypted bool values
+    /// @param a Encrypted operand
+    /// @param b Encrypted operand
+    /// @return The encrypted result
     function or(ebool a, ebool b) internal returns (ebool) {
         return ebool.wrap(inco.eBitOr(ebool.unwrap(s(a)), ebool.unwrap(s(b))));
     }
 
+    /// @notice Bitwise OR of an encrypted bool and a plaintext bool
+    /// @param a Encrypted operand
+    /// @param b Plaintext operand
+    /// @return The encrypted result
     function or(ebool a, bool b) internal returns (ebool) {
         return ebool.wrap(inco.eBitOr(ebool.unwrap(s(a)), ebool.unwrap(asEbool(b))));
     }
 
+    /// @notice Bitwise OR of a plaintext bool and an encrypted bool
+    /// @param a Plaintext operand
+    /// @param b Encrypted operand
+    /// @return The encrypted result
     function or(bool a, ebool b) internal returns (ebool) {
         return ebool.wrap(inco.eBitOr(ebool.unwrap(asEbool(a)), ebool.unwrap(s(b))));
     }
 
+    /// @notice Bitwise XOR of two encrypted uint256 values
+    /// @param a Encrypted operand
+    /// @param b Encrypted operand
+    /// @return The encrypted result
     function xor(euint256 a, euint256 b) internal returns (euint256) {
         return euint256.wrap(inco.eBitXor(euint256.unwrap(s(a)), euint256.unwrap(s(b))));
     }
 
+    /// @notice Bitwise XOR of an encrypted uint256 and a plaintext uint256
+    /// @param a Encrypted operand
+    /// @param b Plaintext operand
+    /// @return The encrypted result
     function xor(euint256 a, uint256 b) internal returns (euint256) {
         return euint256.wrap(inco.eBitXor(euint256.unwrap(s(a)), euint256.unwrap(asEuint256(b))));
     }
 
+    /// @notice Bitwise XOR of a plaintext uint256 and an encrypted uint256
+    /// @param a Plaintext operand
+    /// @param b Encrypted operand
+    /// @return The encrypted result
     function xor(uint256 a, euint256 b) internal returns (euint256) {
         return euint256.wrap(inco.eBitXor(euint256.unwrap(asEuint256(a)), euint256.unwrap(s(b))));
     }
 
+    /// @notice Bitwise XOR of two encrypted bool values
+    /// @param a First operand
+    /// @param b Second operand
+    /// @return The encrypted result
     function xor(ebool a, ebool b) internal returns (ebool) {
         return ebool.wrap(inco.eBitXor(ebool.unwrap(s(a)), ebool.unwrap(s(b))));
     }
 
+    /// @notice Bitwise XOR of an encrypted bool and a plaintext bool
+    /// @param a Encrypted operand
+    /// @param b Plaintext operand
+    /// @return The encrypted result
     function xor(ebool a, bool b) internal returns (ebool) {
         return ebool.wrap(inco.eBitXor(ebool.unwrap(s(a)), ebool.unwrap(asEbool(b))));
     }
 
+    /// @notice Bitwise XOR of a plaintext bool and an encrypted bool
+    /// @param a Plaintext operand
+    /// @param b Encrypted operand
+    /// @return The encrypted result
     function xor(bool a, ebool b) internal returns (ebool) {
         return ebool.wrap(inco.eBitXor(ebool.unwrap(asEbool(a)), ebool.unwrap(s(b))));
     }
 
+    /// @notice Left shift of two encrypted uint256 values
+    /// @param a Encrypted value to shift
+    /// @param b Encrypted shift amount
+    /// @return The encrypted result
     function shl(euint256 a, euint256 b) internal returns (euint256) {
         return inco.eShl(s(a), s(b));
     }
 
+    /// @notice Left shift of an encrypted uint256 by a plaintext uint256
+    /// @param a Encrypted value to shift
+    /// @param b Plaintext shift amount
+    /// @return The encrypted result
     function shl(euint256 a, uint256 b) internal returns (euint256) {
         return inco.eShl(s(a), asEuint256(b));
     }
 
+    /// @notice Left shift of a plaintext uint256 by an encrypted uint256
+    /// @param a Plaintext value to shift
+    /// @param b Encrypted shift amount
+    /// @return The encrypted result
     function shl(uint256 a, euint256 b) internal returns (euint256) {
         return inco.eShl(asEuint256(a), s(b));
     }
 
+    /// @notice Right shift of two encrypted uint256 values
+    /// @param a Encrypted value to shift
+    /// @param b Encrypted shift amount
+    /// @return The encrypted result
     function shr(euint256 a, euint256 b) internal returns (euint256) {
         return inco.eShr(s(a), s(b));
     }
 
+    /// @notice Right shift of an encrypted uint256 by a plaintext uint256
+    /// @param a Encrypted value to shift
+    /// @param b Plaintext shift amount
+    /// @return The encrypted result
     function shr(euint256 a, uint256 b) internal returns (euint256) {
         return inco.eShr(s(a), asEuint256(b));
     }
 
+    /// @notice Right shift of a plaintext uint256 by an encrypted uint256
+    /// @param a Plaintext value to shift
+    /// @param b Encrypted shift amount
+    /// @return The encrypted result
     function shr(uint256 a, euint256 b) internal returns (euint256) {
         return inco.eShr(asEuint256(a), s(b));
     }
 
+    /// @notice Left rotate of two encrypted uint256 values
+    /// @param a Encrypted value to rotate
+    /// @param b Encrypted rotate amount
+    /// @return The encrypted result
     function rotl(euint256 a, euint256 b) internal returns (euint256) {
         return inco.eRotl(s(a), s(b));
     }
 
+    /// @notice Left rotate of an encrypted uint256 by a plaintext uint256
+    /// @param a Encrypted value to rotate
+    /// @param b Plaintext rotate amount
+    /// @return The encrypted result
     function rotl(euint256 a, uint256 b) internal returns (euint256) {
         return inco.eRotl(s(a), asEuint256(b));
     }
 
+    /// @notice Left rotate of a plaintext uint256 by an encrypted uint256
+    /// @param a Plaintext value to rotate
+    /// @param b Encrypted rotate amount
+    /// @return The encrypted result
     function rotl(uint256 a, euint256 b) internal returns (euint256) {
         return inco.eRotl(asEuint256(a), s(b));
     }
 
+    /// @notice Right rotate of two encrypted uint256 values
+    /// @param a Encrypted value to rotate
+    /// @param b Encrypted rotate amount
+    /// @return The encrypted result
     function rotr(euint256 a, euint256 b) internal returns (euint256) {
         return inco.eRotr(s(a), s(b));
     }
 
+    /// @notice Right rotate of an encrypted uint256 by a plaintext uint256
+    /// @param a Encrypted value to rotate
+    /// @param b Plaintext rotate amount
+    /// @return The encrypted result
     function rotr(euint256 a, uint256 b) internal returns (euint256) {
         return inco.eRotr(s(a), asEuint256(b));
     }
 
+    /// @notice Right rotate of a plaintext uint256 by an encrypted uint256
+    /// @param a Plaintext value to rotate
+    /// @param b Encrypted rotate amount
+    /// @return The encrypted result
     function rotr(uint256 a, euint256 b) internal returns (euint256) {
         return inco.eRotr(asEuint256(a), s(b));
     }
 
+    /// @notice Checks equality of two encrypted uint256 values
+    /// @param a Encrypted operand
+    /// @param b Encrypted operand
+    /// @return The encrypted bool result
     function eq(euint256 a, euint256 b) internal returns (ebool) {
         return inco.eEq(euint256.unwrap(s(a)), euint256.unwrap(s(b)));
     }
 
+    /// @notice Checks equality of an encrypted uint256 and a plaintext uint256
+    /// @param a Encrypted operand
+    /// @param b Plaintext operand
+    /// @return The encrypted bool result
     function eq(euint256 a, uint256 b) internal returns (ebool) {
         return inco.eEq(euint256.unwrap(s(a)), euint256.unwrap(asEuint256(b)));
     }
 
+    /// @notice Checks equality of a plaintext uint256 and an encrypted uint256
+    /// @param a Plaintext operand
+    /// @param b Encrypted operand
+    /// @return The encrypted bool result
     function eq(uint256 a, euint256 b) internal returns (ebool) {
         return inco.eEq(euint256.unwrap(asEuint256(a)), euint256.unwrap(s(b)));
     }
 
+    /// @notice Checks equality of an encrypted address and a plaintext address
+    /// @param a Encrypted operand
+    /// @param b Plaintext operand
+    /// @return The encrypted bool result
     function eq(eaddress a, address b) internal returns (ebool) {
         return inco.eEq(eaddress.unwrap(s(a)), eaddress.unwrap(asEaddress(b)));
     }
 
+    /// @notice Checks equality of two encrypted addresses
+    /// @param a Encrypted operand
+    /// @param b Encrypted operand
+    /// @return The encrypted bool result
     function eq(eaddress a, eaddress b) internal returns (ebool) {
         return inco.eEq(eaddress.unwrap(s(a)), eaddress.unwrap(s(b)));
     }
 
+    /// @notice Checks equality of a plaintext address and an encrypted address
+    /// @param a Plaintext operand
+    /// @param b Encrypted operand
+    /// @return The encrypted bool result
     function eq(address a, eaddress b) internal returns (ebool) {
         return inco.eEq(eaddress.unwrap(asEaddress(a)), eaddress.unwrap(s(b)));
     }
 
+    /// @notice Checks inequality of two encrypted uint256 values
+    /// @param a Encrypted operand
+    /// @param b Encrypted operand
+    /// @return The encrypted bool result
     function ne(euint256 a, euint256 b) internal returns (ebool) {
         return inco.eNe(euint256.unwrap(s(a)), euint256.unwrap(s(b)));
     }
 
+    /// @notice Checks inequality of an encrypted uint256 and a plaintext uint256
+    /// @param a Encrypted operand
+    /// @param b Plaintext operand
+    /// @return The encrypted bool result
     function ne(euint256 a, uint256 b) internal returns (ebool) {
         return inco.eNe(euint256.unwrap(s(a)), euint256.unwrap(asEuint256(b)));
     }
 
+    /// @notice Checks inequality of a plaintext uint256 and an encrypted uint256
+    /// @param a Plaintext operand
+    /// @param b Encrypted operand
+    /// @return The encrypted bool result
     function ne(uint256 a, euint256 b) internal returns (ebool) {
         return inco.eNe(euint256.unwrap(asEuint256(a)), euint256.unwrap(s(b)));
     }
 
+    /// @notice Checks inequality of two encrypted addresses
+    /// @param a Encrypted operand
+    /// @param b Encrypted operand
+    /// @return The encrypted bool result
     function ne(eaddress a, eaddress b) internal returns (ebool) {
         return inco.eNe(eaddress.unwrap(s(a)), eaddress.unwrap(s(b)));
     }
 
+    /// @notice Checks inequality of an encrypted address and a plaintext address
+    /// @param a Encrypted operand
+    /// @param b Plaintext operand
+    /// @return The encrypted bool result
     function ne(eaddress a, address b) internal returns (ebool) {
         return inco.eNe(eaddress.unwrap(s(a)), eaddress.unwrap(asEaddress(b)));
     }
 
+    /// @notice Checks inequality of a plaintext address and an encrypted address
+    /// @param a Plaintext operand
+    /// @param b Encrypted operand
+    /// @return The encrypted bool result
     function ne(address a, eaddress b) internal returns (ebool) {
         return inco.eNe(eaddress.unwrap(asEaddress(a)), eaddress.unwrap(s(b)));
     }
 
+    /// @notice Checks if one encrypted uint256 is greater than or equal to another
+    /// @param a Encrypted operand
+    /// @param b Encrypted operand
+    /// @return The encrypted bool result
     function ge(euint256 a, euint256 b) internal returns (ebool) {
         return inco.eGe(s(a), s(b));
     }
 
+    /// @notice Checks if an encrypted uint256 is greater than or equal to a plaintext uint256
+    /// @param a Encrypted operand
+    /// @param b Plaintext operand
+    /// @return The encrypted bool result
     function ge(euint256 a, uint256 b) internal returns (ebool) {
         return inco.eGe(s(a), asEuint256(b));
     }
 
+    /// @notice Checks if a plaintext uint256 is greater than or equal to an encrypted uint256
+    /// @param a Plaintext operand
+    /// @param b Encrypted operand
+    /// @return The encrypted bool result
     function ge(uint256 a, euint256 b) internal returns (ebool) {
         return inco.eGe(asEuint256(a), s(b));
     }
 
+    /// @notice Checks if one encrypted uint256 is greater than another
+    /// @param a Encrypted operand
+    /// @param b Encrypted operand
+    /// @return The encrypted bool result
     function gt(euint256 a, euint256 b) internal returns (ebool) {
         return inco.eGt(s(a), s(b));
     }
 
+    /// @notice Checks if an encrypted uint256 is greater than a plaintext uint256
+    /// @param a Encrypted operand
+    /// @param b Plaintext operand
+    /// @return The encrypted bool result
     function gt(euint256 a, uint256 b) internal returns (ebool) {
         return inco.eGt(s(a), asEuint256(b));
     }
 
+    /// @notice Checks if a plaintext uint256 is greater than an encrypted uint256
+    /// @param a Plaintext operand
+    /// @param b Encrypted operand
+    /// @return The encrypted bool result
     function gt(uint256 a, euint256 b) internal returns (ebool) {
         return inco.eGt(asEuint256(a), s(b));
     }
 
+    /// @notice Checks if one encrypted uint256 is less than or equal to another
+    /// @param a Encrypted operand
+    /// @param b Encrypted operand
+    /// @return The encrypted bool result
     function le(euint256 a, euint256 b) internal returns (ebool) {
         return inco.eLe(s(a), s(b));
     }
 
+    /// @notice Checks if an encrypted uint256 is less than or equal to a plaintext uint256
+    /// @param a Encrypted operand
+    /// @param b Plaintext operand
+    /// @return The encrypted bool result
     function le(euint256 a, uint256 b) internal returns (ebool) {
         return inco.eLe(s(a), asEuint256(b));
     }
 
+    /// @notice Checks if a plaintext uint256 is less than or equal to an encrypted uint256
+    /// @param a Plaintext operand
+    /// @param b Encrypted operand
+    /// @return The encrypted bool result
     function le(uint256 a, euint256 b) internal returns (ebool) {
         return inco.eLe(asEuint256(a), s(b));
     }
 
+    /// @notice Checks if one encrypted uint256 is less than another
+    /// @param a Encrypted operand
+    /// @param b Encrypted operand
+    /// @return The encrypted bool result
     function lt(euint256 a, euint256 b) internal returns (ebool) {
         return inco.eLt(s(a), s(b));
     }
 
+    /// @notice Checks if an encrypted uint256 is less than a plaintext uint256
+    /// @param a Encrypted operand
+    /// @param b Plaintext operand
+    /// @return The encrypted bool result
     function lt(euint256 a, uint256 b) internal returns (ebool) {
         return inco.eLt(s(a), asEuint256(b));
     }
 
+    /// @notice Checks if a plaintext uint256 is less than an encrypted uint256
+    /// @param a Plaintext operand
+    /// @param b Encrypted operand
+    /// @return The encrypted bool result
     function lt(uint256 a, euint256 b) internal returns (ebool) {
         return inco.eLt(asEuint256(a), s(b));
     }
 
+    /// @notice Returns the minimum of two encrypted uint256 values
+    /// @param a Encrypted operand
+    /// @param b Encrypted operand
+    /// @return The encrypted minimum
     function min(euint256 a, euint256 b) internal returns (euint256) {
         return inco.eMin(s(a), s(b));
     }
 
+    /// @notice Returns the minimum of an encrypted uint256 and a plaintext uint256
+    /// @param a Encrypted operand
+    /// @param b Plaintext operand
+    /// @return The encrypted minimum
     function min(euint256 a, uint256 b) internal returns (euint256) {
         return inco.eMin(s(a), asEuint256(b));
     }
 
+    /// @notice Returns the minimum of a plaintext uint256 and an encrypted uint256
+    /// @param a Plaintext operand
+    /// @param b Encrypted operand
+    /// @return The encrypted minimum
     function min(uint256 a, euint256 b) internal returns (euint256) {
         return inco.eMin(asEuint256(a), s(b));
     }
 
+    /// @notice Returns the maximum of two encrypted uint256 values
+    /// @param a Encrypted operand
+    /// @param b Encrypted operand
+    /// @return The encrypted maximum
     function max(euint256 a, euint256 b) internal returns (euint256) {
         return inco.eMax(s(a), s(b));
     }
 
+    /// @notice Returns the maximum of an encrypted uint256 and a plaintext uint256
+    /// @param a Encrypted operand
+    /// @param b Plaintext operand
+    /// @return The encrypted maximum
     function max(euint256 a, uint256 b) internal returns (euint256) {
         return inco.eMax(s(a), asEuint256(b));
     }
 
+    /// @notice Returns the maximum of a plaintext uint256 and an encrypted uint256
+    /// @param a Plaintext operand
+    /// @param b Encrypted operand
+    /// @return The encrypted maximum
     function max(uint256 a, euint256 b) internal returns (euint256) {
         return inco.eMax(asEuint256(a), s(b));
     }
 
+    /// @notice Bitwise NOT of an encrypted bool
+    /// @param a Encrypted operand
+    /// @return The encrypted result
     function not(ebool a) internal returns (ebool) {
         return inco.eNot(s(a));
     }
 
+    /// @notice Generates a random encrypted uint256 (costs the inco fee)
     /// @dev costs the inco fee
+    /// @return The encrypted random value
     function rand() internal returns (euint256) {
         bytes32 result = _callWithFeeRetry(abi.encodeWithSelector(inco.eRand.selector, ETypes.Uint256));
         return euint256.wrap(result);
     }
 
+    /// @notice Generates a random encrypted uint256 less than a plaintext upper bound (costs the inco fee)
     /// @dev costs the inco fee
+    /// @param upperBound The plaintext upper bound
+    /// @return The encrypted random value
     function randBounded(uint256 upperBound) internal returns (euint256) {
         bytes32 boundHandle = euint256.unwrap(asEuint256(upperBound));
         bytes32 result =
@@ -369,7 +698,10 @@ library e {
         return euint256.wrap(result);
     }
 
+    /// @notice Generates a random encrypted uint256 less than an encrypted upper bound (costs the inco fee)
     /// @dev costs the inco fee
+    /// @param upperBound The encrypted upper bound
+    /// @return The encrypted random value
     function randBounded(euint256 upperBound) internal returns (euint256) {
         bytes32 boundHandle = euint256.unwrap(s(upperBound));
         bytes32 result =
@@ -377,22 +709,37 @@ library e {
         return euint256.wrap(result);
     }
 
+    /// @notice Casts a plaintext uint256 to an encrypted uint256
+    /// @param a The plaintext value
+    /// @return The encrypted value
     function asEuint256(uint256 a) internal returns (euint256) {
         return inco.asEuint256(a);
     }
 
+    /// @notice Casts a plaintext bool to an encrypted bool
+    /// @param a The plaintext value
+    /// @return The encrypted value
     function asEbool(bool a) internal returns (ebool) {
         return inco.asEbool(a);
     }
 
+    /// @notice Casts a plaintext address to an encrypted address
+    /// @param a The plaintext value
+    /// @return The encrypted value
     function asEaddress(address a) internal returns (eaddress) {
         return inco.asEaddress(a);
     }
 
+    /// @notice Casts an encrypted uint256 to an encrypted bool
+    /// @param a The encrypted uint256 value
+    /// @return The encrypted bool value
     function asEbool(euint256 a) internal returns (ebool) {
         return ebool.wrap(inco.eCast(euint256.unwrap(a), ETypes.Bool));
     }
 
+    /// @notice Casts an encrypted bool to an encrypted uint256
+    /// @param a The encrypted bool value
+    /// @return The encrypted uint256 value
     function asEuint256(ebool a) internal returns (euint256) {
         return euint256.wrap(inco.eCast(ebool.unwrap(a), ETypes.Uint256));
     }
@@ -436,54 +783,94 @@ library e {
         return eaddress.wrap(result);
     }
 
+    /// @notice Allows an address to access an encrypted uint256
+    /// @param a The encrypted uint256
+    /// @param to The address to allow
     function allow(euint256 a, address to) internal {
         inco.allow(euint256.unwrap(a), to);
     }
 
+    /// @notice Allows an address to access an encrypted bool
+    /// @param a The encrypted bool
+    /// @param to The address to allow
     function allow(ebool a, address to) internal {
         inco.allow(ebool.unwrap(a), to);
     }
 
+    /// @notice Allows an address to access an encrypted address
+    /// @param a The encrypted address
+    /// @param to The address to allow
     function allow(eaddress a, address to) internal {
         inco.allow(eaddress.unwrap(a), to);
     }
 
+    /// @notice Reveals an encrypted uint256
+    /// @param a The encrypted uint256
     function reveal(euint256 a) internal {
         inco.reveal(euint256.unwrap(a));
     }
 
+    /// @notice Reveals an encrypted bool
+    /// @param a The encrypted bool
     function reveal(ebool a) internal {
         inco.reveal(ebool.unwrap(a));
     }
 
+    /// @notice Reveals an encrypted address
+    /// @param a The encrypted address
     function reveal(eaddress a) internal {
         inco.reveal(eaddress.unwrap(a));
     }
 
+    /// @notice Allows this contract to access an encrypted uint256
+    /// @param a The encrypted uint256
     function allowThis(euint256 a) internal {
         allow(a, address(this));
     }
 
+    /// @notice Allows this contract to access an encrypted bool
+    /// @param a The encrypted bool
     function allowThis(ebool a) internal {
         allow(a, address(this));
     }
 
+    /// @notice Allows this contract to access an encrypted address
+    /// @param a The encrypted address
     function allowThis(eaddress a) internal {
         allow(a, address(this));
     }
 
+    /// @notice Checks if a user is allowed to access an encrypted uint256
+    /// @param user The address to check
+    /// @param a The encrypted uint256
+    /// @return True if allowed, false otherwise
     function isAllowed(address user, euint256 a) internal view returns (bool) {
         return inco.isAllowed(euint256.unwrap(a), user);
     }
 
+    /// @notice Selects between two encrypted uint256 values based on an encrypted bool
+    /// @param control The encrypted bool condition
+    /// @param ifTrue Value if control is true
+    /// @param ifFalse Value if control is false
+    /// @return The selected encrypted uint256
     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))));
     }
 
+    /// @notice Selects between two encrypted bool values based on an encrypted bool
+    /// @param control The encrypted bool condition
+    /// @param ifTrue Value if control is true
+    /// @param ifFalse Value if control is false
+    /// @return The selected encrypted bool
     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))));
     }
 
+    /// @notice Selects between two encrypted addresses based on an encrypted bool
+    /// @param control The encrypted bool condition
+    /// @param ifTrue Value if control is true
+    /// @param ifFalse Value if control is false
+    /// @return The selected encrypted address
     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))));
     }