@inco/js 0.2.16 → 0.3.0

package/dist/types/generated/ts/inco/preflight/v1/tx.d.ts

@@ -0,0 +1,187 @@
+import { BinaryReader, BinaryWriter } from "@bufbuild/protobuf/wire";
+import { type CallOptions, type ChannelCredentials, Client, type ClientOptions, type ClientUnaryCall, type handleUnaryCall, type Metadata, type ServiceError, type UntypedServiceImplementation } from "@grpc/grpc-js";
+import { InputContext, Params } from "./types";
+export declare const protobufPackage = "inco.preflight.v1";
+/** MsgRegisterInput the Msg/RegisterInput request type. */
+export interface MsgRegisterInput {
+    /**
+     * signer is the bech32-encoded address of the signer of the Msg. It doesn't
+     * necessarily have to be the owner of the input. In practice, it will one of
+     * the following:
+     * - the owner of the input (if the end-user interacts with the Inco L1
+     * directly)
+     * - a Paymaster that facilitates the interaction between the end-user and
+     * the Inco L1, usually by paying for the gas fees. The Paymaster is
+     * expected to be run by one or more of the covalidators.
+     */
+    signer: string;
+    /** ciphertext is the input encrypted by the end-user. It contains the zkpok. */
+    ciphertext: Uint8Array;
+    /** context is the context with which the input is registered. */
+    context: InputContext | undefined;
+    /**
+     * The prehandle depends on the hash of the ciphertext, and three separate
+     * 1-byte cleartext metadata values in positions 29, 30, and 31 of the 32-byte
+     * handle respectively:
+     *   - the handle index (since ciphertexts are now a list-shaped container),
+     *   - the handle type
+     *   - the handle version (currently always 0)
+     * We could take these 3 bytes of metadata to produce the handle, but since
+     * the client need to compute the prehandle anyway we might as well just have
+     * them submit the finished value, we will still hash in the context
+     * preserving the fallback mechanism security guarantees.
+     */
+    prehandle: Uint8Array;
+}
+/** MsgRegisterInputResponse the Msg/RegisterInput response type. */
+export interface MsgRegisterInputResponse {
+    /** handle refers to a unique identifier for the ciphertext. */
+    handle: Uint8Array;
+}
+/** MsgRegisterFallback the Msg/RegisterFallback request type. */
+export interface MsgRegisterFallback {
+    /** handle refers to a unique identifier for the ciphertext. */
+    handle: Uint8Array;
+    /**
+     * covalidator is the covalidator's bech32-encoded address. This address is
+     * checked against the list of covalidators, which lives in the x/fhe
+     * params.
+     */
+    covalidator: string;
+}
+/** MsgRegisterFallbackResponse the Msg/RegisterFallback response type. */
+export interface MsgRegisterFallbackResponse {
+}
+/** MsgUpdateParams the Msg/UpdateParams request type. */
+export interface MsgUpdateParams {
+    /**
+     * params is the new parameters for the x/preflight module.
+     *
+     * Note: all fields must be set.
+     */
+    params: Params | undefined;
+    /**
+     * authority is the bech32-encoded address of the authority of the Msg. It
+     * defaults to the governance module.
+     */
+    authority: string;
+}
+/** MsgUpdateParamsResponse the Msg/UpdateParams response type. */
+export interface MsgUpdateParamsResponse {
+}
+export declare const MsgRegisterInput: MessageFns<MsgRegisterInput>;
+export declare const MsgRegisterInputResponse: MessageFns<MsgRegisterInputResponse>;
+export declare const MsgRegisterFallback: MessageFns<MsgRegisterFallback>;
+export declare const MsgRegisterFallbackResponse: MessageFns<MsgRegisterFallbackResponse>;
+export declare const MsgUpdateParams: MessageFns<MsgUpdateParams>;
+export declare const MsgUpdateParamsResponse: MessageFns<MsgUpdateParamsResponse>;
+/** Msg is the message service for the x/preflight module. */
+export type MsgService = typeof MsgService;
+export declare const MsgService: {
+    /**
+     * RegisterInput registers a handle to a ciphertext and associated context
+     * for the Preflight schemes.
+     */
+    readonly registerInput: {
+        readonly path: "/inco.preflight.v1.Msg/RegisterInput";
+        readonly requestStream: false;
+        readonly responseStream: false;
+        readonly requestSerialize: (value: MsgRegisterInput) => Buffer;
+        readonly requestDeserialize: (value: Buffer) => MsgRegisterInput;
+        readonly responseSerialize: (value: MsgRegisterInputResponse) => Buffer;
+        readonly responseDeserialize: (value: Buffer) => MsgRegisterInputResponse;
+    };
+    /**
+     * RegisterFallback registers a handle to a fallback value if it has not
+     * been registered. It can only be called by the covalidators.
+     */
+    readonly registerFallback: {
+        readonly path: "/inco.preflight.v1.Msg/RegisterFallback";
+        readonly requestStream: false;
+        readonly responseStream: false;
+        readonly requestSerialize: (value: MsgRegisterFallback) => Buffer;
+        readonly requestDeserialize: (value: Buffer) => MsgRegisterFallback;
+        readonly responseSerialize: (value: MsgRegisterFallbackResponse) => Buffer;
+        readonly responseDeserialize: (value: Buffer) => MsgRegisterFallbackResponse;
+    };
+    /**
+     * UpdateParams updates the parameters of the x/preflight module. It can only
+     * be called by the x/preflight's authority, which defaults to the governance
+     * module.
+     */
+    readonly updateParams: {
+        readonly path: "/inco.preflight.v1.Msg/UpdateParams";
+        readonly requestStream: false;
+        readonly responseStream: false;
+        readonly requestSerialize: (value: MsgUpdateParams) => Buffer;
+        readonly requestDeserialize: (value: Buffer) => MsgUpdateParams;
+        readonly responseSerialize: (value: MsgUpdateParamsResponse) => Buffer;
+        readonly responseDeserialize: (value: Buffer) => MsgUpdateParamsResponse;
+    };
+};
+export interface MsgServer extends UntypedServiceImplementation {
+    /**
+     * RegisterInput registers a handle to a ciphertext and associated context
+     * for the Preflight schemes.
+     */
+    registerInput: handleUnaryCall<MsgRegisterInput, MsgRegisterInputResponse>;
+    /**
+     * RegisterFallback registers a handle to a fallback value if it has not
+     * been registered. It can only be called by the covalidators.
+     */
+    registerFallback: handleUnaryCall<MsgRegisterFallback, MsgRegisterFallbackResponse>;
+    /**
+     * UpdateParams updates the parameters of the x/preflight module. It can only
+     * be called by the x/preflight's authority, which defaults to the governance
+     * module.
+     */
+    updateParams: handleUnaryCall<MsgUpdateParams, MsgUpdateParamsResponse>;
+}
+export interface MsgClient extends Client {
+    /**
+     * RegisterInput registers a handle to a ciphertext and associated context
+     * for the Preflight schemes.
+     */
+    registerInput(request: MsgRegisterInput, callback: (error: ServiceError | null, response: MsgRegisterInputResponse) => void): ClientUnaryCall;
+    registerInput(request: MsgRegisterInput, metadata: Metadata, callback: (error: ServiceError | null, response: MsgRegisterInputResponse) => void): ClientUnaryCall;
+    registerInput(request: MsgRegisterInput, metadata: Metadata, options: Partial<CallOptions>, callback: (error: ServiceError | null, response: MsgRegisterInputResponse) => void): ClientUnaryCall;
+    /**
+     * RegisterFallback registers a handle to a fallback value if it has not
+     * been registered. It can only be called by the covalidators.
+     */
+    registerFallback(request: MsgRegisterFallback, callback: (error: ServiceError | null, response: MsgRegisterFallbackResponse) => void): ClientUnaryCall;
+    registerFallback(request: MsgRegisterFallback, metadata: Metadata, callback: (error: ServiceError | null, response: MsgRegisterFallbackResponse) => void): ClientUnaryCall;
+    registerFallback(request: MsgRegisterFallback, metadata: Metadata, options: Partial<CallOptions>, callback: (error: ServiceError | null, response: MsgRegisterFallbackResponse) => void): ClientUnaryCall;
+    /**
+     * UpdateParams updates the parameters of the x/preflight module. It can only
+     * be called by the x/preflight's authority, which defaults to the governance
+     * module.
+     */
+    updateParams(request: MsgUpdateParams, callback: (error: ServiceError | null, response: MsgUpdateParamsResponse) => void): ClientUnaryCall;
+    updateParams(request: MsgUpdateParams, metadata: Metadata, callback: (error: ServiceError | null, response: MsgUpdateParamsResponse) => void): ClientUnaryCall;
+    updateParams(request: MsgUpdateParams, metadata: Metadata, options: Partial<CallOptions>, callback: (error: ServiceError | null, response: MsgUpdateParamsResponse) => void): ClientUnaryCall;
+}
+export declare const MsgClient: {
+    new (address: string, credentials: ChannelCredentials, options?: Partial<ClientOptions>): MsgClient;
+    service: typeof MsgService;
+    serviceName: string;
+};
+type Builtin = Date | Function | Uint8Array | string | number | boolean | undefined;
+export type DeepPartial<T> = T extends Builtin ? T : T extends globalThis.Array<infer U> ? globalThis.Array<DeepPartial<U>> : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial<U>> : T extends {} ? {
+    [K in keyof T]?: DeepPartial<T[K]>;
+} : Partial<T>;
+type KeysOfUnion<T> = T extends T ? keyof T : never;
+export type Exact<P, I extends P> = P extends Builtin ? P : P & {
+    [K in keyof P]: Exact<P[K], I[K]>;
+} & {
+    [K in Exclude<keyof I, KeysOfUnion<P>>]: never;
+};
+export interface MessageFns<T> {
+    encode(message: T, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): T;
+    fromJSON(object: any): T;
+    toJSON(message: T): unknown;
+    create<I extends Exact<DeepPartial<T>, I>>(base?: I): T;
+    fromPartial<I extends Exact<DeepPartial<T>, I>>(object: I): T;
+}
+export {};

