@inco/js 0.2.16 → 0.3.0

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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

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

@@ -0,0 +1,74 @@
+import { RustType } from 'bincode-ts';
+import { Schema } from 'effect';
+import { CompactPkePublicParams, TfheCompactPublicKey } from 'node-tfhe';
+import { Decryptor, Encryptor, Plaintext, TfheScheme } from '../encryption/encryption.js';
+export declare const SERIALIZED_SIZE_LIMIT_CIPHERTEXT: bigint;
+export declare const SERIALIZED_SIZE_LIMIT_PK: bigint;
+export declare const SERIALIZED_SIZE_LIMIT_CRS: bigint;
+export type TfheEncryptorArgs = {
+    scheme: TfheScheme;
+    publicKey: Buffer;
+    crs2048: Buffer;
+};
+export type TfheDecryptorArgs = {
+    scheme: TfheScheme;
+    cks: Buffer;
+};
+export type PublicParams<T = CompactPkePublicParams> = {
+    [key in EncryptionTypes]?: {
+        publicParams: T;
+    };
+};
+export declare const ENCRYPTION_TYPES: {
+    1: number;
+    4: number;
+    8: number;
+    16: number;
+    32: number;
+    64: number;
+    128: number;
+    160: number;
+    256: number;
+    512: number;
+    1024: number;
+    2048: number;
+};
+export type EncryptionTypes = keyof typeof ENCRYPTION_TYPES;
+export type ZKInput = {
+    addBool: (value: boolean) => ZKInput;
+    add4: (value: number | bigint) => ZKInput;
+    add8: (value: number | bigint) => ZKInput;
+    add16: (value: number | bigint) => ZKInput;
+    add32: (value: number | bigint) => ZKInput;
+    add64: (value: number | bigint) => ZKInput;
+    add128: (value: number | bigint) => ZKInput;
+    add256: (value: number | bigint) => ZKInput;
+    addBytes64: (value: Uint8Array) => ZKInput;
+    addBytes128: (value: Uint8Array) => ZKInput;
+    addBytes256: (value: Uint8Array) => ZKInput;
+    addAddress: (value: string) => ZKInput;
+    getBits: () => number[];
+    encrypt: () => Promise<{
+        prehandles: Uint8Array[];
+        ciphertext: Uint8Array;
+    }>;
+};
+export declare function getTfheEncryptor(args: TfheEncryptorArgs): Encryptor<TfheScheme>;
+export declare function createEncryptedInput(aclContractAddress: string, chainId: bigint, tfheCompactPublicKey: TfheCompactPublicKey, publicParams: PublicParams): (userAddress: string, contractAddress: string) => ZKInput;
+export declare function addPlaintextInput(input: ZKInput, plaintext: Plaintext): ZKInput;
+export declare function getTfheDecryptor({ cks }: TfheDecryptorArgs): Decryptor<TfheScheme>;
+export declare const SerializationHeader: RustType.Type<{
+    [x: string]: {};
+} & {
+    [x: string]: {};
+}>;
+export declare const ProvenCompactCiphertextListTypeName = "high_level_api::ProvenCompactCiphertextList";
+export declare const FheUintTypeName = "high_level_api::FheUint";
+export declare const TfheSerialisationTypeName: Schema.Literal<["high_level_api::ProvenCompactCiphertextList", "high_level_api::FheUint"]>;
+export type TfheSerialisationTypeName = typeof TfheSerialisationTypeName.Type;
+export declare const TfheSerializationHeader: Schema.Struct<{
+    header_version: typeof Schema.String;
+    name: Schema.Union<[Schema.Literal<["high_level_api::ProvenCompactCiphertextList", "high_level_api::FheUint"]>, typeof Schema.String]>;
+}>;
+export type TfheSerializationHeader = typeof TfheSerializationHeader.Type;
+export declare function decodeTfheSerializationHeader(buffer: Uint8Array): TfheSerializationHeader;