@inco/js 0.2.16 → 0.3.0

package/dist/esm/lite/lightning.js

@@ -0,0 +1,213 @@
+import * as fs from 'fs/promises';
+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 { parseLocalEnv } from '../local/index.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: env.COVALIDATOR_HOST_CHAIN_ID ? Number(env.COVALIDATOR_HOST_CHAIN_ID) : conf.chainId,
+            covalidatorUrl: env.COVALIDATOR_GRPC_SERVER_ADDRESS ?? conf.covalidatorUrl,
+            hostChainRpcUrl: env.COVALIDATOR_HOST_CHAIN_RPC_URL ?? conf.hostChainRpcUrl ?? 'http://localhost:8545',
+            // These variables vary per environment
+            executorAddress: env.EXECUTOR_ADDRESS,
+            eciesPublicKey: env.ECIES_PUBLIC_KEY,
+            senderPrivateKey: env.SENDER_PRIVATE_KEY,
+        });
+    }
+    /**
+     * 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 async localNodeFromEnv(filePath) {
+        const buf = filePath ? await fs.readFile(filePath) : undefined;
+        const env = parseLocalEnv(buf);
+        return Lightning.localNode(env);
+    }
+    /**
+     * 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,22 @@
+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">;
+    COVALIDATOR_HOST_CHAIN_ID: Schema.optional<typeof Schema.String>;
+    COVALIDATOR_GRPC_SERVER_ADDRESS: Schema.optional<typeof Schema.String>;
+    COVALIDATOR_HOST_CHAIN_RPC_URL: Schema.optional<typeof Schema.String>;
+}>;
+export type LocalNodeEnv = typeof LocalNodeEnv.Type;
+export declare function parseLocalEnv(envFileOrObj?: string | Buffer): LocalNodeEnv;

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

@@ -0,0 +1,29 @@
+import * as dotenv from '@dotenvx/dotenvx';
+import { Address, HexString } from '@inco/pega/lib/hex';
+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,
+    COVALIDATOR_HOST_CHAIN_ID: Schema.optional(Schema.String),
+    COVALIDATOR_GRPC_SERVER_ADDRESS: Schema.optional(Schema.String),
+    COVALIDATOR_HOST_CHAIN_RPC_URL: Schema.optional(Schema.String),
+});
+// Parses a local environment file or object into a LocalNodeEnv type.
+// If no file or object is provided, it defaults to process.env.
+export function parseLocalEnv(envFileOrObj) {
+    const envObj = envFileOrObj ? dotenv.parse(envFileOrObj) : process.env;
+    return Schema.decodeUnknownSync(LocalNodeEnv)(envObj);
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibG9jYWwtbm9kZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9sb2NhbC9sb2NhbC1ub2RlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sS0FBSyxNQUFNLE1BQU0sa0JBQWtCLENBQUM7QUFDM0MsT0FBTyxFQUFFLE9BQU8sRUFBRSxTQUFTLEVBQUUsTUFBTSxvQkFBb0IsQ0FBQztBQUN4RCxPQUFPLEVBQUUsTUFBTSxFQUFFLE1BQU0sUUFBUSxDQUFDO0FBRWhDLE1BQU0sQ0FBQyxNQUFNLFlBQVksR0FBRyxNQUFNLENBQUMsTUFBTSxDQUFDO0lBQ3hDLGdCQUFnQixFQUFFLE9BQU87SUFDekIsVUFBVSxFQUFFLE1BQU0sQ0FBQyxNQUFNO0lBQ3pCLGdCQUFnQixFQUFFLE9BQU87SUFDekIsZ0JBQWdCLEVBQUUsU0FBUztJQUMzQixnQkFBZ0IsRUFBRSxTQUFTO0lBQzNCLGNBQWMsRUFBRSxPQUFPO0lBQ3ZCLGtCQUFrQixFQUFFLFNBQVM7SUFDN0IsTUFBTSxFQUFFLE1BQU0sQ0FBQyxNQUFNO0lBQ3JCLDZCQUE2QixFQUFFLFNBQVM7SUFDeEMsc0NBQXNDLEVBQUUsU0FBUztJQUNqRCxnQ0FBZ0MsRUFBRSxTQUFTO0lBQzNDLG9CQUFvQixFQUFFLE9BQU87SUFDN0IsOEJBQThCLEVBQUUsT0FBTztJQUN2QyxtQ0FBbUMsRUFBRSxPQUFPO0lBQzVDLHlCQUF5QixFQUFFLE1BQU0sQ0FBQyxRQUFRLENBQUMsTUFBTSxDQUFDLE1BQU0sQ0FBQztJQUN6RCwrQkFBK0IsRUFBRSxNQUFNLENBQUMsUUFBUSxDQUFDLE1BQU0sQ0FBQyxNQUFNLENBQUM7SUFDL0QsOEJBQThCLEVBQUUsTUFBTSxDQUFDLFFBQVEsQ0FBQyxNQUFNLENBQUMsTUFBTSxDQUFDO0NBQy9ELENBQUMsQ0FBQztBQUlILHNFQUFzRTtBQUN0RSxnRUFBZ0U7QUFDaEUsTUFBTSxVQUFVLGFBQWEsQ0FBQyxZQUE4QjtJQUMxRCxNQUFNLE1BQU0sR0FBRyxZQUFZLENBQUMsQ0FBQyxDQUFDLE1BQU0sQ0FBQyxLQUFLLENBQUMsWUFBWSxDQUFDLENBQUMsQ0FBQyxDQUFDLE9BQU8sQ0FBQyxHQUFHLENBQUM7SUFDdkUsT0FBTyxNQUFNLENBQUMsaUJBQWlCLENBQUMsWUFBWSxDQUFDLENBQUMsTUFBTSxDQUFDLENBQUM7QUFDeEQsQ0FBQyJ9

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,83 @@
+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, 
+// Name of the IncoLightning contract.
+domainName = 'incoLite', 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,
+            // 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>;