package/dist/types/generated/ts/inco/preflight/v1/types.d.ts

@@ -0,0 +1,84 @@
+import { BinaryReader, BinaryWriter } from "@bufbuild/protobuf/wire";
+export declare const protobufPackage = "inco.preflight.v1";
+/**
+ * InputRegistration is the message that is stored on-chain in the inputs
+ * registry.
+ */
+export interface InputRegistration {
+    /**
+     * inputted_at is the Inco L1 block height at which the input was registered.
+     * It is used for pruning purposes.
+     */
+    inputtedAt: number;
+    ciphertextRegistration?: CiphertextRegistration | undefined;
+    fallbackRegistration?: FallbackRegistration | undefined;
+}
+/**
+ * CiphertextRegistration is the registration of an input encrypted by the
+ * end-user.
+ */
+export interface CiphertextRegistration {
+    /** ciphertext is the input encrypted by the end-user. */
+    ciphertext: Uint8Array;
+    /** context is the context in which the input was registered. */
+    context: InputContext | undefined;
+}
+/** InputContext is the context in which the input was registered. */
+export interface InputContext {
+    /**
+     * host_chain_id is the chain ID of the host chain. Refer to the x/hostchain
+     * module for a specification of the chain ID.
+     */
+    hostChainId: string;
+    /**
+     * keyset_id is the keyset that the input was encrypted under. Refer
+     * to the x/fhe module for a specification of the keysets.
+     */
+    keysetId: string;
+    /**
+     * contract_addr is the address of the contract that the input is intended
+     * for. This is a hex-encoded, non-prefixed Ethereum address (20 bytes).
+     */
+    contractAddr: string;
+    /**
+     * owner_addr is the address of the owner of the input. This is a hex-encoded,
+     * non-prefixed Ethereum address (20 bytes).
+     */
+    ownerAddr: string;
+}
+/** FallbackRegistration is the registration of an input by a covalidator. */
+export interface FallbackRegistration {
+}
+/** Params defines the parameters for the x/preflight module. */
+export interface Params {
+    /**
+     * blocks_to_keep_inputs is the number of blocks to keep inputs registrations
+     * in state. After this number of blocks, the input registration will be
+     * pruned from state, but still accessible via an archive node.
+     */
+    blocksToKeepInputs: number;
+}
+export declare const InputRegistration: MessageFns<InputRegistration>;
+export declare const CiphertextRegistration: MessageFns<CiphertextRegistration>;
+export declare const InputContext: MessageFns<InputContext>;
+export declare const FallbackRegistration: MessageFns<FallbackRegistration>;
+export declare const Params: MessageFns<Params>;
+type Builtin = Date | Function | Uint8Array | string | number | boolean | undefined;
+export type DeepPartial<T> = T extends Builtin ? T : T extends globalThis.Array<infer U> ? globalThis.Array<DeepPartial<U>> : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial<U>> : T extends {} ? {
+    [K in keyof T]?: DeepPartial<T[K]>;
+} : Partial<T>;
+type KeysOfUnion<T> = T extends T ? keyof T : never;
+export type Exact<P, I extends P> = P extends Builtin ? P : P & {
+    [K in keyof P]: Exact<P[K], I[K]>;
+} & {
+    [K in Exclude<keyof I, KeysOfUnion<P>>]: never;
+};
+export interface MessageFns<T> {
+    encode(message: T, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): T;
+    fromJSON(object: any): T;
+    toJSON(message: T): unknown;
+    create<I extends Exact<DeepPartial<T>, I>>(base?: I): T;
+    fromPartial<I extends Exact<DeepPartial<T>, I>>(object: I): T;
+}
+export {};

