@inco/js 0.9.0-devnet-test-10 → 0.10.0-devnet-1

package/dist/types/binary.d.ts

@@ -1,22 +1,104 @@
 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.
+ * @throws If the bigint is negative or too large to fit in 32 bytes.
+ */
 export declare function bigintToBytes(value: bigint): Buffer;
+/**
+ * Converts a `bigint` to a {@link Bytes32} hex string, left-padded to 32 bytes.
+ * @param value - The bigint to convert.
+ * @returns A `Bytes32` hex string.
+ * @throws If the bigint is negative or too large to fit in 32 bytes.
+ */
 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/types/chain.d.ts

@@ -1,4 +1,12 @@
+/**
+ * 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 mainnet: 1;
+    readonly base: 8453;
     readonly baseSepolia: 84532;
     readonly sepolia: 11155111;
     readonly monadTestnet: 10143;
@@ -6,20 +14,37 @@ 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;
+/**
+ * Map of supported chain IDs to their short names.
+ * Public networks use the `shortName` from https://github.com/ethereum-lists/chains.
+ * Local Anvil uses `31337` (same ID as GoChain Testnet in the registry) but the SDK labels it `anvil`.
+ */
+export declare const chainShortNames: Record<SupportedChainId, 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/types/eip712/eip712.d.ts

@@ -0,0 +1,18 @@
+import type { Account, Chain, Transport, WalletClient } from 'viem';
+import type { HexString } from '../binary.js';
+import type { SupportedChainId } from '../chain.js';
+import { ViemClient } from '../viem.js';
+export declare function fetchEip712DomainVersion(executorAddress: HexString, ethClient: ViemClient): Promise<string>;
+export declare function buildEip712Payload(params: {
+    executorAddress: HexString;
+    ethClient: ViemClient;
+    chainId: SupportedChainId;
+    handles: HexString[];
+    reencryptPubKey: Uint8Array;
+}): Promise<import("../reencryption/eip712.js").EIP712<{
+    handles: `0x${string}`[];
+    publicKey: `0x${string}`;
+}>>;
+type WalletSignTypedDataParams = Parameters<WalletClient<Transport, Chain, Account>['signTypedData']>[0];
+export declare function signEip712(walletClient: WalletClient<Transport, Chain, Account>, eip712Payload: WalletSignTypedDataParams): Promise<`0x${string}`>;
+export {};

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

@@ -0,0 +1 @@
+export { buildEip712Payload, fetchEip712DomainVersion, signEip712, } from './eip712.js';

package/dist/types/elistattesteddecrypt/elist-attested-decrypt.d.ts

