@inco/js 0.8.0-devnet-11 → 0.8.0-devnet-13

package/dist/esm/encryption/encryption.d.ts

@@ -1,37 +1,79 @@
 import { Schema } from 'effect';
 import { ByteArray, Hex } from 'viem';
 import { Bytes32 } from '../binary.js';
+/**
+ * A function that encrypts a plaintext value, embedding its {@link InputContext} into the resulting ciphertext.
+ *
+ * @typeParam S - The encryption scheme (e.g. X-Wing).
+ * @example
+ * ```ts
+ * const result = await encrypt({ plaintext: { scheme: 2, type: 5, value: 42n }, context });
+ * // result.handle, result.ciphertext, result.prehandle
+ * ```
+ */
 export type Encryptor<S extends EncryptionScheme = EncryptionScheme> = <T extends SupportedFheType>(plaintext: PlaintextWithContextOf<S, T>) => Promise<EncryptResultOf<S, T>>;
+/**
+ * A function that decrypts a ciphertext back to its plaintext value.
+ *
+ * @typeParam S - The encryption scheme (e.g. X-Wing).
+ * @example
+ * ```ts
+ * const plaintext = await decrypt({ scheme: 2, type: 5, value: '0x...' });
+ * ```
+ */
 export type Decryptor<S extends EncryptionScheme = EncryptionScheme> = <T extends SupportedFheType>(ciphertext: CiphertextOf<S, T>) => Promise<PlaintextOf<S, T>>;
+/**
+ * Subset of ENCRYPTION types currently supported for encryption/decryption.
+ *
+ * @remarks TODO: review need of `euint64` and `euint160` — `Lib.sol` only supports `euint256` and `ebool`.
+ */
 export declare const supportedFheTypes: {
     readonly euint64: 5;
     readonly euint160: 7;
     readonly euint256: 8;
     readonly ebool: 0;
 };
+/** Schema that validates a string is one of the supported ENCRYPTION type names. */
 export declare const SupportedFheTypeName: Schema.SchemaClass<"ebool" | "euint64" | "euint160" | "euint256", "ebool" | "euint64" | "euint160" | "euint256", never>;
+/** A supported ENCRYPTION type name (e.g. `"euint256"`, `"ebool"`). */
 export type SupportedFheTypeName = typeof SupportedFheTypeName.Type;
+/** Schema that validates a number is one of the supported ENCRYPTION type integer identifiers. */
 export declare const SupportedFheType: Schema.SchemaClass<0 | 5 | 7 | 8, 0 | 5 | 7 | 8, never>;
+/** Integer identifier of a supported ENCRYPTION type (a subset of all ENCRYPTION types). */
 export type SupportedFheType = typeof SupportedFheType.Type;
+/** Map of encryption scheme names to their integer identifiers. Currently only X-Wing (2) is supported. */
 export declare const encryptionSchemes: {
     readonly xwing: 2;
 };
+/**
+ * Returns the human-readable name of an encryption scheme.
+ * @param scheme - The encryption scheme integer identifier.
+ * @returns The scheme name (e.g. `"X-Wing"`).
+ * @throws If the scheme identifier is unknown.
+ */
 export declare function getEncryptionSchemeName(scheme: number): string;
+/** The typeof {@link encryptionSchemes} — mapping from scheme names to integer IDs. */
 export type EncryptionSchemes = typeof encryptionSchemes;
+/** The integer identifier for the X-Wing encryption scheme (`2`). */
 export type XwingScheme = EncryptionSchemes['xwing'];
+/** Schema that validates a value is a known encryption scheme identifier. */
 export declare const EncryptionScheme: Schema.Literal<[2]>;
+/** An encryption scheme identifier (currently only X-Wing = `2`). */
 export type EncryptionScheme = typeof EncryptionScheme.Type;
 type DistType<P, S extends EncryptionScheme, T extends SupportedFheType> = P extends any ? P & {
     scheme: S;
     type: T;
 } : never;