package/dist/types/handle.d.ts

@@ -0,0 +1,41 @@
+import { Schema } from 'effect';
+import { HexString } from './binary.js';
+export declare const HANDLE_VERSION = 0;
+export declare const handleTypes: Readonly<{
+    ebool: 0;
+    euint4: 1;
+    euint8: 2;
+    euint16: 3;
+    euint32: 4;
+    euint64: 5;
+    euint128: 6;
+    euint160: 7;
+    euint256: 8;
+    ebytes64: 9;
+    ebytes128: 10;
+    ebytes256: 11;
+}>;
+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>;
+export type HandleTypeName = typeof HandleTypeName.Type;
+export type HandleTypes = typeof handleTypes;
+export type FheType = HandleTypes[keyof HandleTypes];
+export declare function isFheType(value: number): value is FheType;
+export declare const InputContext: Schema.Struct<{
+    hostChainId: typeof Schema.BigInt;
+    aclAddress: Schema.TemplateLiteral<`0x${string}`>;
+    userAddress: Schema.TemplateLiteral<`0x${string}`>;
+    contractAddress: Schema.TemplateLiteral<`0x${string}`>;
+}>;
+export type InputContext = typeof InputContext.Type;
+export type Handle = HexString;
+export declare function getHandleType(handle: HexString): FheType;
+export declare function computePrehandle({ ciphertext, indexHandle, handleType, handleVersion, }: {
+    ciphertext: Uint8Array;
+    indexHandle: number;
+    handleType: FheType;
+    handleVersion: number;
+}): Buffer;
+export declare function computeHandle({ prehandle, context }: {
+    prehandle: Uint8Array;
+    context: InputContext;
+}): Buffer;