@@ -0,0 +1,49 @@
+import type { Account, Chain, Transport, WalletClient } from 'viem';
+import { validateHandle } from '../attesteddecrypt/attested-decrypt.js';
+import { type HexString } from '../binary.js';
+import { type SupportedChainId } from '../chain.js';
+import { type EncryptionScheme, type SupportedFheType } from '../encryption/encryption.js';
+import { KmsQuorumClient } from '../kms/quorumClient.js';
+import type { XwingKeypair } from '../lite/xwing.js';
+import type { BackoffConfig } from '../retry.js';
+import { type EListDecryptionAttestation, type EncryptedEListDecryptionAttestation } from './types.js';
+export { validateHandle };
+export declare function eListAttestedDecrypt({ handle, backoffConfig, walletClient, chainId, reencryptPubKey, reencryptKeypair, kmsQuorumClient, executorAddress, }: {
+    handle: HexString;
+    backoffConfig?: Partial<BackoffConfig> | undefined;
+    walletClient: WalletClient<Transport, Chain, Account>;
+    chainId: SupportedChainId;
+    reencryptPubKey: Uint8Array;
+    reencryptKeypair: XwingKeypair;
+    kmsQuorumClient: KmsQuorumClient;
+    executorAddress: HexString;
+}): Promise<EListDecryptionAttestation<EncryptionScheme, SupportedFheType>>;
+export declare function eListAttestedDecrypt({ handle, backoffConfig, walletClient, chainId, reencryptPubKey, kmsQuorumClient, executorAddress, }: {
+    handle: HexString;
+    backoffConfig?: Partial<BackoffConfig> | undefined;
+    walletClient: WalletClient<Transport, Chain, Account>;
+    chainId: SupportedChainId;
+    reencryptPubKey: Uint8Array;
+    reencryptKeypair?: never;
+    kmsQuorumClient: KmsQuorumClient;
+    executorAddress: HexString;
+}): Promise<EncryptedEListDecryptionAttestation<EncryptionScheme, SupportedFheType>>;
+export declare function eListAttestedDecrypt({ handle, backoffConfig, walletClient, chainId, kmsQuorumClient, executorAddress, }: {
+    handle: HexString;
+    backoffConfig?: Partial<BackoffConfig> | undefined;
+    walletClient: WalletClient<Transport, Chain, Account>;
+    chainId: SupportedChainId;
+    reencryptPubKey?: never;
+    reencryptKeypair?: never;
+    kmsQuorumClient: KmsQuorumClient;
+    executorAddress: HexString;
+}): Promise<EListDecryptionAttestation<EncryptionScheme, SupportedFheType>>;
+/**
+ * Reveal a single elist handle without wallet authentication.
+ * Returns plaintext values along with an attestation of the checksum.
+ */
+export declare function eListAttestedReveal({ handle, backoffConfig, kmsQuorumClient, }: {
+    handle: HexString;
+    backoffConfig?: Partial<BackoffConfig> | undefined;
+    kmsQuorumClient: KmsQuorumClient;
+}): Promise<EListDecryptionAttestation<EncryptionScheme, SupportedFheType>>;

package/dist/types/elistattesteddecrypt/index.d.ts

@@ -0,0 +1,2 @@
+export { eListAttestedDecrypt, eListAttestedReveal, } from './elist-attested-decrypt.js';
+export * from './types.js';

package/dist/types/elistattesteddecrypt/types.d.ts

@@ -0,0 +1,31 @@
+import type { HexString } from '../binary.js';
+import type { EncryptionScheme, EncryptResultOf, PlaintextOf, SupportedFheType } from '../encryption/encryption.js';
+import { handleTypes } from '../index.js';
+import type { BackoffConfig } from '../retry.js';
+/**
+ * Custom error class for elist attested decrypt operations.
+ */
+export declare class EListAttestedDecryptError extends Error {
+    readonly cause?: unknown | undefined;
+    constructor(message: string, cause?: unknown | undefined);
+}
+export type EListDecryptionAttestation<S extends EncryptionScheme, T extends SupportedFheType> = {
+    handle: HexString;
+    commitmentProof: PlaintextOf<S, typeof handleTypes.euint256>;
+    values: PlaintextOf<S, T>[];
+    covalidatorSignatures: Uint8Array[];
+    commitments: Uint8Array[];
+};
+export type EncryptedEListDecryptionAttestation<S extends EncryptionScheme, T extends SupportedFheType> = {
+    handle: HexString;
+    commitmentProof: PlaintextOf<S, typeof handleTypes.euint256>;
+    values: EncryptResultOf<S, T>[];
+    covalidatorSignatures: Uint8Array[];
+    commitments: Uint8Array[];
+};
+export type EListAttestedDecryptor<S extends EncryptionScheme> = <T extends SupportedFheType>(args: EListAttestedDecryptFnArgs<S, T>) => Promise<EListDecryptionAttestation<S, T>>;
+export type EListAttestedDecryptFnArgs<S extends EncryptionScheme, T extends SupportedFheType> = {
+    /** The handle to decrypt */
+    handle: HexString;
+    backoffConfig?: Partial<BackoffConfig>;
+};

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/encryption/index.d.ts

@@ -1 +1 @@
-export * from './encryption.js';
+export { Ciphertext, EncryptionScheme, Plaintext, SupportedFheType, SupportedFheTypeName, bigintToPlaintext, bytes32ToPlaintext, bytesToPlaintext, encryptionSchemes, getEncryptionSchemeName, plaintextToBigint, plaintextToBytes, plaintextToBytes32, supportedFheTypes, type EncryptionSchemes, } from './encryption.js';