[package]
name = "tfhe"
version = "0.1.0"
edition = "2021"
readme = "../README.md"
keywords = ["fully", "homomorphic", "encryption", "fhe", "cryptography"]
homepage = "https://zama.ai/"
documentation = "https://docs.zama.ai/tfhe-rs"
repository = "https://github.com/zama-ai/tfhe-rs"
license = "BSD-3-Clause-Clear"
description = "Concrete is a fully homomorphic encryption (FHE) library that implements Zama's variant of TFHE."
build = "build.rs"
exclude = ["/docs/", "/c_api_tests/", "/CMakeLists.txt"]

# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html

[dev-dependencies]
rand = "0.7"
kolmogorov_smirnov = "1.1.0"
paste = "1.0.7"
lazy_static = { version = "1.4.0" }
criterion = "0.3.5"
doc-comment = "0.3.3"
# Used in user documentation
bincode = "1.3.3"
fs2 = { version = "0.4.3"}

[build-dependencies]
cbindgen = { version = "0.24.3", optional = true }

[dependencies]
concrete-csprng = { version = "0.2.1" }
concrete-cuda = { version = "0.1.1", optional = true }
lazy_static = { version = "1.4.0", optional = true }
serde = { version = "1.0", optional = true }
rayon = { version = "1.5.0", optional = true }
bincode = { version = "1.3.3", optional = true }
concrete-fft = { version = "0.1", optional = true }
aligned-vec = "0.5"
dyn-stack = { version = "0.8", optional = true }
once_cell = "1.13"
paste = "1.0.7"
fs2 = { version = "0.4.3", optional = true }

# wasm deps
wasm-bindgen = { version = "0.2.63", features = [
    "serde-serialize",
], optional = true }
js-sys = { version = "0.3", optional = true }
console_error_panic_hook = { version = "0.1.7", optional = true }
serde-wasm-bindgen = { version = "0.4", optional = true }
getrandom = { version = "0.2.8", optional = true }

[features]
boolean = ["minimal_core_crypto_features"]
shortint = ["minimal_core_crypto_features"]
internal-keycache = ["lazy_static", "fs2"]

__c_api = ["cbindgen", "minimal_core_crypto_features"]
boolean-c-api = ["boolean", "__c_api"]
shortint-c-api = ["shortint", "__c_api"]

__wasm_api = [
    "wasm-bindgen",
    "js-sys",
    "console_error_panic_hook",
    "serde-wasm-bindgen",
    "getrandom",
    "getrandom/js",
]
boolean-client-js-wasm-api = ["boolean", "__wasm_api"]
shortint-client-js-wasm-api = ["shortint", "__wasm_api"]

cuda = ["backend_cuda"]
nightly-avx512 = ["backend_fft_nightly_avx512"]

# A pure-rust CPU backend.
backend_default = ["concrete-csprng/generator_soft"]

# An accelerated backend, using the `concrete-fft` library.
backend_fft = ["concrete-fft", "dyn-stack"]
backend_fft_serialization = [
    "bincode",
    "concrete-fft/serde",
    "aligned-vec/serde",
    "__commons_serialization",
]
backend_fft_nightly_avx512 = ["concrete-fft/nightly"]

# Enables the parallel engine in default backend.
backend_default_parallel = ["__commons_parallel"]

# Enable the x86_64 specific accelerated implementation of the random generator for the default
# backend
backend_default_generator_x86_64_aesni = [
    "concrete-csprng/generator_x86_64_aesni",
]

# Enable the aarch64 specific accelerated implementation of the random generator for the default
# backend
backend_default_generator_aarch64_aes = [
    "concrete-csprng/generator_aarch64_aes",
]

# Enable the serialization engine in the default backend.
backend_default_serialization = ["bincode", "__commons_serialization"]

# A GPU backend, relying on Cuda acceleration
backend_cuda = ["concrete-cuda"]

# Private features
__profiling = []
__private_docs = []
__commons_parallel = ["rayon", "concrete-csprng/parallel"]
__commons_serialization = ["serde", "serde/derive"]

seeder_unix = ["concrete-csprng/seeder_unix"]
seeder_x86_64_rdseed = ["concrete-csprng/seeder_x86_64_rdseed"]

minimal_core_crypto_features = [
    "backend_default",
    "backend_default_parallel",
    "backend_default_serialization",
    "backend_fft",
    "backend_fft_serialization",
]

# These target_arch features enable a set of public features for concrete-core if users want a known
# good/working configuration for concrete-core.
# For a target_arch that does not yet have such a feature, one can still enable features manually or
# create a feature for said target_arch to make its use simpler.
x86_64 = [
    "minimal_core_crypto_features",
    "backend_default_generator_x86_64_aesni",
    "seeder_x86_64_rdseed",
]
x86_64-unix = ["x86_64", "seeder_unix"]

# CUDA builds are Unix only at the moment
x86_64-unix-cuda = ["x86_64-unix", "cuda"]

aarch64 = [
    "minimal_core_crypto_features",
    "backend_default_generator_aarch64_aes",
]
aarch64-unix = ["aarch64", "seeder_unix"]

[package.metadata.docs.rs]
# TODO: manage builds for docs.rs based on their documentation https://docs.rs/about
features = ["x86_64-unix", "boolean", "shortint"]
rustdoc-args = ["--html-in-header", "katex-header.html"]

###########
#         #
# Benches #
#         #
###########

[[bench]]
name = "boolean-bench"
path = "benches/boolean/bench.rs"
harness = false
required-features = ["boolean", "internal-keycache"]

[[bench]]
name = "shortint-bench"
path = "benches/shortint/bench.rs"
harness = false
required-features = ["shortint", "internal-keycache"]

[[example]]
name = "generates_test_keys"
required-features = ["shortint", "internal-keycache"]

[[example]]
name = "micro_bench_and"
required-features = ["boolean"]

[lib]
crate-type = ["lib", "staticlib", "cdylib"]