package/dist/types/index.d.ts

@@ -0,0 +1,5 @@
+export * from './binary.js';
+export * from './chain.js';
+export * from './handle.js';
+export * from './schema.js';
+export * from './viem.js';

package/dist/types/kms/client.d.ts

@@ -0,0 +1,8 @@
+import { Client } from '@connectrpc/connect';
+import { SupportedChain } from '../chain.js';
+import { KmsService } from '../generated/es/inco/kms/lite/v1/kms_service_pb.js';
+export type KmsClient = Client<typeof KmsService>;
+export declare function getKmsClient(kmsConnectRpcEndpointOrClient: string | KmsClient): KmsClient;
+export declare function defaultCovalidatorGrpc(chain: SupportedChain): string;
+export declare function lightningDevnetCovalidatorGrpc(chain: SupportedChain): string;
+export declare function lightningTestnetCovalidatorGrpc(chain: SupportedChain): string;

package/dist/types/l1/client.d.ts

@@ -0,0 +1,35 @@
+import { Client } from '@connectrpc/connect';
+import { DirectSecp256k1HdWallet, type OfflineSigner } from '@cosmjs/proto-signing';
+import { DeliverTxResponse } from '@cosmjs/stargate';
+import * as fhe from '../generated/es/inco/fhe/v1/query_pb.js';
+import * as preflight from '../generated/es/inco/preflight/v1/query_pb.js';
+import { MsgAddCovalidator, MsgAddFheEnv } from '../generated/ts/inco/fhe/v1/tx.js';
+import { MessageFns, MsgRegisterInput } from '../generated/ts/inco/preflight/v1/tx.js';
+export interface L1ClientArgs {
+    cometRpcEndpoint: string;
+    grpcEndpoint: string;
+    wallet: OfflineSigner;
+    waitTimeForTxInclusion?: number;
+}
+declare const supportedMsgs: {
+    "/inco.preflight.v1.MsgRegisterInput": MessageFns<MsgRegisterInput>;
+    "/inco.fhe.v1.MsgAddCovalidator": import("../generated/ts/inco/fhe/v1/tx.js").MessageFns<MsgAddCovalidator>;
+    "/inco.fhe.v1.MsgAddFheEnv": import("../generated/ts/inco/fhe/v1/tx.js").MessageFns<MsgAddFheEnv>;
+};
+type GetInner<T> = T extends MessageFns<infer U> ? U : never;
+export type SupportedMsgTypes = keyof typeof supportedMsgs;
+export type SupportedMsg<T extends SupportedMsgTypes> = GetInner<(typeof supportedMsgs)[T]>;
+declare const supportedQueries: {
+    fhe: typeof fhe;
+    preflight: typeof preflight;
+};
+export type L1ClientQuery = {
+    [K in keyof typeof supportedQueries]: Client<(typeof supportedQueries)[K]['Query']>;
+};
+export interface L1Client {
+    get q(): L1ClientQuery;
+    sendTx<T extends SupportedMsgTypes>(signerAddress: string, msgType: T, msgBody: SupportedMsg<T>): Promise<DeliverTxResponse>;
+}
+export declare function createL1Wallet(mnemonic: string): Promise<DirectSecp256k1HdWallet>;
+export declare function createL1Client({ cometRpcEndpoint, grpcEndpoint, wallet, waitTimeForTxInclusion, }: L1ClientArgs): Promise<L1Client>;
+export {};

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

