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

package/dist/cjs/binary.d.ts

@@ -1,22 +1,106 @@
 import { Schema } from 'effect';
 import { Hex } from 'viem';
+/** Schema for a `0x`-prefixed hex string. */
 export declare const HexString: Schema.TemplateLiteral<`0x${string}`>;
+/** A `0x`-prefixed hex-encoded string (e.g. `"0xdeadbeef"`). */
 export type HexString = typeof HexString.Type;
+/** A value that can represent raw bytes — either a hex string or a `Uint8Array`. */
 export type BytesIsh = string | Uint8Array;
+/**
+ * Converts a `Uint8Array` to a `bigint`. Returns `0n` for empty arrays.
+ * @param byteArray - The byte array to convert.
+ * @returns The unsigned big-endian integer representation of the bytes.
+ */
 export declare function bytesToBigInt(byteArray: Uint8Array): bigint;
+/**
+ * Converts a `Buffer` to a `bigint`.
+ * @param buffer - The buffer to convert.
+ * @returns The unsigned big-endian integer representation of the buffer.
+ */
 export declare function bufferToBigInt(buffer: Buffer): bigint;
+/**
+ * Converts a `bigint` to a 32-byte `Buffer`, zero-padded on the left.
+ * @param value - The bigint to convert.
+ * @returns A 32-byte big-endian buffer.
+ */
 export declare function bigintToBytes(value: bigint): Buffer;
+/**
+ * Converts a `bigint` to a {@link Bytes32} hex string, left-padded to 32 bytes.
+ *
+ * **Warning:** It is the caller's responsibility to ensure the value fits in
+ * 32 bytes. Values that are too large will be silently truncated.
+ *
+ * @param value - The bigint to convert.
+ * @returns A `Bytes32` hex string.
+ */
 export declare function bigintToBytes32(value: bigint): Bytes32;
+/**
+ * Left-pads a byte array with zeros to the specified length.
+ * @param bs - The byte array to pad.
+ * @param n - The desired total length in bytes.
+ * @returns A new `Buffer` of length `n` with `bs` right-aligned.
+ * @throws If `bs` is longer than `n` (would require truncation).
+ */
 export declare function padLeft(bs: Uint8Array, n: number): Buffer;
+/**
+ * Parses a {@link BytesIsh} value as a 32-byte value and converts it to a `bigint`.
+ * @param bs - A hex string or `Uint8Array` representing exactly 32 bytes.
+ * @returns The `bigint` representation of the 32-byte value.
+ * @throws If the input is not exactly 32 bytes.
+ */
 export declare function bytes32ToBigint(bs: BytesIsh): bigint;
+/**
+ * Decodes a hex string into a `Buffer`. Handles both `0x`-prefixed and bare hex strings.
+ * @param hexString - The hex string to decode.
+ * @returns A `Buffer` containing the decoded bytes.
+ */
 export declare function bytesFromHexString(hexString: string): Buffer;
+/**
+ * Asserts that a string is a valid `0x`-prefixed hex string and narrows its type to `Hex`.
+ * @param value - The string to validate.
+ * @returns The input typed as `Hex`.
+ * @throws If `value` is not a valid hex string.
+ */
 export declare function mustBeHex(value: string): Hex;
+/**
+ * Normalises a string to a `0x`-prefixed `Hex` value, adding the prefix if missing.
+ * @param value - A hex string, with or without a `0x` prefix.
+ * @returns The `0x`-prefixed `Hex` string.
+ * @throws If the resulting string is not valid hex.
+ */
 export declare function normaliseToHex(value: string): Hex;
+/**
+ * Encodes a `Uint8Array` as a `0x`-prefixed hex string.
+ * @param bs - The byte array to encode.
+ * @returns A `Hex` string representation of the bytes.
+ */
 export declare function bytesToHex(bs: Uint8Array): Hex;
+/** Schema for a 32-byte (66-character with `0x` prefix) hex string, branded as `Bytes32`. Accepts both hex strings and `Uint8Array` inputs. */
 export declare const Bytes32: 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">;
+/**
+ * Parses and validates a {@link BytesIsh} value as a {@link Bytes32}.
+ * @param x - A hex string or `Uint8Array` to parse.
+ * @returns A validated `Bytes32` value.
+ * @throws If the input is not exactly 32 bytes.
+ */
 export declare function asBytes32(x: BytesIsh): Bytes32;
+/** A branded 32-byte hex string type (`0x` + 64 hex characters). */
 export type Bytes32 = typeof Bytes32.Type;
+/** A branded 20-byte Ethereum address type (`0x` + 40 hex characters). */
 export type Address = typeof Address.Type;
