@inco/js 0.2.16 → 0.2.17

package/dist/esm/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/esm/l1/client.js

@@ -0,0 +1,93 @@
+import { createClient } from '@connectrpc/connect';
+import { createGrpcTransport } from '@connectrpc/connect-node';
+import { DirectSecp256k1HdWallet, Registry } from '@cosmjs/proto-signing';
+import { defaultRegistryTypes as defaultStargateTypes, SigningStargateClient, } 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 { MsgRegisterInput } from '../generated/ts/inco/preflight/v1/tx.js';
+// We could have extracted these strings from types inside
+// ../generated/es/fhe/v1/tx_pb, but it seems more readable to hardcode
+// them here.
+const msgRegisterInputTypeUrl = '/inco.preflight.v1.MsgRegisterInput';
+const msgAddCovalidatorTypeUrl = '/inco.fhe.v1.MsgAddCovalidator';
+const msgAddFheEnvTypeUrl = '/inco.fhe.v1.MsgAddFheEnv';
+// The CosmJS L1 client needs a local registry to register custom types that
+// are not part of the default Cosmos types (`defaultStargateTypes`). We
+// hardcode them here.
+//
+// If we want to support more messages for strong TS typings, we need to add
+// them here.
+const supportedMsgs = {
+    [msgRegisterInputTypeUrl]: MsgRegisterInput,
+    [msgAddCovalidatorTypeUrl]: MsgAddCovalidator,
+    [msgAddFheEnvTypeUrl]: MsgAddFheEnv,
+};
+// The list of supported queries on the Inco L1.
+//
+// If we want to support more queries (e.g. Cosmos bank, staking queries), we
+// need to add them here.
+const supportedQueries = {
+    fhe,
+    preflight,
+};
+export async function createL1Wallet(mnemonic) {
+    return await DirectSecp256k1HdWallet.fromMnemonic(mnemonic, { prefix: 'inco' });
+}
+// Creates a Cosmos L1 client using CosmJS.
+export async function createL1Client({ cometRpcEndpoint, grpcEndpoint, wallet, waitTimeForTxInclusion = 10_000, }) {
+    // Manual registry creation is required to register custom Msg types.
+    const registry = new Registry(defaultStargateTypes);
+    Object.entries(supportedMsgs).forEach(([typeUrl, message]) => {
+        // @ts-ignore TODO: Fix this typing issue. This was introcued in:
+        // https://github.com/Inco-fhevm/inco-monorepo/pull/251
+        registry.register(typeUrl, message);
+    });
+    // Create one shared gRPC transport for all queries.
+    const transport = createGrpcTransport({ baseUrl: grpcEndpoint });
+    const query = Object.fromEntries(Object.entries(supportedQueries).map(([k, v]) => [k, createClient(v.Query, transport)]));
+    const signingClient = await SigningStargateClient.connectWithSigner(cometRpcEndpoint, wallet, {
+        registry,
+    });
+    // We currently assume that the Inco chain has 0 fees and hardcode the default gas limit.
+    const defaultFee = {
+        amount: [{ denom: 'uinco', amount: '0' }],
+        gas: '1000000',
+    };
+    return {
+        get q() {
+            return query;
+        },
+        async sendTx(signerAddress, msgType, msg, fee = defaultFee) {
+            const msgAny = {
+                typeUrl: msgType,
+                value: msg,
+            };
+            const result = await signingClient.signAndBroadcast(signerAddress, [msgAny], fee);
+            if (result.code) {
+                throw new Error(`Error broadcasting tx: ${result.rawLog}`);
+            }
+            // Poll until the transaction is included in a block, with a maximum wait time given by config.
+            const startTime = Date.now();
+            await new Promise((resolve, reject) => {
+                const interval = setInterval(async () => {
+                    const tx = await signingClient.getTx(result.transactionHash);
+                    if (tx?.code) {
+                        clearInterval(interval);
+                        reject(new Error(`Transaction failed: ${JSON.stringify(tx)}`));
+                    }
+                    else if (tx?.height) {
+                        clearInterval(interval);
+                        resolve();
+                    }
+                    else if (Date.now() - startTime > waitTimeForTxInclusion) {
+                        clearInterval(interval);
+                        reject(new Error('Transaction polling timed out'));
+                    }
+                }, 1000);
+            });
+            return result;
+        },
+    };
+}
+//# sourceMappingURL=data:application/json;base64,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

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

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