@@ -0,0 +1,2 @@
+export * from './client.js';
+export * from './preflight.js';

package/dist/types/l1/preflight.d.ts

@@ -0,0 +1,20 @@
+import { Schema } from 'effect';
+import { Bytes32 } from '../binary.js';
+import { CiphertextWithContext } from '../encryption/encryption.js';
+import { type L1ClientArgs } from './client.js';
+declare const Handle: Schema.brand<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">;
+export type Handle = typeof Handle.Type;
+export type PreflightRequest = CiphertextWithContext & {
+    prehandle: Bytes32;
+};
+export type PreflightResult = {
+    transactionHash: string;
+    handle: Handle;
+};
+export interface PreflightSender {
+    send(encResult: PreflightRequest): Promise<PreflightResult>;
+}
+export declare function cosmJSPreflight({ cometRpcEndpoint, grpcEndpoint, wallet, signerAddress, }: L1ClientArgs & {
+    signerAddress: string;
+}): Promise<PreflightSender>;
+export {};

package/dist/types/lite/attested-compute.d.ts

@@ -0,0 +1,4 @@
+import { type IncoLiteAttestedComputeArgs, incoLiteAttestedCompute } from '../attestedcompute/attested-compute.js';
+import { type AttestedComputeSupportedOps } from '../attestedcompute/types.js';
+export { incoLiteAttestedCompute };
+export type { AttestedComputeSupportedOps, IncoLiteAttestedComputeArgs };

package/dist/types/lite/attested-decrypt.d.ts

@@ -0,0 +1,3 @@
+import { type IncoLiteAttestedDecryptorArgs, incoLiteAttestedDecryptor } from '../attesteddecrypt/attested-decrypt.js';
+export { incoLiteAttestedDecryptor };
+export type { IncoLiteAttestedDecryptorArgs };

package/dist/types/lite/deployments.d.ts

@@ -0,0 +1,6 @@
+import { Chainish } from '../chain.js';
+import { lightningDeployments } from '../generated/lightning.js';
+export type Address = `0x${string}`;
+export type IncoLiteDeployment = (typeof lightningDeployments)[number];
+export declare function getActiveLightningDeployment(chain: Chainish): IncoLiteDeployment;
+export declare function getLightningDeployments(chainId: Chainish): readonly IncoLiteDeployment[];