+/** Schema for a 20-byte `0x`-prefixed Ethereum address, branded as `Address`. */
 export declare const Address: Schema.brand<Schema.filter<Schema.TemplateLiteral<`0x${string}`>>, "Address">;
+/**
+ * Parses and validates a string as an Ethereum {@link Address} (20-byte, `0x`-prefixed).
+ * @param address - The string to parse.
+ * @returns A validated `Address` value.
+ * @throws If the input is not a valid 20-byte hex address.
+ */
 export declare function parseAddress(address: string): Address;
+/**
+ * Parses and validates a string as a {@link HexString} (`0x`-prefixed).
+ * @param hex - The string to parse.
+ * @returns A validated `HexString` value.
+ * @throws If the input is not a valid `0x`-prefixed hex string.
+ */
 export declare function parseHex(hex: string): HexString;

package/dist/cjs/binary.js

@@ -17,25 +17,54 @@ exports.parseHex = parseHex;
 const effect_1 = require("effect");
 const viem_1 = require("viem");
 const schema_js_1 = require("./schema.js");
+/** Schema for a `0x`-prefixed hex string. */
 exports.HexString = effect_1.Schema.TemplateLiteral('0x', effect_1.Schema.String);
+/**
+ * Converts a `Uint8Array` to a `bigint`. Returns `0n` for empty arrays.
+ * @param byteArray - The byte array to convert.
+ * @returns The unsigned big-endian integer representation of the bytes.
+ */
 function bytesToBigInt(byteArray) {
     // Ugly but better than bigint-buffer that insists on writing junk to stderr if it doesn't have native bindings
     return !byteArray?.length
         ? BigInt(0)
         : BigInt('0x' + Buffer.from(byteArray).toString('hex'));
 }
+/**
+ * Converts a `Buffer` to a `bigint`.
+ * @param buffer - The buffer to convert.
+ * @returns The unsigned big-endian integer representation of the buffer.
+ */
 function bufferToBigInt(buffer) {
     return bytesToBigInt(Uint8Array.from(buffer));
 }
+/**
+ * Converts a `bigint` to a 32-byte `Buffer`, zero-padded on the left.
+ * @param value - The bigint to convert.
+ * @returns A 32-byte big-endian buffer.
+ */
 function bigintToBytes(value) {
     return Buffer.from(value.toString(16).padStart(64, '0'), 'hex');
 }
-// Convert a bigint to a 32-byte array, left-padded if necessary. Note: it is
-// caller's responsibility to ensure that the bigint is not too large to fit in
-// 32 bytes, or else the result will be truncated.
+/**
+ * Converts a `bigint` to a {@link Bytes32} hex string, left-padded to 32 bytes.
+ *
+ * **Warning:** It is the caller's responsibility to ensure the value fits in
+ * 32 bytes. Values that are too large will be silently truncated.
+ *
+ * @param value - The bigint to convert.
+ * @returns A `Bytes32` hex string.
+ */
 function bigintToBytes32(value) {
     return (0, schema_js_1.parse)(exports.Bytes32, bigintToBytes(value).toString('hex'));
 }
