@inco/js 0.2.16 → 0.2.17

package/dist/esm/chain.js

@@ -0,0 +1,24 @@
+// No imports here to avoid issues with closures and modules across pulumi boundary
+// This file can be seen as mirroring the functionality of viem changes without depending on it directly.
+// It exists as a workaround for some very gnarly issues with code reuse between Pulumi and this module, partly
+// relating to modules but also linked to Pulumi's ability to capture closures and serialise them.
+export const supportedChains = {
+    baseSepolia: 84532,
+    sepolia: 11155111,
+    monadTestnet: 10143,
+};
+export const fheSupportedChains = { baseSepolia: 84532, sepolia: 11155111 };
+// Get supportedChain either by its chain ID or the short name (lower pascal case)
+export function getSupportedChain(chainish) {
+    const found = typeof chainish === 'number' || typeof chainish === 'bigint'
+        ? Object.entries(supportedChains).find(([, id]) => id === Number(chainish))
+        : typeof chainish === 'object'
+            ? Object.entries(supportedChains).find(([, id]) => id === Number(chainish.id))
+            : Object.entries(supportedChains).find(([shortName]) => shortName === chainish);
+    if (!found) {
+        throw new Error(`Supported chain ${JSON.stringify(chainish)} not found`);
+    }
+    const [name, id] = found;
+    return { name: name, id };
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2hhaW4uanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvY2hhaW4udHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsbUZBQW1GO0FBRW5GLHlHQUF5RztBQUN6RywrR0FBK0c7QUFDL0csa0dBQWtHO0FBRWxHLE1BQU0sQ0FBQyxNQUFNLGVBQWUsR0FBRztJQUM3QixXQUFXLEVBQUUsS0FBSztJQUNsQixPQUFPLEVBQUUsUUFBUTtJQUNqQixZQUFZLEVBQUUsS0FBSztDQUNYLENBQUM7QUFFWCxNQUFNLENBQUMsTUFBTSxrQkFBa0IsR0FBRyxFQUFFLFdBQVcsRUFBRSxLQUFLLEVBQUUsT0FBTyxFQUFFLFFBQVEsRUFBVyxDQUFDO0FBY3JGLGtGQUFrRjtBQUNsRixNQUFNLFVBQVUsaUJBQWlCLENBQUMsUUFBa0I7SUFDbEQsTUFBTSxLQUFLLEdBQ1QsT0FBTyxRQUFRLEtBQUssUUFBUSxJQUFJLE9BQU8sUUFBUSxLQUFLLFFBQVE7UUFDMUQsQ0FBQyxDQUFDLE1BQU0sQ0FBQyxPQUFPLENBQUMsZUFBZSxDQUFDLENBQUMsSUFBSSxDQUFDLENBQUMsQ0FBQyxFQUFFLEVBQUUsQ0FBQyxFQUFFLEVBQUUsQ0FBQyxFQUFFLEtBQUssTUFBTSxDQUFDLFFBQVEsQ0FBQyxDQUFDO1FBQzNFLENBQUMsQ0FBQyxPQUFPLFFBQVEsS0FBSyxRQUFRO1lBQzVCLENBQUMsQ0FBQyxNQUFNLENBQUMsT0FBTyxDQUFDLGVBQWUsQ0FBQyxDQUFDLElBQUksQ0FBQyxDQUFDLENBQUMsRUFBRSxFQUFFLENBQUMsRUFBRSxFQUFFLENBQUMsRUFBRSxLQUFLLE1BQU0sQ0FBQyxRQUFRLENBQUMsRUFBRSxDQUFDLENBQUM7WUFDOUUsQ0FBQyxDQUFDLE1BQU0sQ0FBQyxPQUFPLENBQUMsZUFBZSxDQUFDLENBQUMsSUFBSSxDQUFDLENBQUMsQ0FBQyxTQUFTLENBQUMsRUFBRSxFQUFFLENBQUMsU0FBUyxLQUFLLFFBQVEsQ0FBQyxDQUFDO0lBQ3RGLElBQUksQ0FBQyxLQUFLLEVBQUUsQ0FBQztRQUNYLE1BQU0sSUFBSSxLQUFLLENBQUMsbUJBQW1CLElBQUksQ0FBQyxTQUFTLENBQUMsUUFBUSxDQUFDLFlBQVksQ0FBQyxDQUFDO0lBQzNFLENBQUM7SUFDRCxNQUFNLENBQUMsSUFBSSxFQUFFLEVBQUUsQ0FBQyxHQUFHLEtBQUssQ0FBQztJQUN6QixPQUFPLEVBQUUsSUFBSSxFQUFFLElBQTBCLEVBQUUsRUFBRSxFQUFFLENBQUM7QUFDbEQsQ0FBQyJ9

package/dist/esm/encryption/encryption.d.ts

@@ -0,0 +1,119 @@
+import { Schema } from 'effect';
+import { Bytes32 } from '../binary.js';
+import { InputContext } from '../handle.js';
+export type Encryptor<S extends EncryptionScheme = EncryptionScheme> = <T extends SupportedFheType>(plaintext: PlaintextWithContextOf<S, T>) => Promise<EncryptResultOf<S, T>>;
+export type Decryptor<S extends EncryptionScheme = EncryptionScheme> = <T extends SupportedFheType>(ciphertext: CiphertextOf<S, T>, context?: InputContext) => Promise<PlaintextOf<S, T>>;
+export declare const supportedFheTypes: {
+    readonly euint64: 5;
+    readonly euint160: 7;
+    readonly euint256: 8;
+    readonly ebool: 0;
+};
+export declare const SupportedFheTypeName: Schema.SchemaClass<"ebool" | "euint64" | "euint160" | "euint256", "ebool" | "euint64" | "euint160" | "euint256", never>;
+export type SupportedFheTypeName = typeof SupportedFheTypeName.Type;
+export declare const SupportedFheType: Schema.SchemaClass<0 | 5 | 7 | 8, 0 | 5 | 7 | 8, never>;
+export type SupportedFheType = typeof SupportedFheType.Type;
+export declare const encryptionSchemes: {
+    readonly tfhe: 0;
+    readonly ecies: 1;
+    readonly cryptobox: 2;
+};
+export declare function getEncryptionSchemeName(scheme: number): string;
+export type EncryptionSchemes = typeof encryptionSchemes;
+export type EciesScheme = EncryptionSchemes['ecies'];
+export type TfheScheme = EncryptionSchemes['tfhe'];
+export type CryptoboxScheme = EncryptionSchemes['cryptobox'];
+export declare const EncryptionScheme: Schema.Literal<[0, 1, 2]>;
+export type EncryptionScheme = typeof EncryptionScheme.Type;
+type DistType<P, S extends EncryptionScheme, T extends SupportedFheType> = P extends any ? P & {
+    scheme: S;
+    type: T;
+} : never;
+export declare const ciphertextEnvelopes: {
+    readonly none: 0;
+    readonly hadu: 1;
+};
+export declare const CiphertextEnvelope: Schema.SchemaClass<0 | 1, 0 | 1, never>;
+export declare const Ciphertext: Schema.Struct<{
+    scheme: Schema.Literal<[0, 1, 2]>;
+    type: Schema.SchemaClass<0 | 5 | 7 | 8, 0 | 5 | 7 | 8, never>;
+    value: Schema.TemplateLiteral<`0x${string}`>;
+    envelope: Schema.optional<Schema.SchemaClass<0 | 1, 0 | 1, never>>;
+}>;
+export type Ciphertext = typeof Ciphertext.Type;
+export type CiphertextOf<S extends EncryptionScheme, T extends SupportedFheType> = DistType<Ciphertext, S, T>;
+export declare const CiphertextWithContext: Schema.Struct<{
+    ciphertext: Schema.Struct<{
+        scheme: Schema.Literal<[0, 1, 2]>;
+        type: Schema.SchemaClass<0 | 5 | 7 | 8, 0 | 5 | 7 | 8, never>;
+        value: Schema.TemplateLiteral<`0x${string}`>;
+        envelope: Schema.optional<Schema.SchemaClass<0 | 1, 0 | 1, never>>;
+    }>;
+    context: Schema.Struct<{
+        hostChainId: typeof Schema.BigInt;
+        aclAddress: Schema.TemplateLiteral<`0x${string}`>;
+        userAddress: Schema.TemplateLiteral<`0x${string}`>;
+        contractAddress: Schema.TemplateLiteral<`0x${string}`>;
+    }>;
+}>;
+export type CiphertextWithContext = typeof CiphertextWithContext.Type;
+export type CiphertextWithContextOf<S extends EncryptionScheme, T extends SupportedFheType> = CiphertextWithContext & {
+    ciphertext: CiphertextOf<S, T>;
+};
+export declare const EncryptResult: Schema.Struct<{
+    ciphertext: Schema.Struct<{
+        scheme: Schema.Literal<[0, 1, 2]>;
+        type: Schema.SchemaClass<0 | 5 | 7 | 8, 0 | 5 | 7 | 8, never>;
+        value: Schema.TemplateLiteral<`0x${string}`>;
+        envelope: Schema.optional<Schema.SchemaClass<0 | 1, 0 | 1, never>>;
+    }>;
+    context: Schema.Struct<{
+        hostChainId: typeof Schema.BigInt;
+        aclAddress: Schema.TemplateLiteral<`0x${string}`>;
+        userAddress: Schema.TemplateLiteral<`0x${string}`>;
+        contractAddress: Schema.TemplateLiteral<`0x${string}`>;
+    }>;
+    prehandle: Schema.brand<Schema.filter<Schema.transformOrFail<Schema.Union<[typeof Schema.String, Schema.refine<object & Uint8Array<ArrayBufferLike>, Schema.Schema<object, object, never>>]>, Schema.TemplateLiteral<`0x${string}`>, never>>, "Bytes32">;
+    handle: Schema.brand<Schema.filter<Schema.transformOrFail<Schema.Union<[typeof Schema.String, Schema.refine<object & Uint8Array<ArrayBufferLike>, Schema.Schema<object, object, never>>]>, Schema.TemplateLiteral<`0x${string}`>, never>>, "Bytes32">;
+}>;
+export type EncryptResult = typeof EncryptResult.Type;
+export type EncryptResultOf<S extends EncryptionScheme, T extends SupportedFheType> = EncryptResult & {
+    ciphertext: CiphertextOf<S, T>;
+};
+export declare const Plaintext: Schema.Union<[Schema.Struct<{
+    scheme: Schema.Literal<[0, 1, 2]>;
+    type: Schema.Literal<[5, 7, 8]>;
+    value: typeof Schema.BigInt;
+}>, Schema.Struct<{
+    scheme: Schema.Literal<[0, 1, 2]>;
+    type: Schema.Literal<[0]>;
+    value: typeof Schema.Boolean;
+}>]>;
+export type Plaintext = typeof Plaintext.Type;
+export type PlaintextOf<S extends EncryptionScheme, T extends SupportedFheType> = DistType<Plaintext, S, T>;
+export declare const PlaintextWithContext: Schema.Struct<{
+    plaintext: Schema.Union<[Schema.Struct<{
+        scheme: Schema.Literal<[0, 1, 2]>;
+        type: Schema.Literal<[5, 7, 8]>;
+        value: typeof Schema.BigInt;
+    }>, Schema.Struct<{
+        scheme: Schema.Literal<[0, 1, 2]>;
+        type: Schema.Literal<[0]>;
+        value: typeof Schema.Boolean;
+    }>]>;
+    context: Schema.Struct<{
+        hostChainId: typeof Schema.BigInt;
+        aclAddress: Schema.TemplateLiteral<`0x${string}`>;
+        userAddress: Schema.TemplateLiteral<`0x${string}`>;
+        contractAddress: Schema.TemplateLiteral<`0x${string}`>;
+    }>;
+}>;
+export type PlaintextWithContext = typeof PlaintextWithContext.Type;
+export type PlaintextWithContextOf<S extends EncryptionScheme, T extends SupportedFheType> = PlaintextWithContext & {
+    plaintext: PlaintextOf<S, T>;
+};
+export declare function bigintToPlaintext<S extends EncryptionScheme, T extends SupportedFheType>(scheme: S, type: T, bigPt: bigint): PlaintextOf<S, T>;
+export declare function plaintextToBigint(plaintext: Plaintext): bigint;
+export declare function plaintextToBytes32(plaintext: Plaintext): Bytes32;
+export declare function bytes32ToPlaintext(plaintext: Bytes32, scheme: EncryptionScheme, type: SupportedFheType): Plaintext;
+export {};

package/dist/esm/encryption/encryption.js

@@ -0,0 +1,101 @@
+import { Schema } from 'effect';
+import { bigintToBytes32, Bytes32, HexString } from '../binary.js';
+import { handleTypes, InputContext } from '../handle.js';
+export const supportedFheTypes = {
+    euint64: handleTypes.euint64,
+    euint160: handleTypes.euint160,
+    euint256: handleTypes.euint256,
+    ebool: handleTypes.ebool,
+};
+const supportedFheTypeNames = Object.keys(supportedFheTypes);
+export const SupportedFheTypeName = Schema.Literal(...supportedFheTypeNames);
+// TODO: extend to all types
+export const SupportedFheType = Schema.Literal(...Object.values(supportedFheTypes));
+export const encryptionSchemes = {
+    tfhe: 0,
+    ecies: 1,
+    cryptobox: 2,
+};
+export function getEncryptionSchemeName(scheme) {
+    switch (scheme) {
+        case encryptionSchemes.tfhe:
+            return 'TFHE';
+        case encryptionSchemes.ecies:
+            return 'ECIES';
+        case encryptionSchemes.cryptobox:
+            return 'NACLCryptoBox';
+        default:
+            throw new Error(`Unknown encryption scheme: ${scheme}`);
+    }
+}
+export const EncryptionScheme = Schema.Literal(encryptionSchemes.tfhe, encryptionSchemes.ecies, encryptionSchemes.cryptobox);
+export const ciphertextEnvelopes = {
+    none: 0,
+    hadu: 1,
+};
+export const CiphertextEnvelope = Schema.Literal(...Object.values(ciphertextEnvelopes));
+export const Ciphertext = Schema.Struct({
+    scheme: EncryptionScheme,
+    type: SupportedFheType,
+    value: HexString,
+    envelope: Schema.optional(CiphertextEnvelope),
+});
+export const CiphertextWithContext = Schema.Struct({
+    ciphertext: Ciphertext,
+    context: InputContext,
+});
+export const EncryptResult = Schema.Struct({
+    ciphertext: Ciphertext,
+    context: InputContext,
+    prehandle: Bytes32,
+    handle: Bytes32,
+});
+export const Plaintext = Schema.Union(Schema.Struct({
+    scheme: EncryptionScheme,
+    type: Schema.Literal(handleTypes.euint64, handleTypes.euint160, handleTypes.euint256),
+    value: Schema.BigInt,
+}), Schema.Struct({
+    scheme: EncryptionScheme,
+    type: Schema.Literal(handleTypes.ebool),
+    value: Schema.Boolean,
+}));
+export const PlaintextWithContext = Schema.Struct({
+    plaintext: Plaintext,
+    context: InputContext,
+});
+export function bigintToPlaintext(scheme, type, bigPt) {
+    switch (type) {
+        case handleTypes.euint64:
+        case handleTypes.euint160:
+        case handleTypes.euint256:
+            return {
+                scheme,
+                type,
+                value: bigPt,
+            };
+        case handleTypes.ebool:
+            return {
+                scheme,
+                type,
+                value: bigPt !== 0n,
+            };
+    }
+    throw new Error(`Unsupported FHE type: ${type}`);
+}
+export function plaintextToBigint(plaintext) {
+    switch (plaintext.type) {
+        case handleTypes.euint64:
+        case handleTypes.euint160:
+        case handleTypes.euint256:
+            return plaintext.value;
+        case handleTypes.ebool:
+            return plaintext.value ? 1n : 0n;
+    }
+}
+export function plaintextToBytes32(plaintext) {
+    return bigintToBytes32(plaintextToBigint(plaintext));
+}
+export function bytes32ToPlaintext(plaintext, scheme, type) {
+    return bigintToPlaintext(scheme, type, BigInt(plaintext));
+}
+//# sourceMappingURL=data:application/json;base64,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

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

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

package/dist/esm/encryption/index.js

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

package/dist/esm/fhevm/fhe-environment.d.ts

@@ -0,0 +1,9 @@
+import { Chainish } from '../chain.js';
+export type Address = `0x${string}`;
+export type FheEnvironment = {
+    aclAddress: Address;
+    thfeExecutorAddress: Address;
+    gatewayAddress: Address;
+    kmsVerifierAddress: Address;
+};
+export declare function getFheEnvironment(chainId: Chainish): FheEnvironment;

package/dist/esm/fhevm/fhe-environment.js

@@ -0,0 +1,8 @@
+// Avoid inporting any other dependencies in this file to avoid serialisation issues downstream in infracto
+import { getSupportedChain } from '../chain.js';
+import { FHEEnvironments } from '../generated/fhe-environments.js';
+export function getFheEnvironment(chainId) {
+    const supportedChain = getSupportedChain(chainId);
+    return FHEEnvironments[supportedChain.name];
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZmhlLWVudmlyb25tZW50LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL2ZoZXZtL2ZoZS1lbnZpcm9ubWVudC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSwyR0FBMkc7QUFDM0csT0FBTyxFQUFnQyxpQkFBaUIsRUFBRSxNQUFNLGFBQWEsQ0FBQztBQUM5RSxPQUFPLEVBQUUsZUFBZSxFQUFFLE1BQU0sa0NBQWtDLENBQUM7QUFhbkUsTUFBTSxVQUFVLGlCQUFpQixDQUFDLE9BQWlCO0lBQ2pELE1BQU0sY0FBYyxHQUFHLGlCQUFpQixDQUFDLE9BQU8sQ0FBQyxDQUFDO0lBQ2xELE9BQU8sZUFBZSxDQUFDLGNBQWMsQ0FBQyxJQUF1QyxDQUFDLENBQUM7QUFDakYsQ0FBQyJ9

package/dist/esm/fhevm/fhevm.d.ts

@@ -0,0 +1,41 @@
+import { Account, Chain, PublicClient, TransactionReceipt, Transport, WalletClient } from 'viem';
+import { SupportedChain } from '../chain.js';
+export type PublicWalletClient = {
+    public: PublicClient<Transport, Chain, Account>;
+    wallet: WalletClient<Transport, Chain, Account>;
+};
+export declare function createPublicWalletClient({ account, hostChainRpcUrl, chain, }: {
+    account: Account;
+    hostChainRpcUrl: string;
+    chain: Chain;
+}): PublicWalletClient;
+export declare function getFhevmDeployerClient({ deployer, hostChainRpcUrl, chain, }: {
+    deployer: Account;
+    hostChainRpcUrl: string;
+    chain: SupportedChain;
+}): PublicWalletClient;
+export type PrivateKeys = {
+    relayer: string;
+    kmsSigner: string;
+    deployer: string;
+};
+export type HostChainConfig = {
+    privateKeys: PrivateKeys;
+    rpcUrl: string;
+};
+export declare function configureFhevmContracts({ chain, hostChain: { privateKeys, rpcUrl }, }: {
+    hostChain: HostChainConfig;
+    chain: SupportedChain;
+}): Promise<{
+    addRelayerTxReceipt: TransactionReceipt | null;
+    addKmsSignerTxReceipt: TransactionReceipt | null;
+}>;
+export type L1Config = {
+    cometRpcEndpoint: string;
+    mnemonic: string;
+    grpcEndpoint: string;
+};
+export declare function ensureFheEnvironmentRegistered({ l1, chain, }: {
+    l1: L1Config;
+    chain: SupportedChain;
+}): Promise<void>;

package/dist/esm/fhevm/fhevm.js

@@ -0,0 +1,139 @@
+import { createClient } from '@connectrpc/connect';
+import { createGrpcTransport } from '@connectrpc/connect-node';
+import { createPublicClient, createWalletClient, getContract, http, } from 'viem';
+import { privateKeyToAccount } from 'viem/accounts';
+import * as chains from 'viem/chains';
+import { normaliseToHex } from '../binary.js';
+import { gatewayContractAbi, kmsVerifierAbi } from '../generated/abis/inco-fhevm.js';
+import { Query } from '../generated/es/inco/fhe/v1/query_pb.js';
+import { createL1Client, createL1Wallet } from '../l1/index.js';
+import { getFheEnvironment } from './fhe-environment.js';
+// Create a public and wallet client for the given chain.
+export function createPublicWalletClient({ account, hostChainRpcUrl, chain, }) {
+    const transport = http(hostChainRpcUrl);
+    const publicClient = createPublicClient({
+        chain,
+        transport,
+    });
+    // const privateKey = await shell("cast wallet private-key --account sepolia_deployer --password ''");
+    // const account = privateKeyToAccount(mustBeHex(privateKey));
+    const walletClient = createWalletClient({
+        chain,
+        transport,
+        account,
+    });
+    return { public: publicClient, wallet: walletClient };
+}
+export function getFhevmDeployerClient({ deployer, hostChainRpcUrl, chain, }) {
+    const viemChain = getViemChain(chain.id);
+    const transport = http(hostChainRpcUrl);
+    const publicClient = createPublicClient({
+        chain: viemChain,
+        transport,
+    });
+    // const privateKey = await shell("cast wallet private-key --account sepolia_deployer --password ''");
+    // const account = privateKeyToAccount(mustBeHex(privateKey));
+    const walletClient = createWalletClient({
+        chain: viemChain,
+        transport,
+        account: deployer,
+    });
+    return { public: publicClient, wallet: walletClient };
+}
+export async function configureFhevmContracts({ chain, hostChain: { privateKeys, rpcUrl }, }) {
+    const deployer = privateKeyToAccount(normaliseToHex(privateKeys.deployer));
+    const relayer = privateKeyToAccount(normaliseToHex(privateKeys.relayer));
+    const kmsSigner = privateKeyToAccount(normaliseToHex(privateKeys.kmsSigner));
+    console.log(`Configuring FHE environment contracts on ${chain.name} with deployer ${deployer.address}, relayer ${relayer.address}, and KMS signer ${kmsSigner.address}...`);
+    const client = getFhevmDeployerClient({
+        hostChainRpcUrl: rpcUrl,
+        deployer,
+        chain,
+    });
+    const { gatewayAddress, kmsVerifierAddress } = getFheEnvironment(chain.id);
+    const gateway = getContract({
+        address: gatewayAddress,
+        abi: gatewayContractAbi,
+        client,
+    });
+    const kmsVerifier = getContract({
+        address: kmsVerifierAddress,
+        abi: kmsVerifierAbi,
+        client,
+    });
+    console.log(`Adding relayer ${relayer.address}...`);
+    let addRelayerTxReceipt = null;
+    let addKmsSignerTxReceipt = null;
+    const ErrAlreadyRelayer = 'Address is already relayer';
+    try {
+        const addRelayerTxHash = await gateway.write.addRelayer([relayer.address]);
+        addRelayerTxReceipt = await client.public.waitForTransactionReceipt({
+            hash: addRelayerTxHash,
+        });
+    }
+    catch (err) {
+        if (!err.message.includes(ErrAlreadyRelayer)) {
+            throw err;
+        }
+        console.log(`Relayer ${relayer.address} already added`);
+    }
+    console.log(`Adding KMS signer ${kmsSigner.address}...`);
+    const ErrAlreadySigner = 'Address is already a signer';
+    try {
+        const addKmsSignerTxHash = await kmsVerifier.write.addSigner([kmsSigner.address]);
+        addKmsSignerTxReceipt = await client.public.waitForTransactionReceipt({
+            hash: addKmsSignerTxHash,
+        });
+    }
+    catch (err) {
+        if (!err.message.includes(ErrAlreadySigner)) {
+            throw err;
+        }
+        console.log(`KMS signer ${kmsSigner.address} already added`);
+    }
+    return { addRelayerTxReceipt, addKmsSignerTxReceipt };
+}
+// Attempts to ensure the given Inco L1 has the FHE environment for the given chain/ACL registered.
+// based extracting from logs.
+export async function ensureFheEnvironmentRegistered({ l1, chain, }) {
+    console.log(`Ensuring FHE environment is registered on ${l1.grpcEndpoint} ...`);
+    const { aclAddress } = getFheEnvironment(chain.id);
+    const wallet = await createL1Wallet(l1.mnemonic);
+    const signingClient = await createL1Client({
+        cometRpcEndpoint: l1.cometRpcEndpoint,
+        grpcEndpoint: l1.grpcEndpoint,
+        wallet,
+    });
+    const transport = createGrpcTransport({ baseUrl: l1.grpcEndpoint });
+    const queryClient = createClient(Query, transport);
+    const [signingAccount] = await wallet.getAccounts();
+    const fheEnvArg = {
+        keysetId: aclAddress.slice(2),
+        hostChainId: `evm/${chain.id}`,
+        accessControl: undefined,
+    };
+    const NotFoundErrorMessage = 'collections: not found';
+    try {
+        const { fheEnv } = await queryClient.fheEnv(fheEnvArg);
+        console.log(`FHE environment already registered on ${chain.id} using ACL ${aclAddress} : ${JSON.stringify(fheEnv)} `);
+    }
+    catch (err) {
+        if (String(err).includes(NotFoundErrorMessage)) {
+            const tx = await signingClient.sendTx(signingAccount.address, '/inco.fhe.v1.MsgAddFheEnv', {
+                fheEnv: fheEnvArg,
+                authority: signingAccount.address,
+            });
+            console.log(tx);
+            return;
+        }
+        throw err;
+    }
+}
+function getViemChain(chainId) {
+    const found = Object.values(chains).find((chain) => chain.id === chainId);
+    if (!found) {
+        throw new Error(`could not find chain with id ${chainId}`);
+    }
+    return found;
+}
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1 @@
+export * from './fhe-environment.js';

package/dist/esm/fhevm/index.js

@@ -0,0 +1,2 @@
+export * from './fhe-environment.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvZmhldm0vaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxzQkFBc0IsQ0FBQyJ9

package/dist/esm/fhevm/reencrypt.d.ts

@@ -0,0 +1,20 @@
+import { Account, Address, Chain, Transport, WalletClient } from 'viem';
+import { CryptoboxScheme } from '../encryption/encryption.js';
+import type { Reencryptor, ReencryptorArgs } from '../reencryption/index.js';
+import type { PubKeyEncodable } from '../reencryption/types.js';
+export interface EphemeralCryptoBoxKeypair extends PubKeyEncodable {
+    scheme: CryptoboxScheme;
+    publicKey: Uint8Array;
+    privateKey: Uint8Array;
+}
+export interface ZamaReencryptorArgs extends ReencryptorArgs {
+    gatewayUrl: string;
+    unsafeSkipVerifyKMSSignatures?: boolean;
+    walletClient: WalletClient<Transport, Chain, Account>;
+    contractAddress: Address;
+    chainId: bigint;
+    kmsSigners: Address[];
+    userAddress: Address;
+}
+export declare function zamaReencryptor({ chainId, gatewayUrl, walletClient, unsafeSkipVerifyKMSSignatures, contractAddress, kmsSigners, userAddress, }: ZamaReencryptorArgs): Promise<Reencryptor<CryptoboxScheme>>;
+export declare function generateCryptoBoxEphemeralKeyPair(): EphemeralCryptoBoxKeypair;

package/dist/esm/fhevm/reencrypt.js

@@ -0,0 +1,123 @@
+import { Schema } from 'effect';
+import { cryptobox_get_pk, cryptobox_keygen, cryptobox_pk_to_u8vec, cryptobox_sk_to_u8vec, new_client, process_reencryption_resp_from_js, u8vec_to_cryptobox_pk, u8vec_to_cryptobox_sk, } from 'node-tkms';
+import { getAddress, hexToBigInt } from 'viem';
+import { bytesToBigInt, bytesToHex } from '../binary.js';
+import { bigintToPlaintext, encryptionSchemes, } from '../encryption/encryption.js';
+import { getHandleType } from '../handle.js';
+import { createEIP712Payload } from '../reencryption/index.js';
+import { parse } from '../schema.js';
+// The domain constants that Zama uses for reencrypts.
+const ZAMA_REENCRYPT_DOMAIN = {
+    name: 'Authorization token',
+    version: '1',
+    salt: undefined,
+};
+export async function zamaReencryptor({ chainId, gatewayUrl, walletClient, unsafeSkipVerifyKMSSignatures, contractAddress, kmsSigners, userAddress, }) {
+    const ephemeralKeypair = generateCryptoBoxEphemeralKeyPair();
+    // Sign the EIP712 attesting that the user has access to the private key
+    // corresponding to the ephemeral public key.
+    const eip712Payload = createEIP712Payload({
+        chainId,
+        primaryType: 'ReencryptionRequest',
+        primaryTypeFields: [{ name: 'publicKey', type: 'bytes' }],
+        message: {
+            publicKey: bytesToHex(ephemeralKeypair.encodePublicKey()),
+        },
+        domainName: ZAMA_REENCRYPT_DOMAIN.name,
+        domainVersion: ZAMA_REENCRYPT_DOMAIN.version,
+    });
+    // Using browser extensions, this step will prompt the user to sign the
+    // payload.
+    const eip712Signature = await walletClient.signTypedData(eip712Payload);
+    return async function reencrypt({ handle, }) {
+        const handleBigInt = hexToBigInt(handle);
+        const reencryptRequest = {
+            signature: eip712Signature.replace(/^(0x)/, ''),
+            client_address: getAddress(userAddress),
+            enc_key: bytesToHex(ephemeralKeypair.encodePublicKey()).replace(/^(0x)/, ''),
+            ciphertext_handle: handleBigInt.toString(16).padStart(64, '0'),
+            eip712_verifying_contract: getAddress(contractAddress),
+        };
+        const reencryptResponse = await makeReencryptRequest(reencryptRequest, gatewayUrl);
+        let pubKey;
+        let privKey;
+        try {
+            pubKey = u8vec_to_cryptobox_pk(ephemeralKeypair.publicKey);
+            privKey = u8vec_to_cryptobox_sk(ephemeralKeypair.privateKey);
+        }
+        catch (e) {
+            throw new Error(`Invalid public or private key: ${JSON.stringify(e)}`);
+        }
+        const client = new_client(kmsSigners, userAddress, 'default');
+        try {
+            const buffer = new ArrayBuffer(32);
+            const view = new DataView(buffer);
+            view.setUint32(28, Number(chainId), false);
+            const chainIdArrayBE = new Uint8Array(buffer);
+            // Duplicate reencryptRequest and replace ciphertext_handle with ciphertext_digest.
+            const { ciphertext_handle, ...p } = reencryptRequest;
+            // TODO (from Zama): check all ciphertext digests are all the same
+            const payloadForVerification = {
+                ...p,
+                ciphertext_digest: reencryptResponse.response[0].ciphertext_digest,
+            };
+            const decrypted = process_reencryption_resp_from_js(client, payloadForVerification, {
+                name: eip712Payload.domain.name,
+                version: eip712Payload.domain.version,
+                chain_id: chainIdArrayBE,
+                verifying_contract: eip712Payload.domain.verifyingContract,
+            }, reencryptResponse.response, pubKey, privKey, !unsafeSkipVerifyKMSSignatures);
+            return bigintToPlaintext(encryptionSchemes.cryptobox, getHandleType(handle), bytesToBigInt(decrypted));
+        }
+        catch (e) {
+            console.error(e);
+            throw new Error(`An error occurred during decryption: ${e}`);
+        }
+    };
+}
+// Generate a new ephemeral keypair for reencryption.
+export function generateCryptoBoxEphemeralKeyPair() {
+    const keypair = cryptobox_keygen();
+    const publicKey = cryptobox_pk_to_u8vec(cryptobox_get_pk(keypair));
+    return {
+        scheme: encryptionSchemes.cryptobox,
+        publicKey,
+        privateKey: cryptobox_sk_to_u8vec(keypair),
+        encodePublicKey() {
+            return publicKey;
+        },
+    };
+}
+// This is the response type of the reencrypt endpoint, defined on the
+// server-side in Zama's gateway. The response field is a vector of this struct
+// in Rust:
+// https://github.com/zama-ai/kms-core/blob/a3b824b389e87429d04537696e28dee902a3b2d9/blockchain/events/src/kms.rs#L985-L1003
+const ZamaGatewayReencryptResponse = Schema.Struct({
+    status: Schema.Union(Schema.Literal('success'), Schema.Literal('failure')),
+    response: Schema.Array(Schema.Struct({
+        ciphertext_digest: Schema.optional(Schema.String),
+        payload: Schema.String,
+        signature: Schema.String,
+    })),
+});
+// Make a HTTP request to the reencrypt endpoint of the gateway.
+async function makeReencryptRequest(request, gatewayUrl) {
+    const fetchOptions = {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/json',
+        },
+        body: JSON.stringify(request),
+    };
+    const response = await fetch(`${gatewayUrl}/reencrypt`, fetchOptions);
+    if (!response.ok) {
+        throw new Error(`Reencrypt failed: gateway respond with HTTP code ${response.status}: ${JSON.stringify(await response.json())}`);
+    }
+    const json = await response.json();
+    const reencryptResponse = parse(ZamaGatewayReencryptResponse, json);
+    if (reencryptResponse.status === 'failure') {
+        throw new Error('Reencrypt failed: gateway responded with failure');
+    }
+    return reencryptResponse;
+}
+//# sourceMappingURL=data:application/json;base64,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