package/dist/types/lite/ecies.d.ts

@@ -0,0 +1,26 @@
+import * as ellipticPkg from 'elliptic';
+import { Decryptor, EciesScheme, Encryptor } from '../encryption/encryption.js';
+import { PubKeyEncodable } from '../reencryption/index.js';
+export interface Secp256k1Keypair extends PubKeyEncodable {
+    scheme: EciesScheme;
+    kp: ellipticPkg.ec.KeyPair;
+}
+export type Secp256k1PubKey = ellipticPkg.curve.base.BasePoint;
+export declare function toSecp256k1Keypair(kp: ellipticPkg.ec.KeyPair): Secp256k1Keypair;
+export declare function generateSecp256k1Keypair(): Secp256k1Keypair;
+export declare function encodeSecp256k1PublicKey(pub: Secp256k1PubKey): Uint8Array;
+export declare function decodeSecp256k1PublicKey(pubKeyCompressed: Uint8Array): Secp256k1PubKey;
+export declare function decodeSecp256k1PrivateKey(privKey: Uint8Array): Secp256k1Keypair;
+export declare function encrypt(pubKeyA: Secp256k1PubKey, plaintext: Uint8Array, privKeyB: Secp256k1Keypair): Promise<Uint8Array>;
+export type EciesEncryptorArgs = {
+    scheme: EciesScheme;
+    pubKeyA: Secp256k1PubKey;
+    privKeyB: Secp256k1Keypair;
+};
+export declare function getEciesEncryptor({ pubKeyA, privKeyB }: EciesEncryptorArgs): Encryptor<EciesScheme>;
+export declare function decrypt(privKeyA: Secp256k1Keypair, ciphertext: Uint8Array): Promise<Uint8Array>;
+export type EciesDecryptorArgs = {
+    scheme: EciesScheme;
+    privKeyA: Secp256k1Keypair;
+};
+export declare function getEciesDecryptor({ privKeyA }: EciesDecryptorArgs): Decryptor<EciesScheme>;

package/dist/types/lite/hadu.d.ts

@@ -0,0 +1,24 @@
+import { Schema } from 'effect';
+import { PlaintextWithContext } from '../encryption/index.js';
+export declare const encryptionEnvelopes: {
+    readonly none: 0;
+    readonly hadu: 1;
+};
+export type NoneEnvelope = (typeof encryptionEnvelopes)['none'];
+export type HaduEnvelope = (typeof encryptionEnvelopes)['hadu'];
+export declare const EncryptionEnvelope: Schema.SchemaClass<0 | 1, 0 | 1, never>;
+export declare const HaduInput: Schema.transform<Schema.SchemaClass<unknown, string, never>, Schema.Struct<{
+    envelope: Schema.Literal<[1]>;
+    scheme: Schema.Literal<[0, 1, 2]>;
+    context: Schema.Struct<{
+        hostChainId: typeof Schema.BigInt;
+        aclAddress: Schema.TemplateLiteral<`0x${string}`>;
+        userAddress: Schema.TemplateLiteral<`0x${string}`>;
+        contractAddress: Schema.TemplateLiteral<`0x${string}`>;
+    }>;
+    plaintext: 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">;
+    type: Schema.SchemaClass<0 | 5 | 7 | 8, 0 | 5 | 7 | 8, never>;
+}>>;
+export type HaduInput = typeof HaduInput.Type;
+export declare function encodeInput({ plaintext, context }: PlaintextWithContext): string;
+export declare function decodeInput(json: string): PlaintextWithContext;

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

@@ -0,0 +1,7 @@
+export * from '../generated/abis/lightning.js';
+export type { KmsService, ReencryptRequest } from '../generated/es/inco/kms/lite/v1/kms_service_pb.js';
+export * from './deployments.js';
+export * from './ecies.js';
+export * from './hadu.js';
+export * from './lightning.js';
+export * from './reencrypt.js';

package/dist/types/lite/lightning.d.ts