+/**
+ * Left-pads a byte array with zeros to the specified length.
+ * @param bs - The byte array to pad.
+ * @param n - The desired total length in bytes.
+ * @returns A new `Buffer` of length `n` with `bs` right-aligned.
+ * @throws If `bs` is longer than `n` (would require truncation).
+ */
 function padLeft(bs, n) {
     if (bs.length > n) {
         throw new Error(`Cannot pad ${bs.length} bytes to ${n} - would truncate`);
@@ -44,22 +73,50 @@ function padLeft(bs, n) {
     buf.set(bs, n - bs.length);
     return buf;
 }
+/**
+ * Parses a {@link BytesIsh} value as a 32-byte value and converts it to a `bigint`.
+ * @param bs - A hex string or `Uint8Array` representing exactly 32 bytes.
+ * @returns The `bigint` representation of the 32-byte value.
+ * @throws If the input is not exactly 32 bytes.
+ */
 function bytes32ToBigint(bs) {
     const bytes32 = asBytes32(bs);
     return BigInt(bytes32);
 }
+/**
+ * Decodes a hex string into a `Buffer`. Handles both `0x`-prefixed and bare hex strings.
+ * @param hexString - The hex string to decode.
+ * @returns A `Buffer` containing the decoded bytes.
+ */
 function bytesFromHexString(hexString) {
     return Buffer.from(hexString.startsWith('0x') ? hexString.slice(2) : hexString, 'hex');
 }
+/**
+ * Asserts that a string is a valid `0x`-prefixed hex string and narrows its type to `Hex`.
+ * @param value - The string to validate.
+ * @returns The input typed as `Hex`.
+ * @throws If `value` is not a valid hex string.
+ */
 function mustBeHex(value) {
     if (!(0, viem_1.isHex)(value)) {
         throw new Error(`Expected hex string, got: ${value}`);
     }
     return value;
 }
+/**
+ * Normalises a string to a `0x`-prefixed `Hex` value, adding the prefix if missing.
+ * @param value - A hex string, with or without a `0x` prefix.
+ * @returns The `0x`-prefixed `Hex` string.
+ * @throws If the resulting string is not valid hex.
+ */
 function normaliseToHex(value) {
     return mustBeHex(value.startsWith('0x') ? value : `0x${value}`);
 }
+/**
+ * Encodes a `Uint8Array` as a `0x`-prefixed hex string.
+ * @param bs - The byte array to encode.
+ * @returns A `Hex` string representation of the bytes.
+ */
 function bytesToHex(bs) {
     return ('0x' + Buffer.from(bs).toString('hex'));
 }
@@ -73,17 +130,37 @@ const BytesToHex = effect_1.Schema.transformOrFail(effect_1.Schema.Union(effect_
             ? effect_1.ParseResult.succeed(y)
             : effect_1.ParseResult.fail(new effect_1.ParseResult.Unexpected(y, `'${y}' is not a hex string`)))(normaliseToHex(x)),
 });
+/** Schema for a 32-byte (66-character with `0x` prefix) hex string, branded as `Bytes32`. Accepts both hex strings and `Uint8Array` inputs. */
 exports.Bytes32 = BytesToHex.pipe(effect_1.Schema.filter((x) => x.length === 66 ||
     `Expected 32-byte hex string (66 characters with 0x prefix) but got ${x.length} character string`), effect_1.Schema.brand('Bytes32'));
+/**
+ * Parses and validates a {@link BytesIsh} value as a {@link Bytes32}.
+ * @param x - A hex string or `Uint8Array` to parse.
+ * @returns A validated `Bytes32` value.
+ * @throws If the input is not exactly 32 bytes.
+ */
 function asBytes32(x) {
     return (0, schema_js_1.parse)(exports.Bytes32, x);
 }
+/** Schema for a 20-byte `0x`-prefixed Ethereum address, branded as `Address`. */
 exports.Address = exports.HexString.pipe(effect_1.Schema.filter((s) => s.length === 42 ||
     `Address must be a 20-byte '0x'-prefixed hex string, but got: ${s}`), effect_1.Schema.brand('Address'));
+/**
+ * Parses and validates a string as an Ethereum {@link Address} (20-byte, `0x`-prefixed).
+ * @param address - The string to parse.
+ * @returns A validated `Address` value.
+ * @throws If the input is not a valid 20-byte hex address.
+ */
 function parseAddress(address) {
     return (0, schema_js_1.parse)(exports.Address, address);
 }
+/**
+ * Parses and validates a string as a {@link HexString} (`0x`-prefixed).
+ * @param hex - The string to parse.
+ * @returns A validated `HexString` value.
+ * @throws If the input is not a valid `0x`-prefixed hex string.
+ */
 function parseHex(hex) {
     return (0, schema_js_1.parse)(exports.HexString, hex);
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/cjs/chain.d.ts

@@ -1,3 +1,9 @@
+/**
+ * Map of supported chain short names to their chain IDs.
+ *
+ * @remarks This mirrors viem chain definitions without depending on viem directly,
+ * to work around Pulumi closure serialisation issues.
+ */
 export declare const supportedChains: {
     readonly baseSepolia: 84532;
     readonly sepolia: 11155111;
@@ -6,20 +12,31 @@ export declare const supportedChains: {
     readonly worldchainSepolia: 4801;
     readonly anvil: 31337;
 };
-export declare const fheSupportedChains: {
-    readonly baseSepolia: 84532;
-    readonly sepolia: 11155111;
-};
 type SupportedChains = typeof supportedChains;
+/** Numeric chain ID of a supported chain (e.g. `84532`, `11155111`). */
 export type SupportedChainId = SupportedChains[keyof SupportedChains];
+/** Short name of a supported chain (e.g. `"baseSepolia"`, `"sepolia"`). */
 export type SupportedChainName = keyof SupportedChains;
+/** A supported chain identified by both its short name and numeric ID. */
 export type SupportedChain = {
     name: SupportedChainName;
     id: SupportedChainId;
 };
+/** A value that can represent a number — either a `number` or a `bigint`. */
 export type Numberish = number | bigint;
+/** A flexible chain identifier: a chain ID (`number` | `bigint`), an object with an `id` field, or a chain short name. */
 export type Chainish = {
     id: Numberish;
 } | Numberish | string;
+/**
+ * Resolves a {@link Chainish} value to a {@link SupportedChain}.
+ *
+ * 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 `SupportedChain` with both `name` and `id`.
+ * @throws If no supported chain matches the given identifier.
+ */
 export declare function getSupportedChain(chainish: Chainish): SupportedChain;
 export {};

package/dist/cjs/chain.js

@@ -1,11 +1,17 @@
 "use strict";
 // No imports here to avoid issues with closures and modules across pulumi boundary
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.fheSupportedChains = exports.supportedChains = void 0;
+exports.supportedChains = void 0;
 exports.getSupportedChain = getSupportedChain;
 // This file can be seen as mirroring the functionality of viem changes without depending on it directly.
 // It exists as a workaround for some very gnarly issues with code reuse between Pulumi and this module, partly
 // relating to modules but also linked to Pulumi's ability to capture closures and serialise them.
+/**
+ * Map of supported chain short names to their chain IDs.
+ *
+ * @remarks This mirrors viem chain definitions without depending on viem directly,
+ * to work around Pulumi closure serialisation issues.
+ */
 exports.supportedChains = {
     baseSepolia: 84532,
     sepolia: 11155111,
@@ -14,11 +20,16 @@ exports.supportedChains = {
     worldchainSepolia: 4801,
     anvil: 31337,
 };
-exports.fheSupportedChains = {
-    baseSepolia: 84532,
-    sepolia: 11155111,
-};
-// Get supportedChain either by its chain ID or the short name (lower pascal case)
+/**
+ * Resolves a {@link Chainish} value to a {@link SupportedChain}.
+ *
+ * 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 `SupportedChain` with both `name` and `id`.
+ * @throws If no supported chain matches the given identifier.
+ */
 function getSupportedChain(chainish) {
     const found = typeof chainish === 'number' || typeof chainish === 'bigint'
         ? Object.entries(exports.supportedChains).find(([, id]) => id === Number(chainish))
@@ -31,4 +42,4 @@ function getSupportedChain(chainish) {
     const [name, id] = found;
     return { name: name, id };
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2hhaW4uanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvY2hhaW4udHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IjtBQUFBLG1GQUFtRjs7O0FBaUNuRiw4Q0FrQkM7QUFqREQseUdBQXlHO0FBQ3pHLCtHQUErRztBQUMvRyxrR0FBa0c7QUFFckYsUUFBQSxlQUFlLEdBQUc7SUFDN0IsV0FBVyxFQUFFLEtBQUs7SUFDbEIsT0FBTyxFQUFFLFFBQVE7SUFDakIsWUFBWSxFQUFFLEtBQUs7SUFDbkIsYUFBYSxFQUFFLElBQUk7SUFDbkIsaUJBQWlCLEVBQUUsSUFBSTtJQUN2QixLQUFLLEVBQUUsS0FBSztDQUNKLENBQUM7QUFFRSxRQUFBLGtCQUFrQixHQUFHO0lBQ2hDLFdBQVcsRUFBRSxLQUFLO0lBQ2xCLE9BQU8sRUFBRSxRQUFRO0NBQ1QsQ0FBQztBQWNYLGtGQUFrRjtBQUNsRixTQUFnQixpQkFBaUIsQ0FBQyxRQUFrQjtJQUNsRCxNQUFNLEtBQUssR0FDVCxPQUFPLFFBQVEsS0FBSyxRQUFRLElBQUksT0FBTyxRQUFRLEtBQUssUUFBUTtRQUMxRCxDQUFDLENBQUMsTUFBTSxDQUFDLE9BQU8sQ0FBQyx1QkFBZSxDQUFDLENBQUMsSUFBSSxDQUNsQyxDQUFDLENBQUMsRUFBRSxFQUFFLENBQUMsRUFBRSxFQUFFLENBQUMsRUFBRSxLQUFLLE1BQU0sQ0FBQyxRQUFRLENBQUMsQ0FDcEM7UUFDSCxDQUFDLENBQUMsT0FBTyxRQUFRLEtBQUssUUFBUTtZQUM1QixDQUFDLENBQUMsTUFBTSxDQUFDLE9BQU8sQ0FBQyx1QkFBZSxDQUFDLENBQUMsSUFBSSxDQUNsQyxDQUFDLENBQUMsRUFBRSxFQUFFLENBQUMsRUFBRSxFQUFFLENBQUMsRUFBRSxLQUFLLE1BQU0sQ0FBQyxRQUFRLENBQUMsRUFBRSxDQUFDLENBQ3ZDO1lBQ0gsQ0FBQyxDQUFDLE1BQU0sQ0FBQyxPQUFPLENBQUMsdUJBQWUsQ0FBQyxDQUFDLElBQUksQ0FDbEMsQ0FBQyxDQUFDLFNBQVMsQ0FBQyxFQUFFLEVBQUUsQ0FBQyxTQUFTLEtBQUssUUFBUSxDQUN4QyxDQUFDO0lBQ1YsSUFBSSxDQUFDLEtBQUssRUFBRSxDQUFDO1FBQ1gsTUFBTSxJQUFJLEtBQUssQ0FBQyxtQkFBbUIsUUFBUSxZQUFZLENBQUMsQ0FBQztJQUMzRCxDQUFDO0lBQ0QsTUFBTSxDQUFDLElBQUksRUFBRSxFQUFFLENBQUMsR0FBRyxLQUFLLENBQUM7SUFDekIsT0FBTyxFQUFFLElBQUksRUFBRSxJQUEwQixFQUFFLEVBQUUsRUFBRSxDQUFDO0FBQ2xELENBQUMifQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2hhaW4uanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvY2hhaW4udHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IjtBQUFBLG1GQUFtRjs7O0FBZ0RuRiw4Q0FrQkM7QUFoRUQseUdBQXlHO0FBQ3pHLCtHQUErRztBQUMvRyxrR0FBa0c7QUFFbEc7Ozs7O0dBS0c7QUFDVSxRQUFBLGVBQWUsR0FBRztJQUM3QixXQUFXLEVBQUUsS0FBSztJQUNsQixPQUFPLEVBQUUsUUFBUTtJQUNqQixZQUFZLEVBQUUsS0FBSztJQUNuQixhQUFhLEVBQUUsSUFBSTtJQUNuQixpQkFBaUIsRUFBRSxJQUFJO0lBQ3ZCLEtBQUssRUFBRSxLQUFLO0NBQ0osQ0FBQztBQW1CWDs7Ozs7Ozs7O0dBU0c7QUFDSCxTQUFnQixpQkFBaUIsQ0FBQyxRQUFrQjtJQUNsRCxNQUFNLEtBQUssR0FDVCxPQUFPLFFBQVEsS0FBSyxRQUFRLElBQUksT0FBTyxRQUFRLEtBQUssUUFBUTtRQUMxRCxDQUFDLENBQUMsTUFBTSxDQUFDLE9BQU8sQ0FBQyx1QkFBZSxDQUFDLENBQUMsSUFBSSxDQUNsQyxDQUFDLENBQUMsRUFBRSxFQUFFLENBQUMsRUFBRSxFQUFFLENBQUMsRUFBRSxLQUFLLE1BQU0sQ0FBQyxRQUFRLENBQUMsQ0FDcEM7UUFDSCxDQUFDLENBQUMsT0FBTyxRQUFRLEtBQUssUUFBUTtZQUM1QixDQUFDLENBQUMsTUFBTSxDQUFDLE9BQU8sQ0FBQyx1QkFBZSxDQUFDLENBQUMsSUFBSSxDQUNsQyxDQUFDLENBQUMsRUFBRSxFQUFFLENBQUMsRUFBRSxFQUFFLENBQUMsRUFBRSxLQUFLLE1BQU0sQ0FBQyxRQUFRLENBQUMsRUFBRSxDQUFDLENBQ3ZDO1lBQ0gsQ0FBQyxDQUFDLE1BQU0sQ0FBQyxPQUFPLENBQUMsdUJBQWUsQ0FBQyxDQUFDLElBQUksQ0FDbEMsQ0FBQyxDQUFDLFNBQVMsQ0FBQyxFQUFFLEVBQUUsQ0FBQyxTQUFTLEtBQUssUUFBUSxDQUN4QyxDQUFDO0lBQ1YsSUFBSSxDQUFDLEtBQUssRUFBRSxDQUFDO1FBQ1gsTUFBTSxJQUFJLEtBQUssQ0FBQyxtQkFBbUIsUUFBUSxZQUFZLENBQUMsQ0FBQztJQUMzRCxDQUFDO0lBQ0QsTUFBTSxDQUFDLElBQUksRUFBRSxFQUFFLENBQUMsR0FBRyxLQUFLLENBQUM7SUFDekIsT0FBTyxFQUFFLElBQUksRUFBRSxJQUEwQixFQUFFLEVBQUUsRUFBRSxDQUFDO0FBQ2xELENBQUMifQ==

package/dist/cjs/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 {};