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

package/dist/types/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/types/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 ["0x16844D5b82DdA890dc4DFc1407Ce4b1ebFdF6a93"];
         readonly hostChainRpcUrl: "http://localhost:8545";
-        readonly senderPrivateKey: "0xcffaf5c90b8131b526b028c6c328b3e9f5079932e29a2ec3a1b7f29b383fd0e6";
+        readonly senderPrivateKey: "0x3f9007c8e8de6208a5af414990834e80920255754b247f8a2cdeb293587cab1b";
     };
     readonly alphanet: {
         readonly executorAddress: "0xc0d693DeEF0A91CE39208676b6da09B822abd199";

package/dist/types/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/types/lite/lightning.d.ts

@@ -127,6 +127,7 @@ export declare class Lightning<T extends DeploymentSlice = DeploymentSlice> {
      * @param chain the chain to use to filter the deployments
      */
     static latest<P extends Pepper>(pepper: P, chainId: ChainId): Promise<Lightning<Deployment>>;
+    /** Returns a shallow copy of the deployment configuration this Lightning instance is bound to. */
     get deployment(): T;
     /**
      * Encrypt a value using the network's public key (ECIES or X-Wing).
@@ -384,7 +385,25 @@ export declare class Lightning<T extends DeploymentSlice = DeploymentSlice> {
     }, threshold: number): string[];
     private static isIdByName;
     private static plaintextFromValue;
+    /**
+     * Reads the network public key from the on-chain Inco Verifier contract.
+     *
+     * Falls back to the legacy `eciesPubkey()` getter for older contract versions.
+     *
+     * @param client - A viem public client connected to the host chain.
+     * @param executorAddress - The address of the Inco Lightning executor contract.
+     * @returns The network public key as a hex string.
+     */
     static getNetworkPubkey(client: PublicClient, executorAddress: Address): Promise<HexString>;
+    /**
+     * Resolves the Inco Verifier contract instance associated with a Lightning executor.
+     *
+     * Reads the `incoVerifier` address from the executor contract and returns a typed contract handle.
+     *
+     * @param client - A viem public client connected to the host chain.
+     * @param executorAddress - The address of the Inco Lightning executor contract.
+     * @returns A viem contract instance bound to the Inco Verifier ABI.
+     */
     static getIncoVerifierContract(client: PublicClient, executorAddress: Address): Promise<GetContractReturnType<typeof incoVerifierAbi, PublicClient, Address>>;
     /**
      * Retrieves the verifier contract details including threshold, signers, and XWING public key from the Inco Verifier contract.

package/dist/types/local/local-node.d.ts

@@ -1,4 +1,10 @@
 import { Schema } from 'effect';
+/**
+ * Schema for the environment variables required to connect to a local Inco node.
+ *
+ * Includes executor/sender addresses, keys, covalidator settings, and optional
+ * remote compute-server overrides. Typically populated from a `.env` file.
+ */
 export declare const LocalNodeEnv: Schema.Struct<{
     DEPLOYER_ADDRESS: Schema.brand<Schema.filter<Schema.TemplateLiteral<`0x${string}`>>, "Address">;
     STATE_DUMP: typeof Schema.String;
@@ -14,6 +20,18 @@ export declare const LocalNodeEnv: Schema.Struct<{
     COVALIDATOR_HOST_CHAIN_ID: Schema.optional<typeof Schema.String>;
     COVALIDATOR_URL: Schema.optional<typeof Schema.String>;
     COVALIDATOR_HOST_CHAIN_RPC_URL: Schema.optional<typeof Schema.String>;
+    COVALIDATOR_COMPUTE_TYPE: Schema.optional<typeof Schema.String>;
+    COVALIDATOR_STORAGE_KEY: Schema.optional<Schema.TemplateLiteral<`0x${string}`>>;
 }>;
+/** Parsed local node environment configuration. */
 export type LocalNodeEnv = typeof LocalNodeEnv.Type;
+/**
+ * Parses a dotenv-formatted string or `Buffer` into a validated {@link LocalNodeEnv}.
+ *
+ * Falls back to `process.env` when no argument is provided.
+ *
+ * @param envFileOrObj - A dotenv-formatted string, `Buffer`, or `undefined` to use `process.env`.
+ * @returns A validated `LocalNodeEnv` object.
+ * @throws If required environment variables are missing or invalid.
+ */
 export declare function parseLocalEnv(envFileOrObj?: string | Buffer): LocalNodeEnv;

package/dist/types/reencryption/eip712.d.ts

@@ -14,9 +14,36 @@ declare const baseEIP712: Schema.Struct<{
     }>>>;
 }>;
 type BaseEIP712 = typeof baseEIP712.Type;
+/**
+ * An EIP-712 typed data payload with a generic `message` field.
+ *
+ * Extends the base EIP-712 structure (domain, primaryType, types) with
+ * a strongly-typed `message` object for signing.
+ *
+ * @typeParam Message - The shape of the application-specific message to sign.
+ */
 export interface EIP712<Message extends object> extends BaseEIP712 {
     message: Message;
 }
+/**
+ * Creates an EIP-712 typed data payload for user signing.
+ *
+ * Used to verify the user controls the private key corresponding to the ephemeral
+ * public key embedded in the payload. The `message` keys must exactly match the
+ * `name` values in `primaryTypeFields`.
+ *
+ * @typeParam PrimaryType - The EIP-712 primary type name.
+ * @typeParam Message - The shape of the message to sign.
+ * @param params.chainId - The chain ID for the EIP-712 domain.
+ * @param params.primaryType - The primary type name (e.g. `"Reencrypt"`).
+ * @param params.primaryTypeFields - The field definitions for the primary type.
+ * @param params.message - The message object to sign (must match `primaryTypeFields`).
+ * @param params.verifyingContract - Optional verifying contract address for the domain.
+ * @param params.domainName - Human-readable name for the EIP-712 domain.
+ * @param params.domainVersion - Version string for the EIP-712 domain.
+ * @returns A complete {@link EIP712} payload ready for signing.
+ * @throws If message keys do not match `primaryTypeFields` names.
+ */
 export declare function createEIP712Payload<PrimaryType extends string, Message extends object>({ chainId, primaryType, primaryTypeFields, message, verifyingContract, domainName, domainVersion, }: {
     chainId: bigint;
     primaryType: PrimaryType;

package/dist/types/reencryption/types.d.ts

@@ -4,18 +4,42 @@ import { CiphertextOf, EncryptionScheme, PlaintextOf, SupportedFheType } from '.
 import { Handle } from '../handle.js';
 import type { XwingKeypair } from '../lite/xwing.js';
 import type { BackoffConfig } from '../retry.js';
+/**
+ * The core reencryption function type. Takes a handle (and optional ciphertext) and returns
+ * the decrypted plaintext. Supports retry configuration for handles that are not yet available.
+ *
+ * @typeParam S - The encryption scheme (e.g. X-Wing).
+ */
 export type Reencryptor<S extends EncryptionScheme> = <T extends SupportedFheType>(args: ReencryptFnArgs<S, T>, backoffConfig?: Partial<BackoffConfig>) => Promise<PlaintextOf<S, T>>;
+/** Arguments required to construct a {@link Reencryptor}. */
 export interface ReencryptorArgs {
     chainId: bigint;
 }
+/**
+ * Arguments for a single reencryption call.
+ *
+ * @typeParam S - The encryption scheme.
+ * @typeParam T - The ENCRYPTION type of the ciphertext.
+ */
 export type ReencryptFnArgs<S extends EncryptionScheme, T extends SupportedFheType> = {
     handle: Handle;
+    /**
+     * Optional ciphertext hint. If provided, the reencrypt endpoint may use it directly
+     * instead of fetching from the covalidators.
+     */
     ciphertext?: CiphertextOf<S, T>;
 };
+/** Union of supported ephemeral keypair types for reencryption (currently X-Wing only). */
 export type SupportedEphemeralKeypairs = XwingKeypair;
+/** An object whose public key can be serialized to a `Uint8Array`. */
 export interface PubKeyEncodable {
     encodePublicKey(): Uint8Array;
 }
+/**
+ * A reencryption request to be sent to a reencrypt endpoint.
+ *
+ * @typeParam EKP - The type of ephemeral keypair used for the reencryption session.
+ */
 export interface ReencryptEndpointRequest<EKP extends SupportedEphemeralKeypairs> {
     userAddress: Address;
     handle: Handle;

package/dist/types/viem.d.ts

@@ -1,5 +1,6 @@
 import { Chain } from 'viem';
 import { Chainish } from './chain.js';
+/** Map of supported chain short names to their viem chain objects. */
 export declare const chains: {
     sepolia: {
         blockExplorers: {
@@ -778,4 +779,14 @@ export declare const chains: {
         readonly network: "worldchain-sepolia";
     };
 };
+/**
+ * Resolves a {@link Chainish} value to a viem {@link Chain} object.
+ *
+ * Accepts a chain ID (`number` or `bigint`), an object with an `id` field,
+ * or a chain short name (e.g. `"baseSepolia"`).
+ *
+ * @param chainish - The chain identifier to resolve.
+ * @returns The matching `viem` chain object.
+ * @throws If no supported chain matches the given identifier.
+ */
 export declare function getViemChain(chainish: Chainish): Chain;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@inco/js",
-  "version": "0.8.0-devnet-11",
+  "version": "0.8.0-devnet-12",
   "repository": "https://github.com/Inco-fhevm/inco-monorepo",
   "license": "Apache-2.0",
   "sideEffects": false,
@@ -24,12 +24,6 @@
       "require": "./dist/cjs/lite/index.js",
       "default": "./dist/cjs/lite/index.js"
     },
-    "./fhevm": {
-      "types": "./dist/types/fhevm/index.d.ts",
-      "import": "./dist/esm/fhevm/index.js",
-      "require": "./dist/cjs/fhevm/index.js",
-      "default": "./dist/cjs/fhevm/index.js"
-    },
     "./reencryption": {
       "types": "./dist/types/reencryption/index.d.ts",
       "import": "./dist/esm/reencryption/index.js",