@@ -0,0 +1,132 @@
+import { Account, Chain, Transport, WalletClient } from 'viem';
+import { Address, HexString } from '../binary.js';
+import { EciesScheme } from '../encryption/index.js';
+import { lightningDeployments } from '../generated/lightning.js';
+import { localNodeLightningConfig } from '../generated/local-node.js';
+import { LocalNodeEnv } from '../local/index.js';
+import type { Reencryptor } from '../reencryption/index.js';
+type TupleToUnion<T> = T extends readonly unknown[] ? T[number] : never;
+type Deployment = TupleToUnion<typeof lightningDeployments>;
+type DistributedPick<T, K> = T extends any ? Pick<T, Extract<keyof T, K>> : never;
+export type DeploymentByName = DistributedPick<Deployment, 'name' | 'chainId'>;
+export type DeploymentByExecutor = DistributedPick<Deployment, 'executorAddress' | 'chainId'>;
+export type DeploymentId = DeploymentByName | DeploymentByExecutor;
+export type Pepper = Deployment['pepper'];
+export type LocalNodePepper = keyof typeof localNodeLightningConfig;
+export type ChainId = Deployment['chainId'];
+export type SupportedNativeType = boolean | bigint | number;
+export type EncryptionContext = {
+    accountAddress: string;
+    dappAddress: string;
+};
+export type DeploymentSlice = {
+    executorAddress: string;
+    eciesPublicKey: string;
+    chainId: number;
+};
+export type CustomConfig = {
+    executorAddress: string;
+    eciesPublicKey: string;
+    chainId: number;
+    covalidatorUrl: string;
+    hostChainRpcUrl?: string;
+    senderPrivateKey?: HexString;
+};
+export type CustomDeployment = DeploymentSlice & CustomConfig;
+/**
+ * The Lightning class provides a convenient way to interact with the Inco Lightning contract by binding to a specific
+ * deployment.
+ */
+export declare class Lightning<T extends DeploymentSlice = DeploymentSlice> {
+    private readonly _deployment;
+    readonly covalidatorUrl: string;
+    readonly executorAddress: Address;
+    readonly eciesPublicKey: HexString;
+    readonly chainId: bigint;
+    private readonly encryptor;
+    private readonly ephemeralKeypair;
+    private readonly kmsClient;
+    private constructor();
+    /**
+     * Get a Lightning instance bound to the latest Lightning deployment for the Base Sepolia testnet.
+     */
+    static baseSepoliaTestnet(): Lightning<Deployment>;
+    /**
+     * Get a Lightning instance bound to our canonical Anvil-based test node and test Covalidator node
+     *
+     * These can be run in docker-compose using images pushed to dockerhub as:
+     *   - inconetwork/local-node-anvil
+     *   - inconetwork/local-node-covalidator
+     *
+     * See the sample docker-compose file here: https://github.com/Inco-fhevm/lightning-rod/blob/main/docker-compose.yaml
+     *
+     * @param env either a Pepper such as 'testnet', 'devnet', 'alphanet' or a LocalNodeEnv object containing the
+     * executorAddress, eciesPublicKey, chainId, covalidatorUrl and senderPrivateKey. If none is provided, it defaults to
+     * the 'testnet' Pepper. This produces allows connection to a local node running against a state dump of the
+     * corresponding Pepper.
+     *
+     */
+    static localNode(env?: LocalNodeEnv | LocalNodePepper): Lightning<CustomDeployment>;
+    /**
+     * Get a Lightning instance bound to a local node from a file containing a LocalNodeEnv environment .
+     *
+     * @param filePath the path to the file containing the environment variables in dotenv format
+     */
+    static localNodeFromEnv(filePath?: string): Promise<Lightning<CustomDeployment>>;
+    /**
+     * Get a Lightning deployment by name or executor address on a particular chain.
+     *
+     * @param id this is an object containing either the pair of name and chainId or the executorAddress and chainId
+     */
+    static at(id: DeploymentId): Lightning<Deployment>;
+    /**
+     * Get a Lightning deployment for a local or custom node
+     *
+     * @param config this is an object containing the executorAddress, eciesPublicKey, chainId and covalidatorUrl.
+     *    additional fields past will be made available as part of the `deployment` property.
+     */
+    static custom<T extends CustomConfig>(config: T): Lightning<DeploymentSlice & T>;
+    /**
+     * Get the latest deployment for a given pepper, which usually denotes a family of deployments distinct from their
+     * version such as 'devnet', 'testnet', 'mainnet', etc.
+     *
+     * @param pepper the pepper to use to filter the deployments
+     * @param chainId the chainId to use to filter the deployments
+     */
+    static latestDeployment<P extends Pepper>(pepper: P, chainId: ChainId): Deployment;
+    /**
+     * Get the latest Lightning deployment for a given pepper amd chainId unconditionally.
+     * Note that if you upgrade the library the latest deployment may change and contracts deployed to a previous version
+     * will not be compatible with the new version.
+     *
+     * @param pepper the pepper to use to filter the deployments
+     * @param chainId the chainId to use to filter the deployments
+     */
+    static latest<P extends Pepper>(pepper: P, chainId: ChainId): Lightning<Deployment>;
+    get deployment(): T;
+    /**
+     * Encrypt a value using the public ECIES key of the Lightning deployment.
+     *
+     * @param value a boolean or numeric value to encrypt
+     * @param accountAddress the address of the account interacting with the dapp contract, normally an Externally Owned Account (EOA)
+     * @param dappAddress the address of the dapp contract that interacts with the Inco Lightning contract or library
+     */
+    encrypt<T extends SupportedNativeType>(value: T, { accountAddress, dappAddress }: EncryptionContext): Promise<HexString>;
+    /**
+     * Obtain a reencryptor for a particular Externally Owned Account (EOA) to request decrypted values.
+     * The account associated with the walletClient must have permissions to decrypt the handle or ciphertext passed
+     * to the reencryptor function.
+     *
+     * @param walletClient the wallet client to use for signing the reencrypt request.
+     */
+    getReencryptor(walletClient: WalletClient<Transport, Chain, Account>): Promise<Reencryptor<EciesScheme>>;
+    /**
+     * Get the GRPC endpoint for the covalidator that services this deployment.
+     */
+    static getCovalidatorUrl(deployment: DeploymentSlice & {
+        pepper: string;
+    }): string;
+    private static isIdByName;
+    private static plaintextFromValue;
+}
+export {};