package/dist/esm/l1/index.js

@@ -0,0 +1,3 @@
+export * from './client.js';
+export * from './preflight.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvbDEvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxhQUFhLENBQUM7QUFDNUIsY0FBYyxnQkFBZ0IsQ0FBQyJ9

package/dist/esm/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/esm/l1/preflight.js

@@ -0,0 +1,39 @@
+import { Schema } from 'effect';
+import { Bytes32, bytesFromHexString } from '../binary.js';
+import { MsgRegisterInput } from '../generated/ts/inco/preflight/v1/tx.js';
+import { computeHandle } from '../handle.js';
+import { parse } from '../schema.js';
+import { createL1Client } from './client.js';
+// Do not export this value, only allow parsing of Handle to happen here
+const Handle = Bytes32.pipe(Schema.brand('Handle'));
+// Sends a preflight input to the Cosmos L1 chain using CosmJS.
+export async function cosmJSPreflight({ cometRpcEndpoint, grpcEndpoint, wallet, signerAddress, }) {
+    const l1Client = await createL1Client({ cometRpcEndpoint, wallet, grpcEndpoint });
+    return {
+        async send({ prehandle, ciphertext, context }) {
+            const msg = MsgRegisterInput.create({
+                prehandle: Buffer.from(prehandle.replace(/^0x/, ''), 'hex'),
+                signer: signerAddress,
+                ciphertext: Buffer.from(ciphertext.value, 'hex'),
+                context: {
+                    ownerAddr: context.userAddress.replace(/^0x/, ''),
+                    contractAddr: context.contractAddress.replace(/^0x/, ''),
+                    // We decided to put the ACL address in the keyset ID field.
+                    keysetId: context.aclAddress.replace(/^0x/, ''),
+                    hostChainId: 'evm/' + context.hostChainId,
+                },
+            });
+            // There are some hidden dependencies needed to make the following line work:
+            //
+            // 1. The signer must have an account on the chain. In Cosmos, this is
+            // usually done by sending some tokens to the account. However, since the
+            // fees are 0, this account doesn't need to have any tokens.
+            // 2. The FheEnv must have been created in the on-chain registry. Only the
+            // council can add new FheEnvs to the registry.
+            const result = await l1Client.sendTx(signerAddress, '/inco.preflight.v1.MsgRegisterInput', msg);
+            const handle = computeHandle({ prehandle: bytesFromHexString(prehandle), context });
+            return { transactionHash: result.transactionHash, handle: parse(Handle, handle) };
+        },
+    };
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/esm/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/esm/lite/attested-decrypt.js

@@ -0,0 +1,3 @@
+import { incoLiteAttestedDecryptor } from '../attesteddecrypt/attested-decrypt.js';
+export { incoLiteAttestedDecryptor };
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXR0ZXN0ZWQtZGVjcnlwdC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9saXRlL2F0dGVzdGVkLWRlY3J5cHQudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFzQyx5QkFBeUIsRUFBRSxNQUFNLHdDQUF3QyxDQUFDO0FBRXZILE9BQU8sRUFBRSx5QkFBeUIsRUFBRSxDQUFDIn0=

package/dist/esm/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/esm/lite/deployments.js

@@ -0,0 +1,17 @@
+// Avoid inporting any other dependencies in this file to avoid serialisation issues downstream in infracto
+import { getSupportedChain } from '../chain.js';
+import { lightningDeployments } from '../generated/lightning.js';
+export function getActiveLightningDeployment(chain) {
+    const supportedChain = getSupportedChain(chain);
+    const deployments = lightningDeployments.filter((d) => d.chainId === supportedChain.id);
+    if (!deployments?.length) {
+        throw new Error(`No deployments found for chain ${chain}`);
+    }
+    return deployments[0];
+}
+export function getLightningDeployments(chainId) {
+    const supportedChain = getSupportedChain(chainId);
+    const deployments = lightningDeployments.filter((d) => d.chainId === supportedChain.id);
+    return deployments ?? [];
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGVwbG95bWVudHMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvbGl0ZS9kZXBsb3ltZW50cy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSwyR0FBMkc7QUFDM0csT0FBTyxFQUFZLGlCQUFpQixFQUFFLE1BQU0sYUFBYSxDQUFDO0FBQzFELE9BQU8sRUFBRSxvQkFBb0IsRUFBRSxNQUFNLDJCQUEyQixDQUFDO0FBT2pFLE1BQU0sVUFBVSw0QkFBNEIsQ0FBQyxLQUFlO0lBQzFELE1BQU0sY0FBYyxHQUFHLGlCQUFpQixDQUFDLEtBQUssQ0FBQyxDQUFDO0lBQ2hELE1BQU0sV0FBVyxHQUFHLG9CQUFvQixDQUFDLE1BQU0sQ0FBQyxDQUFDLENBQUMsRUFBRSxFQUFFLENBQUMsQ0FBQyxDQUFDLE9BQU8sS0FBSyxjQUFjLENBQUMsRUFBRSxDQUFDLENBQUM7SUFDeEYsSUFBSSxDQUFDLFdBQVcsRUFBRSxNQUFNLEVBQUUsQ0FBQztRQUN6QixNQUFNLElBQUksS0FBSyxDQUFDLGtDQUFrQyxLQUFLLEVBQUUsQ0FBQyxDQUFDO0lBQzdELENBQUM7SUFDRCxPQUFPLFdBQVcsQ0FBQyxDQUFDLENBQUMsQ0FBQztBQUN4QixDQUFDO0FBRUQsTUFBTSxVQUFVLHVCQUF1QixDQUFDLE9BQWlCO0lBQ3ZELE1BQU0sY0FBYyxHQUFHLGlCQUFpQixDQUFDLE9BQU8sQ0FBQyxDQUFDO0lBQ2xELE1BQU0sV0FBVyxHQUFHLG9CQUFvQixDQUFDLE1BQU0sQ0FBQyxDQUFDLENBQUMsRUFBRSxFQUFFLENBQUMsQ0FBQyxDQUFDLE9BQU8sS0FBSyxjQUFjLENBQUMsRUFBRSxDQUFDLENBQUM7SUFDeEYsT0FBTyxXQUFXLElBQUksRUFBRSxDQUFDO0FBQzNCLENBQUMifQ==

package/dist/esm/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/esm/lite/ecies.js

@@ -0,0 +1,124 @@
+import { decrypt as eciesDecrypt, encrypt as eciesEncrypt } from 'ecies-geth';
+import * as ellipticPkg from 'elliptic';
+import { asBytes32, bytes32ToBigint, bytesFromHexString, bytesToHex } from '../binary.js';
+import { bigintToPlaintext, ciphertextEnvelopes, encryptionSchemes, getEncryptionSchemeName, } from '../encryption/encryption.js';
+import { computeHandle, computePrehandle } from '../handle.js';
+import { decodeInput, encodeInput } from './hadu.js';
+const secp256k1 = new ellipticPkg.ec('secp256k1');
+// Convert an ec.KeyPair from the 'elliptic' package (assumed to have geen generated
+// with the secp256k1 curve) to our Secp256k1Keypair type.
+export function toSecp256k1Keypair(kp) {
+    return {
+        scheme: encryptionSchemes.ecies,
+        kp,
+        encodePublicKey() {
+            return new Uint8Array(kp.getPublic().encode('array', false));
+        },
+    };
+}
+// Generate a new ephemeral keypair for reencryption.
+export function generateSecp256k1Keypair() {
+    return toSecp256k1Keypair(secp256k1.genKeyPair());
+}
+// EncodePublicKey encodes an ECIES public key it's 33-byte compressed form.
+export function encodeSecp256k1PublicKey(pub) {
+    return new Uint8Array(pub.encodeCompressed('array'));
+}
+// DecodeSecp256k1PublicKey decodes a 33-byte compressed ECIES public key.
+export function decodeSecp256k1PublicKey(pubKeyCompressed) {
+    return secp256k1.keyFromPublic(pubKeyCompressed, 'array').getPublic();
+}
+// DecodeSecp256k1PrivateKey returns a ECIES secp256k1 private key based on the provided byte slice which is
+// interpreted as an unsigned 256-bit big-endian integer in the range [0, N-1],
+// where N is the order of the curve.
+// where N is the order of the curve.
+//
+// WARNING: This means passing a slice with more than 32 bytes is truncated and
+// that truncated value is reduced modulo N.  Further, 0 is not a valid private
+// key.  It is up to the caller to provide a value in the appropriate range of
+// [1, N-1].  Failure to do so will either result in an invalid private key or
+// potentially weak private keys that have bias that could be exploited.
+//
+// This function primarily exists to provide a mechanism for converting
+// serialized private keys that are already known to be good.
+//
+// For more info, refer to the decred/dcrd documentation:
+// ref: https://pkg.go.dev/github.com/decred/dcrd/dcrec/secp256k1/v4@v4.2.0#PrivKeyFromBytes
+//
+// We don't include any curve parameters or ECIES params, as they are assumed to
+// be the ones in ecies.ECIES_AES128_SHA256 from go-ethereum.
+// ref: https://github.com/ethereum/go-ethereum/blob/v1.15.0/crypto/ecies/params.go#L76-L82
+export function decodeSecp256k1PrivateKey(privKey) {
+    return toSecp256k1Keypair(secp256k1.keyFromPrivate(privKey, 'array'));
+}
+// Given a (usually 3rd-party known) public key, called `pubKeyA`, and an ephemeral
+// private key (usually generated locally), called `privKeyB`, encrypt the `msg`
+// using ECIES, with geth's parameters:
+// ref: https://github.com/ethereum/go-ethereum/blob/v1.15.2/crypto/ecies/ecies.go
+export async function encrypt(pubKeyA, plaintext, privKeyB) {
+    const pubKeyABuffer = Buffer.from(pubKeyA.encode('array', false));
+    const privKeyBBuffer = privKeyB.kp.getPrivate().toArrayLike(Buffer, 'be', 32);
+    const ct = await eciesEncrypt(pubKeyABuffer, Buffer.from(plaintext), {
+        ephemPrivateKey: privKeyBBuffer,
+    });
+    return new Uint8Array(ct);
+}
+export function getEciesEncryptor({ pubKeyA, privKeyB }) {
+    const pubKeyABuffer = Buffer.from(pubKeyA.encode('array', false));
+    const privKeyBBuffer = privKeyB.kp.getPrivate().toArrayLike(Buffer, 'be', 32);
+    return async ({ plaintext, context, }) => {
+        if (plaintext.scheme !== encryptionSchemes.ecies) {
+            throw new Error(`Plaintext with scheme ${getEncryptionSchemeName(plaintext.scheme)} cannot be encrypted with ECIES`);
+        }
+        const ptBuf = Buffer.from(encodeInput({ plaintext, context }));
+        const ct = await eciesEncrypt(pubKeyABuffer, ptBuf, {
+            ephemPrivateKey: privKeyBBuffer,
+        });
+        const prehandle = computePrehandle({
+            ciphertext: ct,
+            handleType: plaintext.type,
+            indexHandle: 0,
+            handleVersion: 0,
+        });
+        const handle = computeHandle({
+            prehandle,
+            context: context,
+        });
+        return {
+            prehandle: asBytes32(prehandle),
+            handle: asBytes32(handle),
+            context,
+            ciphertext: {
+                scheme: encryptionSchemes.ecies,
+                type: plaintext.type,
+                value: bytesToHex(ct),
+            },
+        };
+    };
+}
+// Given an ephemeral private key, called `privKeyA`, and a ciphertext `ct`,
+// decrypt the ciphertext using ECIES, with geth's parameters:
+// ref: https://github.com/ethereum/go-ethereum/blob/v1.15.2/crypto/ecies/ecies.go
+export async function decrypt(privKeyA, ciphertext) {
+    const privKeyABuffer = privKeyA.kp.getPrivate().toArrayLike(Buffer, 'be', 32);
+    const pt = await eciesDecrypt(privKeyABuffer, Buffer.from(ciphertext));
+    return new Uint8Array(pt);
+}
+export function getEciesDecryptor({ privKeyA }) {
+    const privKeyABuffer = privKeyA.kp.getPrivate().toArrayLike(Buffer, 'be', 32);
+    return async ({ scheme, type, value, envelope, }) => {
+        if (scheme !== encryptionSchemes.ecies) {
+            throw new Error(`Ciphertext with scheme ${getEncryptionSchemeName(scheme)} cannot be decrypted with ECIES`);
+        }
+        const ptBuf = await eciesDecrypt(privKeyABuffer, bytesFromHexString(value));
+        // If envelope field is omitted then assume HADU, only with an explicit none envelope do we assume a raw byte
+        // encoding as would be performed by the compute server
+        if (envelope === ciphertextEnvelopes.none) {
+            const bigPt = bytes32ToBigint(Buffer.from(ptBuf).toString('hex'));
+            return bigintToPlaintext(scheme, type, bigPt);
+        }
+        const { plaintext } = decodeInput(ptBuf.toString());
+        return plaintext;
+    };
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/esm/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/esm/lite/hadu.js

@@ -0,0 +1,36 @@
+import { Schema } from 'effect';
+import { parseJson } from 'effect/Schema';
+import { Bytes32 } from '../binary.js';
+import { bytes32ToPlaintext, EncryptionScheme, plaintextToBytes32, SupportedFheType, } from '../encryption/index.js';
+import { InputContext } from '../handle.js';
+// HADU stands for "Host Chain, ACL, DApp, and User" it maps to the InputContext type where the aclAddress
+// may actually be the singular IncoLite contract which embeds its own ACL
+export const encryptionEnvelopes = {
+    none: 0,
+    hadu: 1,
+};
+export const EncryptionEnvelope = Schema.Literal(...Object.values(encryptionEnvelopes));
+export const HaduInput = parseJson(Schema.Struct({
+    envelope: Schema.Literal(encryptionEnvelopes.hadu),
+    scheme: EncryptionScheme,
+    context: InputContext,
+    plaintext: Bytes32,
+    type: SupportedFheType,
+}));
+export function encodeInput({ plaintext, context }) {
+    return Schema.encodeSync(HaduInput)({
+        envelope: encryptionEnvelopes.hadu,
+        scheme: plaintext.scheme,
+        type: plaintext.type,
+        plaintext: plaintextToBytes32(plaintext),
+        context,
+    });
+}
+export function decodeInput(json) {
+    const { scheme, context, plaintext, type } = Schema.decodeSync(HaduInput)(json);
+    return {
+        plaintext: bytes32ToPlaintext(plaintext, scheme, type),
+        context,
+    };
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaGFkdS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9saXRlL2hhZHUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLE1BQU0sRUFBRSxNQUFNLFFBQVEsQ0FBQztBQUNoQyxPQUFPLEVBQUUsU0FBUyxFQUFFLE1BQU0sZUFBZSxDQUFDO0FBQzFDLE9BQU8sRUFBRSxPQUFPLEVBQUUsTUFBTSxjQUFjLENBQUM7QUFDdkMsT0FBTyxFQUNMLGtCQUFrQixFQUNsQixnQkFBZ0IsRUFDaEIsa0JBQWtCLEVBRWxCLGdCQUFnQixHQUNqQixNQUFNLHdCQUF3QixDQUFDO0FBQ2hDLE9BQU8sRUFBRSxZQUFZLEVBQUUsTUFBTSxjQUFjLENBQUM7QUFFNUMsMEdBQTBHO0FBQzFHLDBFQUEwRTtBQUUxRSxNQUFNLENBQUMsTUFBTSxtQkFBbUIsR0FBRztJQUNqQyxJQUFJLEVBQUUsQ0FBQztJQUNQLElBQUksRUFBRSxDQUFDO0NBQ0MsQ0FBQztBQUtYLE1BQU0sQ0FBQyxNQUFNLGtCQUFrQixHQUFHLE1BQU0sQ0FBQyxPQUFPLENBQUMsR0FBRyxNQUFNLENBQUMsTUFBTSxDQUFDLG1CQUFtQixDQUFDLENBQUMsQ0FBQztBQUV4RixNQUFNLENBQUMsTUFBTSxTQUFTLEdBQUcsU0FBUyxDQUNoQyxNQUFNLENBQUMsTUFBTSxDQUFDO0lBQ1osUUFBUSxFQUFFLE1BQU0sQ0FBQyxPQUFPLENBQUMsbUJBQW1CLENBQUMsSUFBSSxDQUFDO0lBQ2xELE1BQU0sRUFBRSxnQkFBZ0I7SUFDeEIsT0FBTyxFQUFFLFlBQVk7SUFDckIsU0FBUyxFQUFFLE9BQU87SUFDbEIsSUFBSSxFQUFFLGdCQUFnQjtDQUN2QixDQUFDLENBQ0gsQ0FBQztBQUlGLE1BQU0sVUFBVSxXQUFXLENBQUMsRUFBRSxTQUFTLEVBQUUsT0FBTyxFQUF3QjtJQUN0RSxPQUFPLE1BQU0sQ0FBQyxVQUFVLENBQUMsU0FBUyxDQUFDLENBQUM7UUFDbEMsUUFBUSxFQUFFLG1CQUFtQixDQUFDLElBQUk7UUFDbEMsTUFBTSxFQUFFLFNBQVMsQ0FBQyxNQUFNO1FBQ3hCLElBQUksRUFBRSxTQUFTLENBQUMsSUFBSTtRQUNwQixTQUFTLEVBQUUsa0JBQWtCLENBQUMsU0FBUyxDQUFDO1FBQ3hDLE9BQU87S0FDUixDQUFDLENBQUM7QUFDTCxDQUFDO0FBRUQsTUFBTSxVQUFVLFdBQVcsQ0FBQyxJQUFZO0lBQ3RDLE1BQU0sRUFBRSxNQUFNLEVBQUUsT0FBTyxFQUFFLFNBQVMsRUFBRSxJQUFJLEVBQUUsR0FBRyxNQUFNLENBQUMsVUFBVSxDQUFDLFNBQVMsQ0FBQyxDQUFDLElBQUksQ0FBQyxDQUFDO0lBQ2hGLE9BQU87UUFDTCxTQUFTLEVBQUUsa0JBQWtCLENBQUMsU0FBUyxFQUFFLE1BQU0sRUFBRSxJQUFJLENBQUM7UUFDdEQsT0FBTztLQUNSLENBQUM7QUFDSixDQUFDIn0=

package/dist/esm/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/esm/lite/index.js

@@ -0,0 +1,7 @@
+export * from '../generated/abis/lightning.js';
+export * from './deployments.js';
+export * from './ecies.js';
+export * from './hadu.js';
+export * from './lightning.js';
+export * from './reencrypt.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvbGl0ZS9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLGdDQUFnQyxDQUFDO0FBRS9DLGNBQWMsa0JBQWtCLENBQUM7QUFDakMsY0FBYyxZQUFZLENBQUM7QUFDM0IsY0FBYyxXQUFXLENBQUM7QUFDMUIsY0FBYyxnQkFBZ0IsQ0FBQztBQUMvQixjQUFjLGdCQUFnQixDQUFDIn0=

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

@@ -0,0 +1,124 @@
+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 = Pepper & 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;
+    senderPrivateKey?: HexString;
+};
+/**
+ * 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<DeploymentSlice & CustomConfig>;
+    /**
+     * 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 {};