+/** Schema for an ENCRYPTION ciphertext: encryption scheme, ENCRYPTION type, and the encrypted value as a hex string. */
 export declare const Ciphertext: Schema.Struct<{
     scheme: Schema.Literal<[2]>;
     type: Schema.SchemaClass<0 | 5 | 7 | 8, 0 | 5 | 7 | 8, never>;
     value: Schema.TemplateLiteral<`0x${string}`>;
 }>;
+/** An ENCRYPTION ciphertext containing the encryption scheme, ENCRYPTION type, and encrypted hex value. */
 export type Ciphertext = typeof Ciphertext.Type;
 export type CiphertextOf<S extends EncryptionScheme, T extends SupportedFheType> = DistType<Ciphertext, S, T>;
+/** Schema for a ciphertext paired with the {@link InputContext} it was encrypted under. */
 export declare const CiphertextWithContext: Schema.Struct<{
     ciphertext: Schema.Struct<{
         scheme: Schema.Literal<[2]>;
@@ -46,10 +88,12 @@ export declare const CiphertextWithContext: Schema.Struct<{
         version: typeof Schema.Number;
     }>;
 }>;
+/** A ciphertext paired with the {@link InputContext} it was encrypted under. */
 export type CiphertextWithContext = typeof CiphertextWithContext.Type;
 export type CiphertextWithContextOf<S extends EncryptionScheme, T extends SupportedFheType> = CiphertextWithContext & {
     ciphertext: CiphertextOf<S, T>;
 };
+/** Schema for the result of an encryption operation: ciphertext, input context, prehandle, and final handle. */
 export declare const EncryptResult: Schema.Struct<{
     ciphertext: Schema.Struct<{
         scheme: Schema.Literal<[2]>;
@@ -66,10 +110,16 @@ export declare const EncryptResult: Schema.Struct<{
     prehandle: Schema.brand<Schema.filter<Schema.transformOrFail<Schema.Union<[typeof Schema.String, Schema.refine<object & Uint8Array<ArrayBufferLike>, Schema.Schema<object, object, never>>]>, Schema.TemplateLiteral<`0x${string}`>, never>>, "Bytes32">;
     handle: Schema.brand<Schema.filter<Schema.transformOrFail<Schema.Union<[typeof Schema.String, Schema.refine<object & Uint8Array<ArrayBufferLike>, Schema.Schema<object, object, never>>]>, Schema.TemplateLiteral<`0x${string}`>, never>>, "Bytes32">;
 }>;
+/** The result of an encryption operation, containing the ciphertext, context, prehandle, and deterministic handle. */
 export type EncryptResult = typeof EncryptResult.Type;
 export type EncryptResultOf<S extends EncryptionScheme, T extends SupportedFheType> = EncryptResult & {
     ciphertext: CiphertextOf<S, T>;
 };
+/**
+ * Schema for an ENCRYPTION plaintext value. The `value` field type depends on the ENCRYPTION type:
+ * - `euint64` / `euint160` / `euint256`: `bigint`
+ * - `ebool`: `boolean`
+ */
 export declare const Plaintext: Schema.Union<[Schema.Struct<{
     scheme: Schema.Literal<[2]>;
     type: Schema.Literal<[5, 7, 8]>;
@@ -79,8 +129,10 @@ export declare const Plaintext: Schema.Union<[Schema.Struct<{
     type: Schema.Literal<[0]>;
     value: typeof Schema.Boolean;
 }>]>;
+/** An ENCRYPTION plaintext value — `bigint` for integer types, `boolean` for `ebool`. */
 export type Plaintext = typeof Plaintext.Type;
 export type PlaintextOf<S extends EncryptionScheme, T extends SupportedFheType> = DistType<Plaintext, S, T>;
+/** Schema for a plaintext paired with the {@link InputContext} it will be encrypted under. */
 export declare const PlaintextWithContext: Schema.Struct<{
     plaintext: Schema.Union<[Schema.Struct<{
         scheme: Schema.Literal<[2]>;
@@ -99,20 +151,83 @@ export declare const PlaintextWithContext: Schema.Struct<{
         version: typeof Schema.Number;
     }>;
 }>;
+/** A plaintext paired with the {@link InputContext} it will be encrypted under. */
 export type PlaintextWithContext = typeof PlaintextWithContext.Type;
 export type PlaintextWithContextOf<S extends EncryptionScheme, T extends SupportedFheType> = PlaintextWithContext & {
     plaintext: PlaintextOf<S, T>;
 };
+/**
+ * Converts a `bigint` to a typed {@link Plaintext} value.
+ *
+ * For integer ENCRYPTION types (`euint64`, `euint160`, `euint256`) the value is passed through as-is.
+ * For `ebool`, non-zero values become `true`.
+ *
+ * @param scheme - The encryption scheme identifier.
+ * @param type - The ENCRYPTION type to interpret the value as.
+ * @param bigPt - The raw bigint plaintext value.
+ * @returns A typed `Plaintext` matching the given scheme and ENCRYPTION type.
+ * @throws If `type` is not a supported ENCRYPTION type.
+ */
 export declare function bigintToPlaintext<S extends EncryptionScheme, T extends SupportedFheType>(scheme: S, type: T, bigPt: bigint): PlaintextOf<S, T>;
+/**
+ * Decodes an ABI-encoded ciphertext input into its components.
+ *
+ * The input format is: `4-byte version || abi.encode(bytes32 handle, bytes ciphertext)`.
+ *
+ * @param input - The raw encoded input as a byte array or hex string.
+ * @returns The decoded version, handle, and ciphertext.
+ */
 export declare function decodeCiphertextInput(input: ByteArray | Hex): {
     version: number;
     handle: Hex;
     ciphertext: Hex;
 };
+/**
+ * Encodes a handle and ciphertext into the on-chain input format.
+ *
+ * The output format is: `4-byte version || abi.encode(bytes32 handle, bytes ciphertext)`.
+ *
+ * @param version - The encoding version (int32).
+ * @param handle - The 32-byte handle as a hex string.
+ * @param ciphertext - The ciphertext as a hex string.
+ * @returns The ABI-encoded input as a hex string.
+ */
 export declare function encodeCiphertextInput(version: number, handle: Hex, ciphertext: Hex): Hex;
+/**
+ * Converts a {@link Plaintext} to its `bigint` representation.
+ *
+ * Integer types pass through directly; `ebool` maps `true` → `1n`, `false` → `0n`.
+ *
+ * @param plaintext - The plaintext to convert.
+ * @returns The bigint representation of the plaintext value.
+ */
 export declare function plaintextToBigint(plaintext: Plaintext): bigint;
+/**
+ * Converts a {@link Plaintext} to a {@link Bytes32} hex string.
+ * @param plaintext - The plaintext to convert.
+ * @returns A 32-byte hex representation of the plaintext value.
+ */
 export declare function plaintextToBytes32(plaintext: Plaintext): Bytes32;
+/**
+ * Converts a {@link Plaintext} to a 32-byte `Buffer`.
+ * @param plaintext - The plaintext to convert.
+ * @returns A 32-byte big-endian buffer of the plaintext value.
+ */
 export declare function plaintextToBytes(plaintext: Plaintext): Buffer;
+/**
+ * Parses a {@link Bytes32} hex string into a typed {@link Plaintext}.
+ * @param plaintext - The 32-byte hex value to interpret.
+ * @param scheme - The encryption scheme identifier.
+ * @param type - The ENCRYPTION type to interpret the bytes as.
+ * @returns A typed `Plaintext` value.
+ */
 export declare function bytes32ToPlaintext(plaintext: Bytes32, scheme: EncryptionScheme, type: SupportedFheType): Plaintext;
+/**
+ * Parses a `Uint8Array` into a typed {@link Plaintext}.
+ * @param plaintext - The byte array to interpret.
+ * @param scheme - The encryption scheme identifier.
+ * @param type - The ENCRYPTION type to interpret the bytes as.
+ * @returns A typed `Plaintext` value.
+ */
 export declare function bytesToPlaintext(plaintext: Uint8Array, scheme: EncryptionScheme, type: SupportedFheType): Plaintext;
 export {};

package/dist/esm/encryption/encryption.js

@@ -2,7 +2,11 @@ import { Schema } from 'effect';
 import { bytesToHex, decodeAbiParameters, encodeAbiParameters, hexToBytes, } from 'viem';
 import { bigintToBytes, bigintToBytes32, Bytes32, bytesToBigInt, HexString, } from '../binary.js';
 import { handleTypes, InputContext } from '../handle.js';
-// TODO: review need of euint64 and euint160 as supported encrypted data type cause Lib.sol only supports euint256 and ebool
+/**
+ * Subset of ENCRYPTION types currently supported for encryption/decryption.
+ *
+ * @remarks TODO: review need of `euint64` and `euint160` — `Lib.sol` only supports `euint256` and `ebool`.
+ */
 export const supportedFheTypes = {
     euint64: handleTypes.euint64,
     euint160: handleTypes.euint160,
@@ -10,12 +14,21 @@ export const supportedFheTypes = {
     ebool: handleTypes.ebool,
 };
 const supportedFheTypeNames = Object.keys(supportedFheTypes);
+/** Schema that validates a string is one of the supported ENCRYPTION type names. */
 export const SupportedFheTypeName = Schema.Literal(...supportedFheTypeNames);
+/** Schema that validates a number is one of the supported ENCRYPTION type integer identifiers. */
 // TODO: extend to all types
 export const SupportedFheType = Schema.Literal(...Object.values(supportedFheTypes));
+/** Map of encryption scheme names to their integer identifiers. Currently only X-Wing (2) is supported. */
 export const encryptionSchemes = {
     xwing: 2,
 };
+/**
+ * Returns the human-readable name of an encryption scheme.
+ * @param scheme - The encryption scheme integer identifier.
+ * @returns The scheme name (e.g. `"X-Wing"`).
+ * @throws If the scheme identifier is unknown.
+ */
 export function getEncryptionSchemeName(scheme) {
     switch (scheme) {
         case encryptionSchemes.xwing:
@@ -24,22 +37,31 @@ export function getEncryptionSchemeName(scheme) {
             throw new Error(`Unknown encryption scheme: ${scheme}`);
     }
 }
+/** Schema that validates a value is a known encryption scheme identifier. */
 export const EncryptionScheme = Schema.Literal(encryptionSchemes.xwing);
+/** Schema for an ENCRYPTION ciphertext: encryption scheme, ENCRYPTION type, and the encrypted value as a hex string. */
 export const Ciphertext = Schema.Struct({
     scheme: EncryptionScheme,
     type: SupportedFheType,
     value: HexString,
 });
+/** Schema for a ciphertext paired with the {@link InputContext} it was encrypted under. */
 export const CiphertextWithContext = Schema.Struct({
     ciphertext: Ciphertext,
     context: InputContext,
 });
+/** Schema for the result of an encryption operation: ciphertext, input context, prehandle, and final handle. */
 export const EncryptResult = Schema.Struct({
     ciphertext: Ciphertext,
     context: InputContext,
     prehandle: Bytes32,
     handle: Bytes32,
 });
+/**
+ * Schema for an ENCRYPTION plaintext value. The `value` field type depends on the ENCRYPTION type:
+ * - `euint64` / `euint160` / `euint256`: `bigint`
+ * - `ebool`: `boolean`
+ */
 export const Plaintext = Schema.Union(Schema.Struct({
     scheme: EncryptionScheme,
     type: Schema.Literal(handleTypes.euint64, handleTypes.euint160, handleTypes.euint256),
@@ -49,10 +71,23 @@ export const Plaintext = Schema.Union(Schema.Struct({
     type: Schema.Literal(handleTypes.ebool),
     value: Schema.Boolean,
 }));
+/** Schema for a plaintext paired with the {@link InputContext} it will be encrypted under. */
 export const PlaintextWithContext = Schema.Struct({
     plaintext: Plaintext,
     context: InputContext,
 });
+/**
+ * Converts a `bigint` to a typed {@link Plaintext} value.
+ *
+ * For integer ENCRYPTION types (`euint64`, `euint160`, `euint256`) the value is passed through as-is.
+ * For `ebool`, non-zero values become `true`.
+ *
+ * @param scheme - The encryption scheme identifier.
+ * @param type - The ENCRYPTION type to interpret the value as.
+ * @param bigPt - The raw bigint plaintext value.
+ * @returns A typed `Plaintext` matching the given scheme and ENCRYPTION type.
+ * @throws If `type` is not a supported ENCRYPTION type.
+ */
 export function bigintToPlaintext(scheme, type, bigPt) {
     switch (type) {
         case handleTypes.euint64:
@@ -74,15 +109,29 @@ export function bigintToPlaintext(scheme, type, bigPt) {
     }
     throw new Error(`Unsupported Encryption Scheme type: ${type}`);
 }
-// This defines the schema we use for input encoding compatible with abi.decode
-// on chain:
-//   (bytes32 externalHandle, bytes memory ciphertext) = abi.decode(input, (bytes32, bytes));
-// It does not  refer to an actual contract or Solidity type's ABI
-// We consider this location the source of truth for the encoding
+/**
+ * ABI parameter schema for on-chain ciphertext input encoding.
+ *
+ * Compatible with Solidity's `abi.decode(input, (bytes32, bytes))`:
+ * ```solidity
+ * (bytes32 externalHandle, bytes memory ciphertext) = abi.decode(input, (bytes32, bytes));
+ * ```
+ *
+ * This is the source of truth for the encoding format and does not refer to
+ * an actual contract or Solidity type's ABI.
+ */
 const ciphertextInputAbi = [
     { name: 'handle', type: 'bytes32' },
     { name: 'ciphertext', type: 'bytes' },
 ];
+/**
+ * Decodes an ABI-encoded ciphertext input into its components.
+ *
+ * The input format is: `4-byte version || abi.encode(bytes32 handle, bytes ciphertext)`.
+ *
+ * @param input - The raw encoded input as a byte array or hex string.
+ * @returns The decoded version, handle, and ciphertext.
+ */
 export function decodeCiphertextInput(input) {
     const bytes = typeof input === 'string' ? hexToBytes(input) : input;
     const buf = new Uint8Array(bytes).buffer;
@@ -90,6 +139,16 @@ export function decodeCiphertextInput(input) {
     const [handle, ciphertext] = decodeAbiParameters(ciphertextInputAbi, bytes.slice(4));
     return { version, handle, ciphertext };
 }
+/**
+ * Encodes a handle and ciphertext into the on-chain input format.
+ *
+ * The output format is: `4-byte version || abi.encode(bytes32 handle, bytes ciphertext)`.
+ *
+ * @param version - The encoding version (int32).
+ * @param handle - The 32-byte handle as a hex string.
+ * @param ciphertext - The ciphertext as a hex string.
+ * @returns The ABI-encoded input as a hex string.
+ */
 export function encodeCiphertextInput(version, handle, ciphertext) {
     const rest = hexToBytes(encodeAbiParameters(ciphertextInputAbi, [handle, ciphertext]));
     const buf = new ArrayBuffer(rest.length + 4);
@@ -99,6 +158,14 @@ export function encodeCiphertextInput(version, handle, ciphertext) {
     view.set(rest, 4);
     return bytesToHex(view);
 }
+/**
+ * Converts a {@link Plaintext} to its `bigint` representation.
+ *
+ * Integer types pass through directly; `ebool` maps `true` → `1n`, `false` → `0n`.
+ *
+ * @param plaintext - The plaintext to convert.
+ * @returns The bigint representation of the plaintext value.
+ */
 export function plaintextToBigint(plaintext) {
     switch (plaintext.type) {
         case handleTypes.euint64:
@@ -109,16 +176,40 @@ export function plaintextToBigint(plaintext) {
             return plaintext.value ? 1n : 0n;
     }
 }
+/**
+ * Converts a {@link Plaintext} to a {@link Bytes32} hex string.
+ * @param plaintext - The plaintext to convert.
+ * @returns A 32-byte hex representation of the plaintext value.
+ */
 export function plaintextToBytes32(plaintext) {
     return bigintToBytes32(plaintextToBigint(plaintext));
 }
+/**
+ * Converts a {@link Plaintext} to a 32-byte `Buffer`.
+ * @param plaintext - The plaintext to convert.
+ * @returns A 32-byte big-endian buffer of the plaintext value.
+ */
 export function plaintextToBytes(plaintext) {
     return bigintToBytes(plaintextToBigint(plaintext));
 }
+/**
+ * Parses a {@link Bytes32} hex string into a typed {@link Plaintext}.
+ * @param plaintext - The 32-byte hex value to interpret.
+ * @param scheme - The encryption scheme identifier.
+ * @param type - The ENCRYPTION type to interpret the bytes as.
+ * @returns A typed `Plaintext` value.
+ */
 export function bytes32ToPlaintext(plaintext, scheme, type) {
     return bigintToPlaintext(scheme, type, BigInt(plaintext));
 }
+/**
+ * Parses a `Uint8Array` into a typed {@link Plaintext}.
+ * @param plaintext - The byte array to interpret.
+ * @param scheme - The encryption scheme identifier.
+ * @param type - The ENCRYPTION type to interpret the bytes as.
+ * @returns A typed `Plaintext` value.
+ */
 export function bytesToPlaintext(plaintext, scheme, type) {
     return bigintToPlaintext(scheme, type, BigInt(bytesToBigInt(plaintext)));
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/esm/generated/local-node.d.ts

@@ -19,9 +19,9 @@ export declare const localNodeLightningConfig: {
         readonly executorAddress: "0xDF3830489208461f72Df6E45D0e6cbF9DBB74fe1";
         readonly chainId: 31337;
         readonly covalidatorUrls: readonly ["http://localhost:50055"];
-        readonly signers: readonly ["0x686190B567C1EF3adD333B73ad9B4B092D8723c1"];
+        readonly signers: readonly ["0xadAA7b651e894D2B1F4929AC49d065b0143d1506"];
         readonly hostChainRpcUrl: "http://localhost:8545";
-        readonly senderPrivateKey: "0xcffaf5c90b8131b526b028c6c328b3e9f5079932e29a2ec3a1b7f29b383fd0e6";
+        readonly senderPrivateKey: "0xf829aecfc84240e8bfedfc3274d745a209a1e7d15693f424e0596ef55739215b";
     };
     readonly alphanet: {
         readonly executorAddress: "0xc0d693DeEF0A91CE39208676b6da09B822abd199";

package/dist/esm/generated/local-node.js

@@ -47,10 +47,10 @@ export const localNodeLightningConfig = {
             "http://localhost:50055"
         ],
         "signers": [
-            "0x686190B567C1EF3adD333B73ad9B4B092D8723c1"
+            "0xadAA7b651e894D2B1F4929AC49d065b0143d1506"
         ],
         "hostChainRpcUrl": "http://localhost:8545",
-        "senderPrivateKey": "0xcffaf5c90b8131b526b028c6c328b3e9f5079932e29a2ec3a1b7f29b383fd0e6"
+        "senderPrivateKey": "0xf829aecfc84240e8bfedfc3274d745a209a1e7d15693f424e0596ef55739215b"
     },
     "alphanet": {
         "executorAddress": "0xc0d693DeEF0A91CE39208676b6da09B822abd199",

package/dist/esm/handle.d.ts

@@ -1,6 +1,14 @@
 import { Schema } from 'effect';
 import { HexString } from './binary.js';
+/** Current handle version byte, appended as the last byte of every handle. */
 export declare const HANDLE_VERSION = 0;
+/**
+ * Map of ENCRYPTION type names to their integer identifiers (matching tfhe-rs `FheType`).
+ *
+ * Keys provide a semantic interpretation over the underlying integral type.
+ * For example, `ebool` interprets a `uint16` as a boolean, `ebytes64` interprets
+ * a `uint512` as a 64-byte array, etc.
+ */
 export declare const handleTypes: Readonly<{
     ebool: 0;
     euint4: 1;
@@ -15,11 +23,21 @@ export declare const handleTypes: Readonly<{
     ebytes128: 10;
     ebytes256: 11;
 }>;
+/** Schema that validates a string is one of the known ENCRYPTION type names (e.g. `"ebool"`, `"euint256"`). */
 export declare const HandleTypeName: Schema.SchemaClass<"ebool" | "euint4" | "euint8" | "euint16" | "euint32" | "euint64" | "euint128" | "euint160" | "euint256" | "ebytes64" | "ebytes128" | "ebytes256", "ebool" | "euint4" | "euint8" | "euint16" | "euint32" | "euint64" | "euint128" | "euint160" | "euint256" | "ebytes64" | "ebytes128" | "ebytes256", never>;
+/** A valid ENCRYPTION type name string (e.g. `"ebool"`, `"euint32"`, `"ebytes64"`). */
 export type HandleTypeName = typeof HandleTypeName.Type;
+/** The typeof {@link handleTypes} — mapping from ENCRYPTION type names to integer IDs. */
 export type HandleTypes = typeof handleTypes;
+/** Integer identifier of an ENCRYPTION type (0–11), corresponding to a {@link HandleTypeName}. */
 export type FheType = HandleTypes[keyof HandleTypes];
+/**
+ * Type guard that checks whether a number is a valid {@link FheType} identifier.
+ * @param value - The number to check.
+ * @returns `true` if `value` is a known ENCRYPTION type integer (0–11).
+ */
 export declare function isFheType(value: number): value is FheType;
+/** Schema for the context required to compute a deterministic ENCRYPTION handle from a prehandle. */
 export declare const InputContext: Schema.Struct<{
     hostChainId: typeof Schema.BigInt;
     aclAddress: Schema.TemplateLiteral<`0x${string}`>;
@@ -27,7 +45,15 @@ export declare const InputContext: Schema.Struct<{
     contractAddress: Schema.TemplateLiteral<`0x${string}`>;
     version: typeof Schema.Number;
 }>;
+/** Context fields (chain ID, ACL address, user/contract addresses, version) used to derive a deterministic handle. */
 export type InputContext = typeof InputContext.Type;
+/**
+ * A 32-byte hex string representing an ENCRYPTION ciphertext handle.
+ *
+ * Format: `keccak_hash[0:29] || index_handle || handle_type || handle_version`
+ *
+ * @see {@link https://github.com/Inco-fhevm/inco-monorepo/blob/636756f512ae16535bdcb9a43df76bf14fbd6ba7/pkg/fhe/handle.md Handle format spec}
+ */
 export type Handle = HexString;
 /**
  * Expected length of a handle in bytes.
@@ -41,6 +67,13 @@ export declare const HANDLE_LENGTH_BYTES = 32;
  * @throws Error if handle is malformed (wrong format, length, or unsupported version)
  */
 export declare function validateHandle(handle: HexString): void;
+/**
+ * Extracts the {@link FheType} from byte 30 of a validated handle.
+ * @param handle - A 32-byte hex handle string.
+ * @returns The ENCRYPTION type identifier stored in the handle.
+ * @throws If the handle is malformed or contains an invalid ENCRYPTION type.
+ * @see {@link https://github.com/Inco-fhevm/inco-monorepo/blob/636756f512ae16535bdcb9a43df76bf14fbd6ba7/pkg/fhe/handle.md Handle format spec}
+ */
 export declare function getHandleType(handle: HexString): FheType;
 /**
  *  Computes the prehandle hash for an input based on the ciphertext
@@ -67,4 +100,12 @@ export declare function computeHandle({ prehandle, context, }: {
     prehandle: Uint8Array;
     context: InputContext;
 }): Buffer;
+/**
+ * Computes the Keccak-256 hash of an ABI-packed {@link InputContext}.
+ *
+ * The context is packed as: `"evm/" || chainId || aclAddress || userAddress || contractAddress || version`.
+ *
+ * @param context - The input context to hash.
+ * @returns A 32-byte `Buffer` containing the Keccak-256 digest.
+ */
 export declare function hashInputContext(context: InputContext): Buffer;

package/dist/esm/handle.js

@@ -3,10 +3,15 @@ import { Schema } from 'effect';
 import { Keccak } from 'sha3';
 import { encodePacked, hexToBytes, toHex } from 'viem';
 import { HexString } from './binary.js';
+/** Current handle version byte, appended as the last byte of every handle. */
 export const HANDLE_VERSION = 0;
-// This enum maps to FheType as defined in tfhe-rs in value, but the keys provide an additional interpretation over
-// the underlying integral FheType. For example, ebool interprets an uint16 as a boolean, ebytes64 interprets an uint512
-// as a 64-byte array, etc.
+/**
+ * Map of ENCRYPTION type names to their integer identifiers (matching tfhe-rs `FheType`).
+ *
+ * Keys provide a semantic interpretation over the underlying integral type.
+ * For example, `ebool` interprets a `uint16` as a boolean, `ebytes64` interprets
+ * a `uint512` as a 64-byte array, etc.
+ */
 export const handleTypes = Object.freeze({
     ebool: 0,
     euint4: 1,
@@ -22,10 +27,17 @@ export const handleTypes = Object.freeze({
     ebytes256: 11,
 });
 const handleNames = Object.keys(handleTypes);
+/** Schema that validates a string is one of the known ENCRYPTION type names (e.g. `"ebool"`, `"euint256"`). */
 export const HandleTypeName = Schema.Literal(...handleNames);
+/**
+ * Type guard that checks whether a number is a valid {@link FheType} identifier.
+ * @param value - The number to check.
+ * @returns `true` if `value` is a known ENCRYPTION type integer (0–11).
+ */
 export function isFheType(value) {
     return Object.values(handleTypes).includes(value);
 }
+/** Schema for the context required to compute a deterministic ENCRYPTION handle from a prehandle. */
 export const InputContext = Schema.Struct({
     hostChainId: Schema.BigInt,
     aclAddress: HexString,
@@ -57,8 +69,13 @@ export function validateHandle(handle) {
         throw new Error(`Unsupported handle version: expected ${HANDLE_VERSION}, got ${handleVersion} for handle ${handle}`);
     }
 }
-// Returns the FheType of the handle. See:
-// https://github.com/Inco-fhevm/inco-monorepo/blob/636756f512ae16535bdcb9a43df76bf14fbd6ba7/pkg/fhe/handle.md
+/**
+ * Extracts the {@link FheType} from byte 30 of a validated handle.
+ * @param handle - A 32-byte hex handle string.
+ * @returns The ENCRYPTION type identifier stored in the handle.
+ * @throws If the handle is malformed or contains an invalid ENCRYPTION type.
+ * @see {@link https://github.com/Inco-fhevm/inco-monorepo/blob/636756f512ae16535bdcb9a43df76bf14fbd6ba7/pkg/fhe/handle.md Handle format spec}
+ */
 export function getHandleType(handle) {
     // Validate handle integrity before extracting type
     validateHandle(handle);
@@ -129,6 +146,14 @@ export function computeHandle({ prehandle, context, }) {
         prehandle.slice(29, 32),
     ]);
 }
+/**
+ * Computes the Keccak-256 hash of an ABI-packed {@link InputContext}.
+ *
+ * The context is packed as: `"evm/" || chainId || aclAddress || userAddress || contractAddress || version`.
+ *
+ * @param context - The input context to hash.
+ * @returns A 32-byte `Buffer` containing the Keccak-256 digest.
+ */
 export function hashInputContext(context) {
     const packed = encodePacked(['string', 'uint256', 'address', 'address', 'address', 'uint16'], [
         // Note: The x/hostchain spec requires the chain ID to be prefixed with 'evm/' for EVM chains
@@ -146,4 +171,4 @@ function assertUint8(value) {
         throw new Error(`Invalid uint8 value: ${value}`);
     }
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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