package/dist/types/lite/reencrypt.d.ts

@@ -0,0 +1,24 @@
+import { Client } from '@connectrpc/connect';
+import { Account, Chain, Hex, Transport, WalletClient } from 'viem';
+import { SupportedChain } from '../chain.js';
+import { EciesScheme, PlaintextOf, SupportedFheType } from '../encryption/encryption.js';
+import { KmsService, ReencryptResponse } from '../generated/es/inco/kms/lite/v1/kms_service_pb.js';
+import { Handle } from '../handle.js';
+import type { EIP712 } from '../reencryption/eip712.js';
+import type { Reencryptor, ReencryptorArgs } from '../reencryption/types.js';
+import { Secp256k1Keypair } from './ecies.js';
+export interface IncoLiteReencryptorArgs extends ReencryptorArgs {
+    walletClient: WalletClient<Transport, Chain, Account>;
+    kmsConnectRpcEndpointOrClient?: string | Client<typeof KmsService>;
+    ephemeralKeypair?: Secp256k1Keypair;
+}
+export declare function reencryptEIP712(chainId: bigint, ephemeralPubKey: Uint8Array): EIP712<{
+    publicKey: Hex;
+}>;
+export declare function incoLiteReencryptor({ kmsConnectRpcEndpointOrClient, chainId, walletClient, ephemeralKeypair, }: IncoLiteReencryptorArgs): Promise<Reencryptor<EciesScheme>>;
+export declare function getKmsClient(kmsConnectRpcEndpointOrClient: string | Client<typeof KmsService>): Client<typeof KmsService>;
+export declare function decryptGrpcResponse<T extends SupportedFheType>(response: ReencryptResponse, ephemeralKeypair: Secp256k1Keypair, handle: Handle): Promise<PlaintextOf<1, T>>;
+export declare function defaultCovalidatorGrpc(chain: SupportedChain): string;
+export declare function pulumiCovalidatorGrpc(chain: SupportedChain): string;
+export declare function lightningDevnetCovalidatorGrpc(chain: SupportedChain): string;
+export declare function lightningTestnetCovalidatorGrpc(chain: SupportedChain): string;

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

@@ -0,0 +1 @@
+export * from './local-node.js';