@inco/js 0.2.16 → 0.2.17

package/dist/esm/lite/lightning.js

@@ -0,0 +1,200 @@
+import { hexToBytes } from 'viem';
+import { baseSepolia } from 'viem/chains';
+import { HexString, parseAddress } from '../binary.js';
+import { encryptionSchemes } from '../encryption/index.js';
+import { lightningDeployments } from '../generated/lightning.js';
+import { localNodeLightningConfig } from '../generated/local-node.js';
+import { handleTypes } from '../handle.js';
+import { parse } from '../schema.js';
+import { decodeSecp256k1PublicKey, generateSecp256k1Keypair, getEciesEncryptor } from './ecies.js';
+import { getKmsClient, incoLiteReencryptor } from './reencrypt.js';
+const DefaultPepper = 'testnet';
+/**
+ * The Lightning class provides a convenient way to interact with the Inco Lightning contract by binding to a specific
+ * deployment.
+ */
+export class Lightning {
+    _deployment;
+    covalidatorUrl;
+    executorAddress;
+    eciesPublicKey;
+    chainId;
+    encryptor;
+    ephemeralKeypair;
+    kmsClient;
+    constructor(_deployment, covalidatorUrl) {
+        this._deployment = _deployment;
+        this.covalidatorUrl = covalidatorUrl;
+        this.executorAddress = parseAddress(_deployment.executorAddress);
+        this.eciesPublicKey = parse(HexString, _deployment.eciesPublicKey);
+        this.chainId = BigInt(_deployment.chainId);
+        this.ephemeralKeypair = generateSecp256k1Keypair();
+        this.kmsClient = getKmsClient(covalidatorUrl);
+        this.encryptor = getEciesEncryptor({
+            scheme: encryptionSchemes.ecies,
+            pubKeyA: decodeSecp256k1PublicKey(hexToBytes(parse(HexString, _deployment.eciesPublicKey))),
+            privKeyB: this.ephemeralKeypair,
+        });
+    }
+    /**
+     * Get a Lightning instance bound to the latest Lightning deployment for the Base Sepolia testnet.
+     */
+    static baseSepoliaTestnet() {
+        return Lightning.latest('testnet', baseSepolia.id);
+    }
+    /**
+     * 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) {
+        if (!env) {
+            return Lightning.custom(localNodeLightningConfig[DefaultPepper]);
+        }
+        if (typeof env === 'string') {
+            return Lightning.custom(localNodeLightningConfig[env]);
+        }
+        const conf = localNodeLightningConfig[DefaultPepper];
+        return Lightning.custom({
+            // We assume that we always run a local node as the default anvil node
+            chainId: conf.chainId,
+            covalidatorUrl: conf.covalidatorUrl,
+            // These variables vary per environment
+            executorAddress: env.EXECUTOR_ADDRESS,
+            eciesPublicKey: env.ECIES_PUBLIC_KEY,
+            senderPrivateKey: env.SENDER_PRIVATE_KEY,
+        });
+    }
+    /**
+     * 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) {
+        const deployment = this.isIdByName(id)
+            ? lightningDeployments.find((d) => d.name === id.name && d.chainId === id.chainId)
+            : lightningDeployments.find((d) => d.executorAddress === id.executorAddress && d.chainId === id.chainId);
+        if (!deployment) {
+            throw new Error(`No deployment found for ${JSON.stringify(id)}`);
+        }
+        return new Lightning(deployment, Lightning.getCovalidatorUrl(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(config) {
+        return new Lightning(config, config.covalidatorUrl);
+    }
+    /**
+     * 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(pepper, chainId) {
+        // Deployments are sorted so we are guaranteed to get the latest first
+        const latestByPepper = lightningDeployments.find((d) => d.pepper === pepper && d.chainId === chainId);
+        if (!latestByPepper) {
+            // This should not actually happen provided this file compiles since we are extracting the available peppers
+            // from the const itself
+            throw new Error(`No deployment found for pepper ${pepper}`);
+        }
+        return latestByPepper;
+    }
+    /**
+     * 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(pepper, chainId) {
+        return Lightning.at(Lightning.latestDeployment(pepper, chainId));
+    }
+    /*
+     * 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.
+     */
+    get deployment() {
+        return { ...this._deployment };
+    }
+    /**
+     * 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
+     */
+    async encrypt(value, { accountAddress, dappAddress }) {
+        const { ciphertext } = await this.encryptor({
+            plaintext: Lightning.plaintextFromValue(value),
+            context: {
+                hostChainId: this.chainId,
+                aclAddress: this.executorAddress,
+                userAddress: parseAddress(accountAddress),
+                contractAddress: parseAddress(dappAddress),
+            },
+        });
+        return ciphertext.value;
+    }
+    /**
+     * 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) {
+        return incoLiteReencryptor({
+            walletClient,
+            kmsConnectRpcEndpointOrClient: this.kmsClient,
+            chainId: this.chainId,
+            ephemeralKeypair: this.ephemeralKeypair,
+        });
+    }
+    /**
+     * Get the GRPC endpoint for the covalidator that services this deployment.
+     */
+    static getCovalidatorUrl(deployment) {
+        const { executorAddress, chainId, pepper } = deployment;
+        return `https://${executorAddress.toLowerCase()}.${chainId}.${pepper}.inco.org`;
+    }
+    static isIdByName(id) {
+        return id.name !== undefined;
+    }
+    static plaintextFromValue(value) {
+        if (typeof value === 'boolean') {
+            return {
+                scheme: encryptionSchemes.ecies,
+                type: handleTypes.ebool,
+                value: value,
+            };
+        }
+        else if (typeof value === 'bigint' || typeof value === 'number') {
+            return {
+                scheme: encryptionSchemes.ecies,
+                type: handleTypes.euint256,
+                value: BigInt(value),
+            };
+        }
+        else {
+            throw new Error(`Unsupported type ${typeof value}`);
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,132 @@
+import { createClient } from '@connectrpc/connect';
+import { createConnectTransport } from '@connectrpc/connect-web';
+import { bytesToHex, hexToBytes } from 'viem';
+import { bytesToBigInt } from '../binary.js';
+import { getSupportedChain } from '../chain.js';
+import { bigintToPlaintext, encryptionSchemes, } from '../encryption/encryption.js';
+import { KmsService } from '../generated/es/inco/kms/lite/v1/kms_service_pb.js';
+import { getHandleType } from '../handle.js';
+import { createEIP712Payload } from '../reencryption/eip712.js';
+import { retryWithBackoff } from '../retry.js';
+import { decrypt, generateSecp256k1Keypair } from './ecies.js';
+// The domain constants used for basic reencrypts.
+// Note: for advanced ACL, since the signature is checked on-chain, the domain
+// and version must match the ones used in the contract. For basic ones, we use
+// a domain different than the one used on-chain
+const BASIC_REENCRYPT_DOMAIN = {
+    name: 'IncoReencryption',
+    version: '0.1.0',
+};
+// Create an EIP712 payload for the Inco Lite basic reencrypt.
+export function reencryptEIP712(chainId, ephemeralPubKey) {
+    return createEIP712Payload({
+        chainId,
+        primaryType: 'ReencryptionRequest',
+        primaryTypeFields: [{ name: 'publicKey', type: 'bytes' }],
+        message: {
+            publicKey: bytesToHex(ephemeralPubKey),
+        },
+        domainName: BASIC_REENCRYPT_DOMAIN.name,
+        domainVersion: BASIC_REENCRYPT_DOMAIN.version,
+    });
+}
+// Returns the Inco Lite Reencryptor, which can reencrypt a handle using the
+// Basic ACL.
+export async function incoLiteReencryptor({ kmsConnectRpcEndpointOrClient, chainId, walletClient, ephemeralKeypair, }) {
+    const kmsClient = getKmsClient(kmsConnectRpcEndpointOrClient || defaultCovalidatorGrpc(getSupportedChain(chainId)));
+    if (!ephemeralKeypair) {
+        ephemeralKeypair = await generateSecp256k1Keypair();
+    }
+    // Sign the EIP712 attesting that the user has access to the private key
+    // corresponding to the ephemeral public key.
+    const eip712Payload = reencryptEIP712(chainId, ephemeralKeypair.encodePublicKey());
+    // Using browser extensions, this step will prompt the user to sign the
+    // payload.
+    const eip712Signature = await walletClient.signTypedData(eip712Payload);
+    return async function reencrypt({ handle }, backoffConfig) {
+        const ephemeralPubKey = ephemeralKeypair.encodePublicKey();
+        const reencryptRequest = {
+            $typeName: 'inco.kms.lite.v1.ReencryptRequest',
+            userAddress: walletClient.account.address,
+            ephemeralPubKey,
+            eip712Signature: hexToBytes(eip712Signature),
+            handlesWithProofs: [
+                {
+                    $typeName: 'inco.kms.lite.v1.HandleWithProof',
+                    handle,
+                    aclProof: {
+                        $typeName: 'inco.kms.lite.v1.ACLProof',
+                        // See advancedacl/session-key.ts for an example of using
+                        // Advanced ACL.
+                        proof: {
+                            case: 'incoLiteBasicAclProof',
+                            value: {
+                                $typeName: 'inco.kms.lite.v1.IncoLiteBasicACLProof',
+                            },
+                        },
+                    },
+                },
+            ],
+        };
+        try {
+            return await retryWithBackoff(async () => {
+                const response = await kmsClient.reencrypt(reencryptRequest);
+                return decryptGrpcResponse(response, ephemeralKeypair, handle);
+            }, backoffConfig);
+        }
+        catch (error) {
+            console.log(error);
+            throw error;
+        }
+    };
+}
+// Helper function to get a KMS client from a string or a Client instance.
+export function getKmsClient(kmsConnectRpcEndpointOrClient) {
+    if (typeof kmsConnectRpcEndpointOrClient === 'string') {
+        const transport = createConnectTransport({
+            baseUrl: kmsConnectRpcEndpointOrClient,
+        });
+        return createClient(KmsService, transport);
+    }
+    return kmsConnectRpcEndpointOrClient;
+}
+// Decrypt using ECIES the ciphertext in the response.
+// Even though the proto specifies a list of ciphertexts, our JS SDK
+// currently only supports a single ciphertext.
+export async function decryptGrpcResponse(response, ephemeralKeypair, handle) {
+    const reencryptedCt = response.payload?.userCiphertexts[0];
+    if (!reencryptedCt) {
+        throw new Error('No reencrypted ciphertext in the response');
+    }
+    const plaintextBytes = await decrypt(ephemeralKeypair, reencryptedCt.ciphertext);
+    const plaintext = bytesToBigInt(plaintextBytes);
+    return bigintToPlaintext(encryptionSchemes.ecies, getHandleType(handle), plaintext);
+}
+// Helper function to return the default gRPC endpoint for the covalidator.
+// Currently, this returns the covalidator for the Inco Lightning public testnet.
+export function defaultCovalidatorGrpc(chain) {
+    return lightningTestnetCovalidatorGrpc(chain);
+}
+// Helper function to get the gRPC endpoint for the Denver covalidator on the
+// AWS (Pulumi) setup. This function is a convenience, and might disappear in
+// the future, if the denver testnet is no longer supported.
+export function pulumiCovalidatorGrpc(chain) {
+    return `https://grpc.${chain.name.toLowerCase()}.covalidator.denver.inco.org`;
+}
+// Helper function to get the devnet gRPC endpoint for the Inco Lightning covalidator.
+export function lightningDevnetCovalidatorGrpc(chain) {
+    return getCovalidatorGrpcHelper(chain, 'devnet', 'lightning');
+}
+// Helper function to get the testnet gRPC endpoint for the Inco Lightning covalidator.
+export function lightningTestnetCovalidatorGrpc(chain) {
+    return getCovalidatorGrpcHelper(chain, 'testnet', 'lightning');
+}
+// Convert camelCase to dash-case.
+function camelToDashCase(str) {
+    return str.replace(/([a-z])([A-Z])/g, '$1-$2').toLowerCase();
+}
+// Small helper, as our GCP covalidator URLs are in a specific format.
+function getCovalidatorGrpcHelper(chain, network, cluster) {
+    return `https://grpc.${camelToDashCase(chain.name)}.${cluster}.${network}.inco.org`;
+}
+//# sourceMappingURL=data:application/json;base64,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

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

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

package/dist/esm/local/index.js

@@ -0,0 +1,2 @@
+export * from './local-node.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvbG9jYWwvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxpQkFBaUIsQ0FBQyJ9

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

@@ -0,0 +1,19 @@
+import { Schema } from 'effect';
+export declare const LocalNodeEnv: Schema.Struct<{
+    DEPLOYER_ADDRESS: Schema.brand<Schema.filter<Schema.TemplateLiteral<`0x${string}`>>, "Address">;
+    STATE_DUMP: typeof Schema.String;
+    EXECUTOR_ADDRESS: Schema.brand<Schema.filter<Schema.TemplateLiteral<`0x${string}`>>, "Address">;
+    ECIES_PUBLIC_KEY: Schema.TemplateLiteral<`0x${string}`>;
+    CALLBACK_ADDRESS: Schema.TemplateLiteral<`0x${string}`>;
+    SENDER_ADDRESS: Schema.brand<Schema.filter<Schema.TemplateLiteral<`0x${string}`>>, "Address">;
+    SENDER_PRIVATE_KEY: Schema.TemplateLiteral<`0x${string}`>;
+    PEPPER: typeof Schema.String;
+    COVALIDATOR_ECIES_PRIVATE_KEY: Schema.TemplateLiteral<`0x${string}`>;
+    COVALIDATOR_EIP712_PRIVATE_SIGNING_KEY: Schema.TemplateLiteral<`0x${string}`>;
+    COVALIDATOR_CALLBACK_PRIVATE_KEY: Schema.TemplateLiteral<`0x${string}`>;
+    COVALIDATOR_ACL_ADDR: Schema.brand<Schema.filter<Schema.TemplateLiteral<`0x${string}`>>, "Address">;
+    COVALIDATOR_INCO_EXECUTOR_ADDR: Schema.brand<Schema.filter<Schema.TemplateLiteral<`0x${string}`>>, "Address">;
+    COVALIDATOR_DECRYPTION_HANDLER_ADDR: Schema.brand<Schema.filter<Schema.TemplateLiteral<`0x${string}`>>, "Address">;
+}>;
+export type LocalNodeEnv = typeof LocalNodeEnv.Type;
+export declare function parseLocalEnv(envFileContents: string | Buffer): LocalNodeEnv;

package/dist/esm/local/local-node.js

@@ -0,0 +1,24 @@
+import { Address, HexString } from '@inco/pega/lib/hex';
+import * as dotenv from 'dotenv';
+import { Schema } from 'effect';
+export const LocalNodeEnv = Schema.Struct({
+    DEPLOYER_ADDRESS: Address,
+    STATE_DUMP: Schema.String,
+    EXECUTOR_ADDRESS: Address,
+    ECIES_PUBLIC_KEY: HexString,
+    CALLBACK_ADDRESS: HexString,
+    SENDER_ADDRESS: Address,
+    SENDER_PRIVATE_KEY: HexString,
+    PEPPER: Schema.String,
+    COVALIDATOR_ECIES_PRIVATE_KEY: HexString,
+    COVALIDATOR_EIP712_PRIVATE_SIGNING_KEY: HexString,
+    COVALIDATOR_CALLBACK_PRIVATE_KEY: HexString,
+    COVALIDATOR_ACL_ADDR: Address,
+    COVALIDATOR_INCO_EXECUTOR_ADDR: Address,
+    COVALIDATOR_DECRYPTION_HANDLER_ADDR: Address,
+});
+export function parseLocalEnv(envFileContents) {
+    const envObj = dotenv.parse(envFileContents);
+    return Schema.decodeUnknownSync(LocalNodeEnv)(envObj);
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibG9jYWwtbm9kZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9sb2NhbC9sb2NhbC1ub2RlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxPQUFPLEVBQUUsU0FBUyxFQUFFLE1BQU0sb0JBQW9CLENBQUM7QUFDeEQsT0FBTyxLQUFLLE1BQU0sTUFBTSxRQUFRLENBQUM7QUFDakMsT0FBTyxFQUFFLE1BQU0sRUFBRSxNQUFNLFFBQVEsQ0FBQztBQUVoQyxNQUFNLENBQUMsTUFBTSxZQUFZLEdBQUcsTUFBTSxDQUFDLE1BQU0sQ0FBQztJQUN4QyxnQkFBZ0IsRUFBRSxPQUFPO0lBQ3pCLFVBQVUsRUFBRSxNQUFNLENBQUMsTUFBTTtJQUN6QixnQkFBZ0IsRUFBRSxPQUFPO0lBQ3pCLGdCQUFnQixFQUFFLFNBQVM7SUFDM0IsZ0JBQWdCLEVBQUUsU0FBUztJQUMzQixjQUFjLEVBQUUsT0FBTztJQUN2QixrQkFBa0IsRUFBRSxTQUFTO0lBQzdCLE1BQU0sRUFBRSxNQUFNLENBQUMsTUFBTTtJQUNyQiw2QkFBNkIsRUFBRSxTQUFTO0lBQ3hDLHNDQUFzQyxFQUFFLFNBQVM7SUFDakQsZ0NBQWdDLEVBQUUsU0FBUztJQUMzQyxvQkFBb0IsRUFBRSxPQUFPO0lBQzdCLDhCQUE4QixFQUFFLE9BQU87SUFDdkMsbUNBQW1DLEVBQUUsT0FBTztDQUM3QyxDQUFDLENBQUM7QUFJSCxNQUFNLFVBQVUsYUFBYSxDQUFDLGVBQWdDO0lBQzVELE1BQU0sTUFBTSxHQUFHLE1BQU0sQ0FBQyxLQUFLLENBQUMsZUFBZSxDQUFDLENBQUM7SUFDN0MsT0FBTyxNQUFNLENBQUMsaUJBQWlCLENBQUMsWUFBWSxDQUFDLENBQUMsTUFBTSxDQUFDLENBQUM7QUFDeEQsQ0FBQyJ9

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

@@ -0,0 +1,29 @@
+import { Schema } from 'effect';
+import { Address } from 'viem';
+declare const baseEIP712: Schema.Struct<{
+    domain: Schema.Struct<{
+        chainId: typeof Schema.BigInt;
+        name: typeof Schema.String;
+        version: typeof Schema.String;
+        verifyingContract: Schema.optional<Schema.TemplateLiteral<`0x${string}`>>;
+    }>;
+    primaryType: typeof Schema.String;
+    types: Schema.Record$<typeof Schema.String, Schema.Array$<Schema.Struct<{
+        name: typeof Schema.String;
+        type: typeof Schema.String;
+    }>>>;
+}>;
+type BaseEIP712 = typeof baseEIP712.Type;
+export interface EIP712<Message extends object> extends BaseEIP712 {
+    message: Message;
+}
+export declare function createEIP712Payload<PrimaryType extends string, Message extends object>({ chainId, primaryType, primaryTypeFields, message, verifyingContract, domainName, domainVersion, }: {
+    chainId: bigint;
+    primaryType: PrimaryType;
+    primaryTypeFields: BaseEIP712['types'][PrimaryType];
+    message: Message;
+    verifyingContract?: Address;
+    domainName?: string;
+    domainVersion?: string;
+}): EIP712<Message>;
+export {};

package/dist/esm/reencryption/eip712.js

@@ -0,0 +1,81 @@
+import { Schema } from 'effect';
+import { HexString } from '../binary.js';
+import { getActiveLightningDeployment } from '../lite/deployments.js';
+// An effect Schema representing a base EIP712 typed message, without any
+// custom message types, as defined in EIP-712.
+const baseEIP712 = Schema.Struct({
+    domain: Schema.Struct({
+        chainId: Schema.BigInt,
+        name: Schema.String,
+        version: Schema.String,
+        verifyingContract: Schema.optional(HexString),
+        // If salt is needed, it can be added here. Currently, none of the Incolite
+        // features need this.
+    }),
+    primaryType: Schema.String,
+    types: Schema.Record({
+        key: Schema.String,
+        value: Schema.Array(Schema.Struct({
+            name: Schema.String,
+            type: Schema.String,
+        })),
+    }),
+});
+// This function creates the payload that will be signed by the user. It is used to verify that the
+// user has access to the private key that corresponds to the ephemeral public key in the payload.
+// If the last argument is provided, it will be used as the contract address.
+//
+// The `message` argument must have the same keys as the all the `name` values
+// in the `primaryTypeFields` argument.
+export function createEIP712Payload({ chainId, primaryType, primaryTypeFields, message, verifyingContract, domainName, domainVersion, }) {
+    const types = {
+        // This refers to the domain the contract is hosted on.
+        EIP712Domain: [
+            { name: 'name', type: 'string' },
+            { name: 'version', type: 'string' },
+            { name: 'chainId', type: 'uint256' },
+        ],
+        // Refer to primaryType.
+        [primaryType]: primaryTypeFields,
+    };
+    if (verifyingContract) {
+        types.EIP712Domain.push({ name: 'verifyingContract', type: 'address' });
+    }
+    // Check that the message has the same keys as the primaryTypeFields.
+    const messageKeys = Object.keys(message);
+    const primaryTypeFieldsKeys = primaryTypeFields.map((field) => field.name);
+    if (messageKeys.length !== primaryTypeFieldsKeys.length) {
+        throw new Error('Message keys do not match primaryTypeFields keys');
+    }
+    for (const key of messageKeys) {
+        if (!primaryTypeFieldsKeys.includes(key)) {
+            throw new Error(`Message key ${key} does not match primaryTypeFields key`);
+        }
+    }
+    // TODO: We could also check that the types of the values are correct here.
+    if (!domainVersion) {
+        const incoLite = getActiveLightningDeployment(chainId);
+        // See Version.sol for the format of the version string.
+        domainVersion = `${incoLite.version.major}_${incoLite.version.minor}_${incoLite.version.patch}`;
+    }
+    const msgParams = {
+        types,
+        // This defines the message you're proposing the user to sign, is dapp-specific, and contains
+        // anything you want. There are no required fields. Be as explicit as possible when building out
+        // the message schema.
+        // This refers to the keys of the following types object.
+        primaryType,
+        domain: {
+            // Give a user-friendly name to the specific contract you're signing for.
+            name: domainName ?? 'incoLite',
+            // This identifies the latest version.
+            version: domainVersion,
+            // This defines the network, in this case, Mainnet.
+            chainId,
+            verifyingContract,
+        },
+        message,
+    };
+    return msgParams;
+}
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,2 @@
+export * from './eip712.js';
+export * from './types.js';

package/dist/esm/reencryption/index.js

@@ -0,0 +1,3 @@
+export * from './eip712.js';
+export * from './types.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvcmVlbmNyeXB0aW9uL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsYUFBYSxDQUFDO0FBQzVCLGNBQWMsWUFBWSxDQUFDIn0=

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

@@ -0,0 +1,25 @@
+import { Address } from 'viem';
+import { HexString } from '../binary.js';
+import { CiphertextOf, EncryptionScheme, PlaintextOf, SupportedFheType } from '../encryption/encryption.js';
+import type { EphemeralCryptoBoxKeypair } from '../fhevm/reencrypt.js';
+import { Handle } from '../handle.js';
+import type { Secp256k1Keypair } from '../lite/ecies.js';
+import type { BackoffConfig } from '../retry.js';
+export type Reencryptor<S extends EncryptionScheme> = <T extends SupportedFheType>(args: ReencryptFnArgs<S, T>, backoffConfig?: Partial<BackoffConfig>) => Promise<PlaintextOf<S, T>>;
+export interface ReencryptorArgs {
+    chainId: bigint;
+}
+export type ReencryptFnArgs<S extends EncryptionScheme, T extends SupportedFheType> = {
+    handle: Handle;
+    ciphertext?: CiphertextOf<S, T>;
+};
+export type SupportedEphemeralKeypairs = EphemeralCryptoBoxKeypair | Secp256k1Keypair;
+export interface PubKeyEncodable {
+    encodePublicKey(): Uint8Array;
+}
+export interface ReencryptEndpointRequest<EKP extends SupportedEphemeralKeypairs> {
+    userAddress: Address;
+    handle: Handle;
+    eip712Signature: HexString;
+    ephemeralKeypair: EKP;
+}

package/dist/esm/reencryption/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHlwZXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvcmVlbmNyeXB0aW9uL3R5cGVzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIifQ==

package/dist/esm/retry.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Configuration for exponential backoff retry logic.
+ */
+export type BackoffConfig = {
+    maxRetries: number;
+    baseDelayInMs: number;
+    backoffFactor: number;
+};
+/**
+ * Helper function to implement exponential backoff retry logic.
+ * @param fn - The function to retry
+ * @param config - Optional backoff configuration
+ * @returns Promise that resolves with the result of the function
+ */
+export declare function retryWithBackoff<T>(fn: () => Promise<T>, { maxRetries, baseDelayInMs, backoffFactor }?: Partial<BackoffConfig>): Promise<T>;

package/dist/esm/retry.js

@@ -0,0 +1,25 @@
+/**
+ * Helper function to implement exponential backoff retry logic.
+ * @param fn - The function to retry
+ * @param config - Optional backoff configuration
+ * @returns Promise that resolves with the result of the function
+ */
+export async function retryWithBackoff(fn, { maxRetries = 10, baseDelayInMs = 1000, backoffFactor = 1.5 } = {}) {
+    let lastError;
+    for (let attempt = 0; attempt < maxRetries; attempt++) {
+        try {
+            return await fn();
+        }
+        catch (error) {
+            lastError = error;
+            if (attempt === maxRetries - 1) {
+                break;
+            }
+            const delay = baseDelayInMs * Math.pow(backoffFactor, attempt);
+            const jitter = delay * (0.8 + Math.random() * 0.4); // random jitter, 80% to 120% of the delay
+            await new Promise((resolve) => setTimeout(resolve, jitter));
+        }
+    }
+    throw lastError;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicmV0cnkuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvcmV0cnkudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBU0E7Ozs7O0dBS0c7QUFDSCxNQUFNLENBQUMsS0FBSyxVQUFVLGdCQUFnQixDQUNwQyxFQUFvQixFQUNwQixFQUFFLFVBQVUsR0FBRyxFQUFFLEVBQUUsYUFBYSxHQUFHLElBQUksRUFBRSxhQUFhLEdBQUcsR0FBRyxLQUE2QixFQUFFO0lBRTNGLElBQUksU0FBNEIsQ0FBQztJQUVqQyxLQUFLLElBQUksT0FBTyxHQUFHLENBQUMsRUFBRSxPQUFPLEdBQUcsVUFBVSxFQUFFLE9BQU8sRUFBRSxFQUFFLENBQUM7UUFDdEQsSUFBSSxDQUFDO1lBQ0gsT0FBTyxNQUFNLEVBQUUsRUFBRSxDQUFDO1FBQ3BCLENBQUM7UUFBQyxPQUFPLEtBQUssRUFBRSxDQUFDO1lBQ2YsU0FBUyxHQUFHLEtBQWMsQ0FBQztZQUMzQixJQUFJLE9BQU8sS0FBSyxVQUFVLEdBQUcsQ0FBQyxFQUFFLENBQUM7Z0JBQy9CLE1BQU07WUFDUixDQUFDO1lBQ0QsTUFBTSxLQUFLLEdBQUcsYUFBYSxHQUFHLElBQUksQ0FBQyxHQUFHLENBQUMsYUFBYSxFQUFFLE9BQU8sQ0FBQyxDQUFDO1lBQy9ELE1BQU0sTUFBTSxHQUFHLEtBQUssR0FBRyxDQUFDLEdBQUcsR0FBRyxJQUFJLENBQUMsTUFBTSxFQUFFLEdBQUcsR0FBRyxDQUFDLENBQUMsQ0FBQywwQ0FBMEM7WUFDOUYsTUFBTSxJQUFJLE9BQU8sQ0FBQyxDQUFDLE9BQU8sRUFBRSxFQUFFLENBQUMsVUFBVSxDQUFDLE9BQU8sRUFBRSxNQUFNLENBQUMsQ0FBQyxDQUFDO1FBQzlELENBQUM7SUFDSCxDQUFDO0lBRUQsTUFBTSxTQUFTLENBQUM7QUFDbEIsQ0FBQyJ9

package/dist/esm/schema.d.ts

@@ -0,0 +1,4 @@
+import { Schema } from 'effect';
+import { ParseOptions } from 'effect/SchemaAST';
+export declare function parse<A, I>(schema: Schema.Schema<A, I>, obj: unknown, options?: ParseOptions): A;
+export declare function parseJson<A, I>(schema: Schema.Schema<A, I>, json: string | Uint8Array, options?: ParseOptions): A;