Full Code of zama-ai/fhevm for AI

gitextract_e6fiq0a2/

├── .commitlintrc.json
├── .dockerignore
├── .github/
│   ├── CODEOWNERS
│   ├── CONTRIBUTING.md
│   ├── ISSUE_TEMPLATE/
│   │   ├── config.yml
│   │   ├── documentation-issue.md
│   │   ├── gateway_contracts_issue.yml
│   │   └── general_issue.yml
│   ├── actionlint.yaml
│   ├── actions/
│   │   └── gpu_setup/
│   │       └── action.yml
│   ├── config/
│   │   ├── commitlint.config.js
│   │   └── ct.yaml
│   ├── dependabot.yml
│   ├── hooks/
│   │   ├── commit-msg
│   │   ├── install.sh
│   │   └── pre-push
│   ├── release.yml
│   ├── squid/
│   │   └── sandbox-proxy-rules.conf
│   └── workflows/
│       ├── charts-helm-checks.yml
│       ├── charts-helm-release.yml
│       ├── check-changes-for-docker-build.yml
│       ├── claude-review.yml
│       ├── codeql.yml
│       ├── common-pull-request-lint.yml
│       ├── common-typos-check.yml
│       ├── contracts-upgrade-version-check.yml
│       ├── coprocessor-benchmark-cpu.yml
│       ├── coprocessor-benchmark-gpu.yml
│       ├── coprocessor-cargo-clippy.yml
│       ├── coprocessor-cargo-fmt.yml
│       ├── coprocessor-cargo-tests.yml
│       ├── coprocessor-dependency-analysis.yml
│       ├── coprocessor-docker-build.yml
│       ├── coprocessor-gpu-tests.yml
│       ├── coprocessor-stress-test-tool-docker-build.yml
│       ├── gateway-contracts-deployment-tests.yml
│       ├── gateway-contracts-docker-build.yml
│       ├── gateway-contracts-hardhat-tests.yml
│       ├── gateway-contracts-integrity-checks.yml
│       ├── gateway-contracts-upgrade-tests.yml
│       ├── gateway-stress-tool-docker-build.yml
│       ├── golden-container-images-docker-build-nodejs.yml
│       ├── golden-container-images-docker-build-rust.yml
│       ├── host-contracts-docker-build.yml
│       ├── host-contracts-docker-deployment-tests.yml
│       ├── host-contracts-hardhat-forge-tests.yml
│       ├── host-contracts-integrity-checks.yml
│       ├── host-contracts-publish.yml
│       ├── host-contracts-slither-analysis.yml
│       ├── host-contracts-upgrade-tests.yml
│       ├── is-latest-commit.yml
│       ├── kms-connector-dependency-analysis.yml
│       ├── kms-connector-docker-build.yml
│       ├── kms-connector-tests.yml
│       ├── library-solidity-publish.yml
│       ├── library-solidity-tests.yml
│       ├── re-tag-docker-image.yml
│       ├── sdk-rust-sdk-tests.yml
│       ├── test-suite-docker-build.yml
│       ├── test-suite-e2e-operators-tests.yml
│       ├── test-suite-e2e-tests.yml
│       ├── test-suite-orchestrate-e2e-tests.yml
│       └── unverified_prs.yml
├── .gitignore
├── .hadolint.yaml
├── .linkspector.yml
├── .mergify.yml
├── .npmrc
├── .prettierignore
├── .prettierrc.yml
├── .slither.config.json
├── CODE_OF_CONDUCT.md
├── LICENSE
├── README.md
├── SECURITY.md
├── charts/
│   ├── anvil-node/
│   │   ├── Chart.yaml
│   │   ├── templates/
│   │   │   ├── anvil-service.yaml
│   │   │   └── anvil-statefulset.yaml
│   │   └── values.yaml
│   ├── contracts/
│   │   ├── Chart.yaml
│   │   ├── templates/
│   │   │   ├── _helpers.tpl
│   │   │   ├── sc-deploy-config.yaml
│   │   │   ├── sc-deploy-job.yaml
│   │   │   ├── sc-deploy-pvc.yaml
│   │   │   └── sc-deploy-statefulset.yaml
│   │   ├── values-deploy-protocol-payment.yaml
│   │   ├── values-kmsgen.yaml
│   │   ├── values-ownership.yaml
│   │   └── values.yaml
│   ├── coprocessor/
│   │   ├── Chart.yaml
│   │   ├── templates/
│   │   │   ├── _helpers.tpl
│   │   │   ├── coprocessor-db-migration.yaml
│   │   │   ├── coprocessor-gw-listener-deployment.yaml
│   │   │   ├── coprocessor-gw-listener-service-monitor.yaml
│   │   │   ├── coprocessor-gw-listener-service.yaml
│   │   │   ├── coprocessor-host-listener-catchup-only-deployment.yaml
│   │   │   ├── coprocessor-host-listener-catchup-only-service-monitor.yaml
│   │   │   ├── coprocessor-host-listener-catchup-only-service.yaml
│   │   │   ├── coprocessor-host-listener-deployment.yaml
│   │   │   ├── coprocessor-host-listener-poller-deployment.yaml
│   │   │   ├── coprocessor-host-listener-poller-service-monitor.yaml
│   │   │   ├── coprocessor-host-listener-poller-service.yaml
│   │   │   ├── coprocessor-host-listener-service-monitor.yaml
│   │   │   ├── coprocessor-host-listener-service.yaml
│   │   │   ├── coprocessor-init-config.yaml
│   │   │   ├── coprocessor-init-job.yaml
│   │   │   ├── coprocessor-sns-worker-deployment.yaml
│   │   │   ├── coprocessor-sns-worker-hpa.yaml
│   │   │   ├── coprocessor-sns-worker-service-monitor.yaml
│   │   │   ├── coprocessor-sns-worker-service.yaml
│   │   │   ├── coprocessor-tfhe-worker-deployment.yaml
│   │   │   ├── coprocessor-tfhe-worker-hpa.yaml
│   │   │   ├── coprocessor-tfhe-worker-service-monitor.yaml
│   │   │   ├── coprocessor-tfhe-worker-service.yaml
│   │   │   ├── coprocessor-tx-sender-deployment.yaml
│   │   │   ├── coprocessor-tx-sender-service-monitor.yaml
│   │   │   ├── coprocessor-tx-sender-service.yaml
│   │   │   ├── coprocessor-zkproof-worker-deployment.yaml
│   │   │   ├── coprocessor-zkproof-worker-hpa.yaml
│   │   │   ├── coprocessor-zkproof-worker-service-monitor.yaml
│   │   │   └── coprocessor-zkproof-worker-service.yaml
│   │   └── values.yaml
│   ├── coprocessor-sql-exporter/
│   │   ├── Chart.yaml
│   │   ├── config/
│   │   │   └── config.yml
│   │   ├── templates/
│   │   │   └── configmap.yaml
│   │   └── values.yaml
│   └── kms-connector/
│       ├── Chart.yaml
│       ├── README.md
│       ├── templates/
│       │   ├── _helpers.tpl
│       │   ├── kms-connector-db-migration.yaml
│       │   ├── kms-connector-gw-listener-deployment.yaml
│       │   ├── kms-connector-gw-listener-service-monitor.yaml
│       │   ├── kms-connector-gw-listener-service.yaml
│       │   ├── kms-connector-kms-worker-deployment.yaml
│       │   ├── kms-connector-kms-worker-service-monitor.yaml
│       │   ├── kms-connector-kms-worker-service.yaml
│       │   ├── kms-connector-tx-sender-deployment.yaml
│       │   ├── kms-connector-tx-sender-service-monitor.yaml
│       │   └── kms-connector-tx-sender-service.yaml
│       └── values.yaml
├── ci/
│   ├── benchmark_parser.py
│   ├── check-upgrade-versions.ts
│   ├── contracts_bindings_update.py
│   ├── ct.yaml
│   ├── local_docs_link_check.py
│   ├── merge-address-constants.ts
│   └── slab.toml
├── coprocessor/
│   ├── .dockerignore
│   ├── .gitignore
│   ├── .gitmodules
│   ├── README.md
│   ├── docs/
│   │   ├── README.md
│   │   ├── SUMMARY.md
│   │   ├── developer/
│   │   │   ├── contribute.md
│   │   │   └── roadmap.md
│   │   ├── fundamentals/
│   │   │   ├── fhevm/
│   │   │   │   ├── contracts.md
│   │   │   │   ├── coprocessor/
│   │   │   │   │   ├── architecture.md
│   │   │   │   │   └── fhe_computation.md
│   │   │   │   ├── inputs.md
│   │   │   │   ├── native/
│   │   │   │   │   ├── architecture.md
│   │   │   │   │   ├── fhe_computation.md
│   │   │   │   │   ├── genesis.md
│   │   │   │   │   └── storage.md
│   │   │   │   └── symbolic_execution.md
│   │   │   ├── gateway/
│   │   │   │   ├── asc.md
│   │   │   │   ├── decryption.md
│   │   │   │   ├── proof.md
│   │   │   │   └── reencryption.md
│   │   │   ├── glossary.md
│   │   │   ├── overview.md
│   │   │   └── tkms/
│   │   │       ├── architecture.md
│   │   │       ├── blockchain.md
│   │   │       ├── centralized.md
│   │   │       ├── threshold.md
│   │   │       └── zama.md
│   │   ├── getting_started/
│   │   │   ├── fhevm/
│   │   │   │   ├── coprocessor/
│   │   │   │   │   ├── configuration.md
│   │   │   │   │   └── coprocessor_backend.md
│   │   │   │   └── native/
│   │   │   │       ├── configuration.md
│   │   │   │       ├── executor.md
│   │   │   │       └── geth.md
│   │   │   ├── gateway/
│   │   │   │   └── configuration.md
│   │   │   ├── quick_start.md
│   │   │   └── tkms/
│   │   │       ├── contract.md
│   │   │       ├── create.md
│   │   │       ├── run.md
│   │   │       └── zama.md
│   │   ├── guides/
│   │   │   ├── benchmark.md
│   │   │   └── hardware.md
│   │   └── references/
│   │       ├── fhevm_api.md
│   │       └── gateway_api.md
│   ├── fhevm-engine/
│   │   ├── .cargo/
│   │   │   ├── audit.toml
│   │   │   └── deny.toml
│   │   ├── .gitignore
│   │   ├── .sqlx/
│   │   │   ├── query-00291bc0b863f2caf4c1f7b3fb9b07096422936f9260c363cc0b4c664c3e75fe.json
│   │   │   ├── query-0194202f1e08d10cc50aaa92568bb9bcbb219b722e4570198fd9b75d3adc9a85.json
│   │   │   ├── query-040ce7f040af75604989d052ab8ee348bd56ac4513659a03d52557e4a188f2f6.json
│   │   │   ├── query-048212909e0bbe46633e404235d2c5cffb5284903adb757b4fda59b7fbe81d57.json
│   │   │   ├── query-06757014537fbb4ab31dcfed5c16d384585a31bac9856aad1be27f3170535731.json
│   │   │   ├── query-07ca385ea31d86b52ec49b021d2fa43287fd3bc162aa1a72a2bee5779357a86a.json
│   │   │   ├── query-081a15f82a405de28992b48a0bc989e47c62f841f3c642735ce468e8ac144a2d.json
│   │   │   ├── query-0b85af1e88f24290121400feb960ef80ce040e2b877b259da17188668e6c404a.json
│   │   │   ├── query-0be7f94ac1356de126688b56b95593e80509b7834f14f39e8aed9a4f15fad410.json
│   │   │   ├── query-156dcfa2ae70e64be2eb8014928745a9c95e29d18a435f4d2e2fda2afd7952bf.json
│   │   │   ├── query-15a3e780df5acd5542cbd1457c6fd09990469c9b037a77665893ae8c4b81b119.json
│   │   │   ├── query-171a4376dcc7709a7666bc75c2eaa9b16acca30538c432072e0421bb309613ac.json
│   │   │   ├── query-18459bdad13870228dde81bea5aa060e9b723b66204c6b393f08238ee7cc7dab.json
│   │   │   ├── query-1cd9d8c3e04254eea323ca8d1d7a60645aad1364f2fd8faa861f02201a18a114.json
│   │   │   ├── query-22d4192be3d4af374ffb6b6d39b842b5d0d56e548e90b3b9387f94eb4dc17fa2.json
│   │   │   ├── query-2441dbaec5523254da542760abfe67b8e17c0cc85f0e26cca33f0b5186d940cc.json
│   │   │   ├── query-2611f503726ca2bd9cb05c62058395cf36c079ed4e0f7a9111e46e2b9a391b8c.json
│   │   │   ├── query-2637d7e49fbc45e9051a9a4b098464aec3b13a8b311e71d962b6fb173b671b09.json
│   │   │   ├── query-280922cbaa3f2c2c2893da7bc015793f752df19c8940cbc2d26c788cae901d95.json
│   │   │   ├── query-2e431116e7d3116265c42dda4fbee1b9954906485e02665c59431e4c6394d239.json
│   │   │   ├── query-355e54c5e8527ac44a96a2a1e1bf42341e9704a8bacb703eef5b3e58b6fa4ab3.json
│   │   │   ├── query-356ad05cf8677b0e561e56e0b7d5298b39471d8431093f3297da926b3f97273e.json
│   │   │   ├── query-3d26edeaf3dfe38e48b2705da13373c8bbdeee43fca309a3b94c606b42ff71e5.json
│   │   │   ├── query-41f1e1ec2e2ca8cc6fe2395105767fa28e0020847366a86cdeb18cd8db1354d7.json
│   │   │   ├── query-4348b12a11ea6fcb102d97b1979b63ac167f55188496f006abce0ee1159b6663.json
│   │   │   ├── query-455bd359a58df1cef6d001eeb2e70381328eabdfbd9d5ba39401c634d5403b79.json
│   │   │   ├── query-45f9a96fb7f0e31ee8f7d316418de59d65d1f9be75c21825f4c07a7f56e5ae4a.json
│   │   │   ├── query-49417a40d2aa74a4a9d7486417acf5c791519c9b1de680de3516e18d24b4f48e.json
│   │   │   ├── query-4a1ee26e6b481517a3ab7f6f2bb75dccd1728ef569a39d851f134a23a8b513be.json
│   │   │   ├── query-4c1cc00434e82b0ade1c67ec109630dd536452ad6faa983c426e312a41138ac9.json
│   │   │   ├── query-4dfc8d4bed4ce056b362126302fbb445a3af68b9aeaf2e84d81ff09e38384561.json
│   │   │   ├── query-4ecbf864725469e316110ddfd9c861d4b0d50363e9a4f7e359fe16e3786c08ba.json
│   │   │   ├── query-512f035677f835d138e4c40537a462f5611a0dfdd54c3198032a7e8ade4bb61d.json
│   │   │   ├── query-51b0ba894dbdd2b26c9ad13e1a5b3d4657af9aa912bbe652eabeae2959588589.json
│   │   │   ├── query-571a684cbff1241ec33dda67bd02697aa95adc548f114c5bb009248c84f304b2.json
│   │   │   ├── query-5907c37948a322cde980c602e3ebeb266827abb1f4d4484f94eb6e0565025a7f.json
│   │   │   ├── query-596dea818737c64f6d34646c47febc27968cb38e73f65b1ee98f57107b97b501.json
│   │   │   ├── query-5a4711c1d15fd6e9838a38f8c440867372d972a24d8af5fca1a97c2d3a49b1de.json
│   │   │   ├── query-5d0594aefc96b09bbfc06cc5bfee7a066b01630afec98b2a8407e05fb79466b6.json
│   │   │   ├── query-5e688c149b2b6ef8058c825005d732d7cc4de56aa53a2d9db77c0cef1766a420.json
│   │   │   ├── query-5ed3357cb17bbeb4c9c195203319d4c52c23e042141c6e4574edcf6416aaa282.json
│   │   │   ├── query-5f1777e5b74d10d99f96fe57fc6ffa5c8e6eb8f1e95384e014362c9c02edea1e.json
│   │   │   ├── query-5f1afb2747806defba9411e78f5ac62b310f53fc4f943cadbc05ae3d0d575dea.json
│   │   │   ├── query-615f86e8d30acec4a74b6f5a0a4446b1d19ec5a7f14162f27d07536bf3e68dce.json
│   │   │   ├── query-6363bd804ce2b1505b46684e17aec0d3d8760bf4cb0d17e01fb53b0f3bfef610.json
│   │   │   ├── query-66fcc6dfb88db7c48ea1cc752e61fc1aefb776aa112b632cd0383144c730e7f8.json
│   │   │   ├── query-6ad98c10b69f3b51f3da346ec4099672a6caffdd4bb6367aec376a9f48178609.json
│   │   │   ├── query-6c2747c4d67751619b5fa1cceddc88de5de074b1b8f2c1ce39ac263552d34676.json
│   │   │   ├── query-6d7ded0d4ae669d73f3102d587ff28837a50c63a860954012b4662e94b4a56e6.json
│   │   │   ├── query-6e79a42707d3e5a6351638b5a3fc366cb4196394860bfd84e7e982cb8d6c5b18.json
│   │   │   ├── query-70fad3e1d4f3a64354cbeb0e3ca48b8ab08df1e6358ec3e4f757d0d088c76f48.json
│   │   │   ├── query-716311a203bbae991195af32e0d5da036f2cbd318140bb898c16130192da8263.json
│   │   │   ├── query-774d0833f523257d42044019619094083caf37a564283a97822f0efb309f2ea8.json
│   │   │   ├── query-795fb48de7af8f3580c762cbb1fea2d39fb077fc422bb0009818881dd25c8e2e.json
│   │   │   ├── query-797432c3fb131ab8114f6ebae7e1800c39b91d2ee605ad35742da793ef403c7c.json
│   │   │   ├── query-7c2893a193186d51a0d980e44e0875b9b1ab5cb63951d4816248df0f22befe21.json
│   │   │   ├── query-7e4f6abc7e18549f31548130efa4bed4d267da6e28697ceb780a58d787e739f1.json
│   │   │   ├── query-83990047729c1121ab65f969cdb64bd8a3cae2594e5049b6049aeeb3afce3604.json
│   │   │   ├── query-83f5c3fa88b2ea5423d42617d4f937bdf08ffc80906b8ad1aeddc4a0f4ab1889.json
│   │   │   ├── query-84c5e88c6c98fd021781e6730664989697c8708668a0d7498f83f54cc9270913.json
│   │   │   ├── query-88e197ca40810b08239f59843477ebad687a02fab9dd6126fd473f392ebd92dd.json
│   │   │   ├── query-8a2918ace6c8fe642dc6b8badc952c7a3df9b2e0ac113b93d20b2a78bcab75b7.json
│   │   │   ├── query-8b46c95180daf944b99d16dca194420f46cf495d5738d25b453a745cb83797a0.json
│   │   │   ├── query-8d26754325c24ace1e89a1b432b68d36e5f5f082a1807a112a4ec0dba38e665c.json
│   │   │   ├── query-8e2e1efee7317633a7c75aa4e750db5583341a7a5fda81949d49029db7468829.json
│   │   │   ├── query-8f7a80b924a8cc486b806a8c89d92bc46ae3f8342223e75b46a6f370cc701c13.json
│   │   │   ├── query-9216fe2a7bc69b70dc8a962e0a7ecb664f4dfa1b17af87f4671bfeaf33ebcda9.json
│   │   │   ├── query-94e9cb426316068aa285da33e7fd1dfa34bf30db25bcf69a333a341b17b5557a.json
│   │   │   ├── query-96a5408903c809773e2e612896ac5f409d57f1fa2faee0f149c5fb49b97cd72f.json
│   │   │   ├── query-9a71466b2a069b1f23002c8e3e2368eb9067669b008dc7d1c80b11d75cbe9897.json
│   │   │   ├── query-9c32675069536c1825f8e161677a3d1c443a66514312fa099d0818cbbcfdf400.json
│   │   │   ├── query-a3581b82aa78344b06e4270d0aec5ac76c2d0fa1661c1502600852450d92fe8a.json
│   │   │   ├── query-abf5e9cde25bc541a81b63750c3464c633a9b0d724d094e0355455e0d80de3c1.json
│   │   │   ├── query-ac06d348f1c67ccd28d7366a1d81ca221f8e611fa06a25dec4fa538e7157f293.json
│   │   │   ├── query-ad63b516c6102b7cbcbdb22f48f8e369da1ea2ff1069f4681285cc945b3c3052.json
│   │   │   ├── query-b5b633e5812b7396037e2ab0a1db9a1d753b8650ed3367681ba30ed426799502.json
│   │   │   ├── query-b70ea209992428946075c428fb31645d2a857bfddd4f1f6c628d6965cf6ef2fe.json
│   │   │   ├── query-b7d5ed966527dfc500ce529e0249d96c058a06c18a02ed117ad2f4140fbc470f.json
│   │   │   ├── query-b801404dd6465cc942d1f953f7aa53eece85e4302cef55f50096fa0b25ab7a50.json
│   │   │   ├── query-b8a3d295f6c8ffaf10cd0f168cb21a1da296a46f576bd8e8907930256108aa6b.json
│   │   │   ├── query-b973ff4880b83c2ebfae9f16c44e5567e10cf61e9743fd35f37fa491b03f6f14.json
│   │   │   ├── query-bd3133f71b96a8dd47cd98e439e1177780feb486fa57c3a86dbcf6975efb2922.json
│   │   │   ├── query-be2b163e885ff2e4df27ae07c51f8c304f534b50565504a96bd63ce63a6179d7.json
│   │   │   ├── query-c010283b4b49e2fe25298ee7925e5b920f95e05efde395c8bd1a270ff464f863.json
│   │   │   ├── query-c04e20e576db9e48984ccc149dd87a82f00d0437152b8cb279dd0bb8481f0a89.json
│   │   │   ├── query-c39fd3cd50f810ba951eb6015eb41792e00688f1147f8475f263c76a1d4ec9a6.json
│   │   │   ├── query-c9baf1542b684063be66cae40108e096dc603a296fc403c52bd58cb6c8e7071e.json
│   │   │   ├── query-cb0007cbc7fb244f430b4d59fa6a80933893fd00210e3c646260a626008fe669.json
│   │   │   ├── query-cbf71c3aa66e532d73d0d53c71f0fdc94508cdc26ec474f4d06ee9b64173ea72.json
│   │   │   ├── query-cdc6f5540c07295f92a29399a7108cdb89f6ed7489533e74fdbf8d495f74a09c.json
│   │   │   ├── query-ce25e817abead7c5a3a71ab88f8d4832119716c070bcb5b19a5cd338b6d30006.json
│   │   │   ├── query-cec3858b85d307add170a758cd61c62c2a5c56506248882654d59b790d8fef26.json
│   │   │   ├── query-d1d558d9f86eae97eb9fd0b16b1e0bf4ad00f66119c50381c0673a0d2433567b.json
│   │   │   ├── query-d1f929a46fc666737ca207bbb043cc93c72bcb52150f779f2fc49bc83767bf23.json
│   │   │   ├── query-d28852ae21252e3cfed6f82f912d44301291ccd97d88c3ea6f124316dce09ffd.json
│   │   │   ├── query-d4019362b696c0b4a3115810e5587f3cecd34f069ebea5689cf48779f0160779.json
│   │   │   ├── query-d5b1a3a280be69aa2f0ba494c36fa4fbf10e8cfc1961df766327f0c375aeccc2.json
│   │   │   ├── query-d689a7a2fc154b39cd8662c515c9e80c3cdad919dd41b595790079843445e664.json
│   │   │   ├── query-d6d82726686a53f620946463cd2bd0044ca7f2daf2261f3647ec944216252ec5.json
│   │   │   ├── query-d7f8906e1ac617629dc51e9c58ed28a03564df2aa1b270aec24e50ee45a098f6.json
│   │   │   ├── query-d85f9e81a8049c2f66534f9e7a9c5b8900bedd9785fd4da3629978df3b589230.json
│   │   │   ├── query-d94483044765504ae794c16487fd225297876c170ba807360ae413fb9f837e5d.json
│   │   │   ├── query-db960d1e67219284c082dbb56187c75efe1b9389d9e8a703b6f3399586369bac.json
│   │   │   ├── query-e007c4af2864544c0eaa5d27f456f611b3d9f9909a845f78f85cdd69787c7106.json
│   │   │   ├── query-e26529636b13051b543f64a54d4557837af16aa5b3fa8c74dc30550e59612bbf.json
│   │   │   ├── query-e6783de9bead8fc13c6954369740763df1e7ae2a98aa0495b4245960b9a1bbfc.json
│   │   │   ├── query-e8c9fde48a0d089461d92437b2afe994bef17f18e5c64ddcf63574cc0a579d28.json
│   │   │   ├── query-e8e1a20c2a71d8658815aed49df37fe3e7ad9a10416da01bfc4a885f78199532.json
│   │   │   ├── query-e9835f07851a4323c9a8ffbf0faddc4869c6b1074ce226a8004baf45c7421c54.json
│   │   │   ├── query-ea82d8b3b75ba91c214466b39aeef81278ad12c002eeea1a7857b50ba39962fb.json
│   │   │   ├── query-eadec222d0154713dc15ea7ba1e113ae7838d935e4462421fd796f5f7986dbbd.json
│   │   │   ├── query-eee88ff2cfe1661d1253970efd6962cf97d815b0812b0f704396e9f8500eb9f8.json
│   │   │   ├── query-f3d7ddb9d731b10dd25b1ece48b777115087dbd619f74c61c921a2e21b2e3682.json
│   │   │   ├── query-f4aae3e6a8c06222c30078b78eaf48d50439c2eba9411f160ea2a0f7c00a52e7.json
│   │   │   ├── query-f4abad33ec40c74fa5f4fbec67631d8a1d10f0d36b55428356b093eaedbc5e1c.json
│   │   │   ├── query-f5fc158d631a0fd6fcc45e940c14ce507e764cec73c215ce295fcfb64b95c37e.json
│   │   │   ├── query-f7599bbef8c317c1ab1a61b2bcba3c5b03855b8a536bcdf369332c567b29d92c.json
│   │   │   ├── query-f8bb60a7281c6fc60b9ad82c9a7e536ce74a42afcc72bc79215a7bb51497ec02.json
│   │   │   ├── query-faf23b99c8ddbc31b32cdbbcc96cdf4b113a5c4181cc95ab2db93f680fe2a8ea.json
│   │   │   ├── query-fd1604ca19ddd4ebb61b085800bf355b6812d8aa8cc254c9e0b27c780462f9e9.json
│   │   │   ├── query-fd20a584d8619dbbed4c61a0e930c900d51d45ddcc16f5e799b68a058f04ac1e.json
│   │   │   └── query-fd80c7542a9e5573dc53fc8dcce04faff79341cdd6cbd60376c951cd9f8e21ee.json
│   │   ├── Cargo.toml
│   │   ├── Dockerfile.workspace
│   │   ├── db-migration/
│   │   │   ├── Dockerfile
│   │   │   ├── describe_table.sh
│   │   │   ├── initialize_db.sh
│   │   │   └── migrations/
│   │   │       ├── 20240722111257_coprocessor.sql
│   │   │       ├── 20250205000000_drop_output_type_in_computations.sql
│   │   │       ├── 20250205130209_create_pbs_computations_table.sql
│   │   │       ├── 20250207092623_verify_proofs.sql
│   │   │       ├── 20250212082040_create_sns_keys_columns.sql
│   │   │       ├── 20250217133315_add_table_blocks_valid.sql
│   │   │       ├── 20250221112128_gw_listener_last_block.sql
│   │   │       ├── 20250303135355_fhevm_listner_auto_notify.sql
│   │   │       ├── 20250310120834_create_ciphertext_digest.sql
│   │   │       ├── 20250310122059_add_ciphertext128_column.sql
│   │   │       ├── 20250317140442_create_allow_handle.sql
│   │   │       ├── 20250326183240_add_key_id_to_tenants.sql
│   │   │       ├── 20250508075211_ciphertext_digest_and_acl_retries.sql
│   │   │       ├── 20250512084614_fhevm_listner_auto_notify_acl.sql
│   │   │       ├── 20250529101607_retry_count_rename.sql
│   │   │       ├── 20250703000000_add_schedule_order_column.sql
│   │   │       ├── 20250718073338_add_ciphertext128_format_column.sql
│   │   │       ├── 20250728110954_verify_proofs_extra_data.sql
│   │   │       ├── 20250729115448_ciphertext_digest_txn_info.sql
│   │   │       ├── 20250729123642_allowed_handles_txn_info.sql
│   │   │       ├── 20250801080000_computations_transaction_id.sql
│   │   │       ├── 20250801080001_allowed_handles_computed_flag.sql
│   │   │       ├── 20250801080153_verify_proofs_bigint_chain_id.sql
│   │   │       ├── 20250801080312_tenants_bigint_chain_id.sql
│   │   │       ├── 20250802080000_computations_drop_trigger_work_available.sql
│   │   │       ├── 20250805080000_computations_update_primary_key.sql
│   │   │       ├── 20250814080000_computations_uncomputable_counter.sql
│   │   │       ├── 20250831080000_allowed_handles_schedule_order.sql
│   │   │       ├── 20250901090610_simplify_blocks_valid_table.sql
│   │   │       ├── 20250920080000_computations_scheduling.sql
│   │   │       ├── 20250929064611_create_transactions_table.sql
│   │   │       ├── 20251002083309_add_transactions_index.sql
│   │   │       ├── 20251006080000_computations_auto_notify.sql
│   │   │       ├── 20251013083601_delegations.sql
│   │   │       ├── 20251015000000_host_listener_poller_state.sql
│   │   │       ├── 20251126110000_computations_created_at_index.sql
│   │   │       ├── 20251203140023_ciphertext_digest_idx_sent_and_handle.sql
│   │   │       ├── 20251205070512_add_pbs_computations_created_at_idx.sql
│   │   │       ├── 20251205154454_create_dependence_chain_table.sql
│   │   │       ├── 20251218162249_extend_dcid_table.sql
│   │   │       ├── 20251221080000_dependence_chain_index_processed_last_updated.sql
│   │   │       ├── 20251224110000_ciphertexts_partial_indexes.sql
│   │   │       ├── 20251230155309_improve_sns_and_txsend_select_indexing.sql
│   │   │       ├── 20260105120000_dependence_chain_proofs_indexing.sql
│   │   │       ├── 20260106145618_unused_index.sql
│   │   │       ├── 20260106150619_create_ciphertexts128_table.sql
│   │   │       ├── 20260110190000_index_dependence_chain.sql
│   │   │       ├── 20260120102002_unused_index_cleaning.sql
│   │   │       ├── 20260128095635_remove_tenants.sql
│   │   │       ├── 20260204130000_dependence_chain_schedule_priority.sql
│   │   │       ├── 20260218155637_add_block_status.sql
│   │   │       ├── 20260311154000_gw_listener_earliest_open_ct_block.sql
│   │   │       └── 20260312174148_downgradable_block_status.sql
│   │   ├── fhevm-engine-common/
│   │   │   ├── Cargo.toml
│   │   │   ├── build.rs
│   │   │   ├── src/
│   │   │   │   ├── bin/
│   │   │   │   │   └── generate_keys.rs
│   │   │   │   ├── chain_id.rs
│   │   │   │   ├── crs.rs
│   │   │   │   ├── db_keys.rs
│   │   │   │   ├── gpu_memory.rs
│   │   │   │   ├── healthz_server.rs
│   │   │   │   ├── host_chains.rs
│   │   │   │   ├── keys.rs
│   │   │   │   ├── lib.rs
│   │   │   │   ├── metrics_server.rs
│   │   │   │   ├── pg_pool.rs
│   │   │   │   ├── telemetry.rs
│   │   │   │   ├── tfhe_ops.rs
│   │   │   │   ├── types.rs
│   │   │   │   └── utils.rs
│   │   │   └── tests/
│   │   │       └── utils.rs
│   │   ├── fhevm-keys/
│   │   │   ├── .gitattributes
│   │   │   ├── cks
│   │   │   ├── gpu-cks
│   │   │   ├── gpu-csks
│   │   │   ├── gpu-pks
│   │   │   ├── gpu-pp
│   │   │   ├── pks
│   │   │   ├── pp
│   │   │   ├── sks
│   │   │   └── sns_pk
│   │   ├── gw-listener/
│   │   │   ├── .gitignore
│   │   │   ├── Cargo.toml
│   │   │   ├── Dockerfile
│   │   │   ├── README.md
│   │   │   ├── build.rs
│   │   │   ├── contracts/
│   │   │   │   ├── InputVerification.sol
│   │   │   │   └── KMSGeneration.sol
│   │   │   ├── gw-listener/
│   │   │   │   └── tests/
│   │   │   │       └── gw_listener_tests.rs
│   │   │   ├── src/
│   │   │   │   ├── aws_s3.rs
│   │   │   │   ├── bin/
│   │   │   │   │   └── gw_listener.rs
│   │   │   │   ├── database.rs
│   │   │   │   ├── digest.rs
│   │   │   │   ├── drift_detector.rs
│   │   │   │   ├── gw_listener.rs
│   │   │   │   ├── http_server.rs
│   │   │   │   ├── lib.rs
│   │   │   │   ├── metrics.rs
│   │   │   │   └── sks_key.rs
│   │   │   └── tests/
│   │   │       └── gw_listener_tests.rs
│   │   ├── host-listener/
│   │   │   ├── .gitignore
│   │   │   ├── Cargo.toml
│   │   │   ├── Dockerfile
│   │   │   ├── README.md
│   │   │   ├── build.rs
│   │   │   ├── contracts/
│   │   │   │   ├── ACLTest.sol
│   │   │   │   └── FHEVMExecutorTest.sol
│   │   │   ├── rustfmt.toml
│   │   │   ├── src/
│   │   │   │   ├── bin/
│   │   │   │   │   ├── main.rs
│   │   │   │   │   └── poller.rs
│   │   │   │   ├── cmd/
│   │   │   │   │   ├── block_history.rs
│   │   │   │   │   └── mod.rs
│   │   │   │   ├── contracts/
│   │   │   │   │   └── mod.rs
│   │   │   │   ├── database/
│   │   │   │   │   ├── dependence_chains.rs
│   │   │   │   │   ├── ingest.rs
│   │   │   │   │   ├── mod.rs
│   │   │   │   │   └── tfhe_event_propagate.rs
│   │   │   │   ├── health_check.rs
│   │   │   │   ├── lib.rs
│   │   │   │   └── poller/
│   │   │   │       ├── http_client.rs
│   │   │   │       ├── metrics.rs
│   │   │   │       └── mod.rs
│   │   │   └── tests/
│   │   │       ├── host_listener_integration_tests.rs
│   │   │       └── poller_integration_tests.rs
│   │   ├── rust-toolchain.toml
│   │   ├── scheduler/
│   │   │   ├── Cargo.toml
│   │   │   └── src/
│   │   │       ├── dfg/
│   │   │       │   ├── scheduler.rs
│   │   │       │   └── types.rs
│   │   │       ├── dfg.rs
│   │   │       └── lib.rs
│   │   ├── sns-worker/
│   │   │   ├── Cargo.toml
│   │   │   ├── Dockerfile
│   │   │   ├── README.md
│   │   │   ├── ciphertext64.json
│   │   │   └── src/
│   │   │       ├── aws_upload.rs
│   │   │       ├── bin/
│   │   │       │   ├── sns_worker.rs
│   │   │       │   └── utils/
│   │   │       │       ├── daemon_cli.rs
│   │   │       │       └── mod.rs
│   │   │       ├── executor.rs
│   │   │       ├── keyset.rs
│   │   │       ├── lib.rs
│   │   │       ├── metrics.rs
│   │   │       ├── squash_noise.rs
│   │   │       └── tests/
│   │   │           └── mod.rs
│   │   ├── stress-test-generator/
│   │   │   ├── Cargo.toml
│   │   │   ├── Dockerfile
│   │   │   ├── Makefile
│   │   │   ├── README.md
│   │   │   ├── data/
│   │   │   │   ├── evgen_scenario.csv
│   │   │   │   ├── json/
│   │   │   │   │   ├── batch_allow_handles.json
│   │   │   │   │   ├── batch_bids_auction.json
│   │   │   │   │   ├── batch_input_proofs.json
│   │   │   │   │   ├── evgen_scenario.json
│   │   │   │   │   ├── example_job.json
│   │   │   │   │   ├── minitest_001_zkinputs.json
│   │   │   │   │   ├── minitest_002_erc20.json
│   │   │   │   │   └── minitest_003_generate_handles_for_decryption.csv.json
│   │   │   │   ├── minitest_001_zkinputs.csv
│   │   │   │   ├── minitest_002_erc20.csv
│   │   │   │   └── minitest_003_generate_handles_for_decryption.csv
│   │   │   └── src/
│   │   │       ├── args.rs
│   │   │       ├── auction.rs
│   │   │       ├── bin/
│   │   │       │   └── stress_generator.rs
│   │   │       ├── dex.rs
│   │   │       ├── erc20.rs
│   │   │       ├── erc7984.rs
│   │   │       ├── lib.rs
│   │   │       ├── synthetics.rs
│   │   │       ├── utils.rs
│   │   │       └── zk_gen.rs
│   │   ├── test-harness/
│   │   │   ├── Cargo.toml
│   │   │   └── src/
│   │   │       ├── db_utils.rs
│   │   │       ├── health_check.rs
│   │   │       ├── instance.rs
│   │   │       ├── lib.rs
│   │   │       ├── localstack.rs
│   │   │       └── s3_utils.rs
│   │   ├── tfhe-worker/
│   │   │   ├── .gitattributes
│   │   │   ├── .gitignore
│   │   │   ├── Cargo.toml
│   │   │   ├── Dockerfile
│   │   │   ├── Makefile
│   │   │   ├── README.md
│   │   │   ├── benches/
│   │   │   │   ├── dex.rs
│   │   │   │   ├── erc20.rs
│   │   │   │   ├── synthetics.rs
│   │   │   │   └── utils.rs
│   │   │   ├── coprocessor.key
│   │   │   ├── docker-compose.yml
│   │   │   ├── scripts/
│   │   │   │   └── recreate_db.sh
│   │   │   └── src/
│   │   │       ├── bin/
│   │   │       │   ├── tfhe_worker.rs
│   │   │       │   └── utils.rs
│   │   │       ├── daemon_cli.rs
│   │   │       ├── dependence_chain.rs
│   │   │       ├── health_check.rs
│   │   │       ├── lib.rs
│   │   │       ├── tests/
│   │   │       │   ├── dependence_chain.rs
│   │   │       │   ├── errors.rs
│   │   │       │   ├── event_helpers.rs
│   │   │       │   ├── health_check.rs
│   │   │       │   ├── inputs.rs
│   │   │       │   ├── migrations.rs
│   │   │       │   ├── mod.rs
│   │   │       │   ├── operators_from_events.rs
│   │   │       │   ├── random.rs
│   │   │       │   ├── scheduling_bench.rs
│   │   │       │   ├── test_cases.rs
│   │   │       │   └── utils.rs
│   │   │       ├── tfhe_worker.rs
│   │   │       └── types.rs
│   │   ├── transaction-sender/
│   │   │   ├── .gitignore
│   │   │   ├── Cargo.toml
│   │   │   ├── Dockerfile
│   │   │   ├── build.rs
│   │   │   ├── contracts/
│   │   │   │   ├── CiphertextCommits.sol
│   │   │   │   └── InputVerification.sol
│   │   │   ├── src/
│   │   │   │   ├── bin/
│   │   │   │   │   └── transaction_sender.rs
│   │   │   │   ├── config.rs
│   │   │   │   ├── http_server.rs
│   │   │   │   ├── lib.rs
│   │   │   │   ├── metrics.rs
│   │   │   │   ├── nonce_managed_provider.rs
│   │   │   │   ├── ops/
│   │   │   │   │   ├── add_ciphertext.rs
│   │   │   │   │   ├── common.rs
│   │   │   │   │   ├── mod.rs
│   │   │   │   │   └── verify_proof.rs
│   │   │   │   └── transaction_sender.rs
│   │   │   └── tests/
│   │   │       ├── add_ciphertext_tests.rs
│   │   │       ├── common.rs
│   │   │       ├── overprovision_gas_limit_tests.rs
│   │   │       └── verify_proof_tests.rs
│   │   └── zkproof-worker/
│   │       ├── Cargo.toml
│   │       ├── Dockerfile
│   │       └── src/
│   │           ├── auxiliary.rs
│   │           ├── bin/
│   │           │   └── zkproof_worker.rs
│   │           ├── lib.rs
│   │           ├── tests/
│   │           │   ├── mod.rs
│   │           │   └── utils.rs
│   │           └── verifier.rs
│   └── proto/
│       └── common.proto
├── docs/
│   ├── examples/
│   │   ├── SUMMARY.md
│   │   ├── fhe-counter.md
│   │   ├── fhe-encrypt-multiple-value.md
│   │   ├── fhe-encrypt-multiple-values.md
│   │   ├── fhe-encrypt-single-value.md
│   │   ├── fhe-user-decrypt-multiple-values.md
│   │   ├── fhe-user-decrypt-single-value.md
│   │   ├── fheadd.md
│   │   ├── fheifthenelse.md
│   │   ├── heads-or-tails.md
│   │   ├── highest-die-roll.md
│   │   ├── integration-guide.md
│   │   ├── legacy/
│   │   │   └── see-all-tutorials.md
│   │   ├── openzeppelin/
│   │   │   ├── ERC7984ERC20WrapperMock.md
│   │   │   ├── README.md
│   │   │   ├── erc7984-tutorial.md
│   │   │   ├── erc7984.md
│   │   │   ├── swapERC7984ToERC20.md
│   │   │   ├── swapERC7984ToERC7984.md
│   │   │   └── vesting-wallet.md
│   │   ├── sealed-bid-auction-tutorial.md
│   │   └── sealed-bid-auction.md
│   ├── metrics/
│   │   └── metrics.md
│   ├── operators/
│   │   └── operators-overview.md
│   ├── protocol/
│   │   ├── README.md
│   │   ├── SUMMARY.md
│   │   ├── architecture/
│   │   │   ├── coprocessor.md
│   │   │   ├── gateway.md
│   │   │   ├── hostchain.md
│   │   │   ├── kms.md
│   │   │   ├── library.md
│   │   │   ├── overview.md
│   │   │   └── relayer_oracle.md
│   │   ├── contribute.md
│   │   ├── d_re_ecrypt_compute.md
│   │   └── roadmap.md
│   ├── sdk-guides/
│   │   ├── SUMMARY.md
│   │   ├── cli.md
│   │   ├── initialization.md
│   │   ├── input.md
│   │   ├── public-decryption.md
│   │   ├── sdk-overview.md
│   │   ├── user-decryption.md
│   │   ├── webapp.md
│   │   └── webpack.md
│   └── solidity-guides/
│       ├── README.md
│       ├── SUMMARY.md
│       ├── acl/
│       │   ├── README.md
│       │   ├── acl_examples.md
│       │   └── reorgs_handling.md
│       ├── configure.md
│       ├── contract_addresses.md
│       ├── debug_decrypt.md
│       ├── decryption/
│       │   ├── debugging.md
│       │   └── oracle.md
│       ├── foundry.md
│       ├── functions.md
│       ├── getting-started/
│       │   ├── overview.md
│       │   └── quick-start-tutorial/
│       │       ├── README.md
│       │       ├── setup.md
│       │       ├── test_the_fhevm_contract.md
│       │       ├── turn_it_into_fhevm.md
│       │       └── write_a_simple_contract.md
│       ├── hardhat/
│       │   ├── README.md
│       │   ├── run_test.md
│       │   ├── write_task.md
│       │   └── write_test.md
│       ├── hcu.md
│       ├── inputs.md
│       ├── key_concepts.md
│       ├── logics/
│       │   ├── README.md
│       │   ├── conditions.md
│       │   ├── error_handling.md
│       │   └── loop.md
│       ├── migration.md
│       ├── mocked.md
│       ├── operations/
│       │   ├── README.md
│       │   ├── casting.md
│       │   └── random.md
│       ├── transform_smart_contract_with_fhevm.md
│       └── types.md
├── gateway-contracts/
│   ├── .env.example
│   ├── .gitignore
│   ├── .husky/
│   │   ├── commit-msg
│   │   └── pre-commit
│   ├── .prettierignore
│   ├── .solhint.json
│   ├── .solhintignore
│   ├── Dockerfile
│   ├── Makefile
│   ├── README.md
│   ├── contracts/
│   │   ├── CiphertextCommits.sol
│   │   ├── Decryption.sol
│   │   ├── GatewayConfig.sol
│   │   ├── InputVerification.sol
│   │   ├── KMSGeneration.sol
│   │   ├── ProtocolPayment.sol
│   │   ├── emptyProxy/
│   │   │   └── EmptyUUPSProxy.sol
│   │   ├── emptyProxyGatewayConfig/
│   │   │   └── EmptyUUPSProxyGatewayConfig.sol
│   │   ├── examples/
│   │   │   ├── CiphertextCommitsV2Example.sol
│   │   │   ├── DecryptionV2Example.sol
│   │   │   ├── GatewayConfigV2Example.sol
│   │   │   ├── InputVerificationV2Example.sol
│   │   │   ├── KMSGenerationV2Example.sol
│   │   │   └── ProtocolPaymentV2Example.sol
│   │   ├── immutable/
│   │   │   └── PauserSet.sol
│   │   ├── interfaces/
│   │   │   ├── ICiphertextCommits.sol
│   │   │   ├── IDecryption.sol
│   │   │   ├── IGatewayConfig.sol
│   │   │   ├── IInputVerification.sol
│   │   │   ├── IKMSGeneration.sol
│   │   │   ├── IPauserSet.sol
│   │   │   └── IProtocolPayment.sol
│   │   ├── libraries/
│   │   │   ├── FHETypeBitSizes.sol
│   │   │   └── HandleOps.sol
│   │   ├── mockedPaymentBridging/
│   │   │   └── ZamaOFT.sol
│   │   ├── mocks/
│   │   │   ├── CiphertextCommitsMock.sol
│   │   │   ├── DecryptionMock.sol
│   │   │   ├── GatewayConfigMock.sol
│   │   │   ├── InputVerificationMock.sol
│   │   │   ├── KMSGenerationMock.sol
│   │   │   └── ProtocolPaymentMock.sol
│   │   └── shared/
│   │       ├── FheType.sol
│   │       ├── GatewayConfigChecks.sol
│   │       ├── GatewayOwnable.sol
│   │       ├── KMSRequestCounters.sol
│   │       ├── Pausable.sol
│   │       ├── ProtocolPaymentUtils.sol
│   │       ├── Structs.sol
│   │       └── UUPSUpgradeableEmptyProxy.sol
│   ├── docker-compose.yml
│   ├── docs/
│   │   ├── README.md
│   │   ├── SUMMARY.md
│   │   ├── getting-started/
│   │   │   ├── contracts/
│   │   │   │   ├── gateway_config.md
│   │   │   │   ├── kms_generation.md
│   │   │   │   └── pauser_set.md
│   │   │   ├── deployment/
│   │   │   │   ├── docker_deploy.md
│   │   │   │   ├── env_variables.md
│   │   │   │   └── local_deploy.md
│   │   │   └── pausing/
│   │   │       ├── env_variables.md
│   │   │       └── pausing.md
│   │   └── references/
│   │       └── selectors.md
│   ├── foundry.toml
│   ├── hardhat.config.ts
│   ├── package.json
│   ├── rust_bindings/
│   │   ├── .gitignore
│   │   ├── Cargo.toml
│   │   └── src/
│   │       ├── address.rs
│   │       ├── ciphertext_commits.rs
│   │       ├── context.rs
│   │       ├── context_upgradeable.rs
│   │       ├── decryption.rs
│   │       ├── ecdsa.rs
│   │       ├── eip712_upgradeable.rs
│   │       ├── empty_uups_proxy.rs
│   │       ├── empty_uups_proxy_gateway_config.rs
│   │       ├── erc1967_utils.rs
│   │       ├── erc20.rs
│   │       ├── errors.rs
│   │       ├── fhe_type_bit_sizes.rs
│   │       ├── gateway_config.rs
│   │       ├── gateway_config_checks.rs
│   │       ├── gateway_ownable.rs
│   │       ├── handle_ops.rs
│   │       ├── i_beacon.rs
│   │       ├── i_ciphertext_commits.rs
│   │       ├── i_decryption.rs
│   │       ├── i_gateway_config.rs
│   │       ├── i_input_verification.rs
│   │       ├── i_pauser_set.rs
│   │       ├── i_protocol_payment.rs
│   │       ├── ierc1155_errors.rs
│   │       ├── ierc1822_proxiable.rs
│   │       ├── ierc1967.rs
│   │       ├── ierc20.rs
│   │       ├── ierc20_errors.rs
│   │       ├── ierc20_metadata.rs
│   │       ├── ierc5267.rs
│   │       ├── ierc721_errors.rs
│   │       ├── ikms_generation.rs
│   │       ├── initializable.rs
│   │       ├── input_verification.rs
│   │       ├── kms_generation.rs
│   │       ├── math.rs
│   │       ├── message_hash_utils.rs
│   │       ├── mod.rs
│   │       ├── ownable2_step_upgradeable.rs
│   │       ├── ownable_upgradeable.rs
│   │       ├── panic.rs
│   │       ├── pausable.rs
│   │       ├── pausable_upgradeable.rs
│   │       ├── pauser_set.rs
│   │       ├── protocol_payment.rs
│   │       ├── protocol_payment_utils.rs
│   │       ├── safe_cast.rs
│   │       ├── signed_math.rs
│   │       ├── storage_slot.rs
│   │       ├── strings.rs
│   │       ├── uups_upgradeable.rs
│   │       ├── uups_upgradeable_empty_proxy.rs
│   │       └── zama_oft.rs
│   ├── scripts/
│   │   ├── ensure_proxy_addresses.ts
│   │   └── mock_contracts_cli.js
│   ├── selectors.txt
│   ├── tasks/
│   │   ├── accounts.ts
│   │   ├── addHostChains.ts
│   │   ├── addPausers.ts
│   │   ├── blockExplorerVerify.ts
│   │   ├── deployment/
│   │   │   ├── contracts.ts
│   │   │   ├── empty_proxies.ts
│   │   │   ├── index.ts
│   │   │   ├── mock_contracts.ts
│   │   │   ├── pauserSet.ts
│   │   │   ├── paymentBridging/
│   │   │   │   ├── index.ts
│   │   │   │   ├── mocked.ts
│   │   │   │   └── setAddresses.ts
│   │   │   └── utils.ts
│   │   ├── generateKmsMaterials.ts
│   │   ├── getters.ts
│   │   ├── mockedTokenFund.ts
│   │   ├── ownership.ts
│   │   ├── pauseContracts.ts
│   │   ├── reshareKeys.ts
│   │   ├── upgradeContracts.ts
│   │   └── utils/
│   │       ├── index.ts
│   │       ├── loadVariables.ts
│   │       └── stringOps.ts
│   ├── test/
│   │   ├── CiphertextCommits.ts
│   │   ├── Decryption.ts
│   │   ├── GatewayConfig.ts
│   │   ├── InputVerification.ts
│   │   ├── KMSGeneration.ts
│   │   ├── PauserSet.ts
│   │   ├── ProtocolPayment.ts
│   │   ├── mocks/
│   │   │   └── mocks.ts
│   │   ├── tasks/
│   │   │   ├── keyResharing.ts
│   │   │   ├── ownership.ts
│   │   │   └── pausing.ts
│   │   ├── upgrades/
│   │   │   └── upgrades.ts
│   │   └── utils/
│   │       ├── contracts.ts
│   │       ├── eip712/
│   │       │   ├── decryption.ts
│   │       │   ├── index.ts
│   │       │   ├── inputVerification.ts
│   │       │   ├── interface.ts
│   │       │   └── kmsGeneration.ts
│   │       ├── events.ts
│   │       ├── index.ts
│   │       ├── inputs.ts
│   │       ├── kmsRequestIds.ts
│   │       ├── typeConversion.ts
│   │       └── wallets.ts
│   ├── tsconfig.json
│   └── upgrade-manifest.json
├── golden-container-images/
│   ├── nodejs/
│   │   └── Dockerfile
│   └── rust-glibc/
│       └── Dockerfile
├── host-contracts/
│   ├── .env.example
│   ├── .gitignore
│   ├── .npmignore
│   ├── .prettierignore
│   ├── .prettierrc.json
│   ├── .solcover.js
│   ├── CustomProvider.ts
│   ├── Dockerfile
│   ├── Makefile
│   ├── README.md
│   ├── codegen.config.json
│   ├── contracts/
│   │   ├── ACL.sol
│   │   ├── ACLEvents.sol
│   │   ├── FHEEvents.sol
│   │   ├── FHEVMExecutor.sol
│   │   ├── HCULimit.sol
│   │   ├── InputVerifier.sol
│   │   ├── KMSVerifier.sol
│   │   ├── emptyProxy/
│   │   │   └── EmptyUUPSProxy.sol
│   │   ├── emptyProxyACL/
│   │   │   └── EmptyUUPSProxyACL.sol
│   │   ├── immutable/
│   │   │   └── PauserSet.sol
│   │   ├── interfaces/
│   │   │   └── IPauserSet.sol
│   │   └── shared/
│   │       ├── ACLOwnable.sol
│   │       ├── Constants.sol
│   │       ├── EIP712UpgradeableCrossChain.sol
│   │       ├── FheType.sol
│   │       └── UUPSUpgradeableEmptyProxy.sol
│   ├── docker-compose.yml
│   ├── docs/
│   │   └── contract_selectors.txt
│   ├── examples/
│   │   ├── ACLUpgradedExample.sol
│   │   ├── ACLUpgradedExample2.sol
│   │   ├── Counter.sol
│   │   ├── EncryptedERC20.sol
│   │   ├── FHEVMExecutorUpgradedExample.sol
│   │   ├── HCULimitTest.sol
│   │   ├── HCULimitUpgradedExample.sol
│   │   ├── KMSVerifierUpgradedExample.sol
│   │   ├── MakePubliclyDecryptable.sol
│   │   ├── Rand.sol
│   │   ├── Reencrypt.sol
│   │   ├── Regression1.sol
│   │   ├── SmartAccount.sol
│   │   ├── TestInput.sol
│   │   ├── TracingSubCalls.sol
│   │   └── tests/
│   │       ├── FHEVMManualTestSuite.sol
│   │       ├── FHEVMTestSuite1.sol
│   │       ├── FHEVMTestSuite2.sol
│   │       ├── FHEVMTestSuite3.sol
│   │       ├── FHEVMTestSuite4.sol
│   │       ├── FHEVMTestSuite5.sol
│   │       ├── FHEVMTestSuite6.sol
│   │       └── FHEVMTestSuite7.sol
│   ├── fhevm-foundry/
│   │   └── HostContractsDeployerTestUtils.sol
│   ├── foundry.toml
│   ├── hardhat.config.ts
│   ├── lib/
│   │   ├── CoprocessorSetup.sol
│   │   ├── FHE.sol
│   │   ├── Impl.sol
│   │   └── cryptography/
│   │       └── FhevmECDSA.sol
│   ├── package.json
│   ├── remappings.txt
│   ├── rust_bindings/
│   │   ├── Cargo.toml
│   │   └── src/
│   │       ├── acl.rs
│   │       ├── acl_events.rs
│   │       ├── acl_ownable.rs
│   │       ├── address.rs
│   │       ├── context_upgradeable.rs
│   │       ├── ecdsa.rs
│   │       ├── eip712_upgradeable_cross_chain.rs
│   │       ├── empty_uups_proxy.rs
│   │       ├── empty_uups_proxy_acl.rs
│   │       ├── erc1967_utils.rs
│   │       ├── errors.rs
│   │       ├── fhe_events.rs
│   │       ├── fhevm_executor.rs
│   │       ├── hcu_limit.rs
│   │       ├── i_beacon.rs
│   │       ├── i_input_verifier.rs
│   │       ├── i_pauser_set.rs
│   │       ├── ierc1822_proxiable.rs
│   │       ├── ierc1967.rs
│   │       ├── ierc5267.rs
│   │       ├── initializable.rs
│   │       ├── input_verifier.rs
│   │       ├── kms_verifier.rs
│   │       ├── math.rs
│   │       ├── message_hash_utils.rs
│   │       ├── mod.rs
│   │       ├── multicall_upgradeable.rs
│   │       ├── ownable2_step_upgradeable.rs
│   │       ├── ownable_upgradeable.rs
│   │       ├── panic.rs
│   │       ├── pausable_upgradeable.rs
│   │       ├── pauser_set.rs
│   │       ├── safe_cast.rs
│   │       ├── signed_math.rs
│   │       ├── storage_slot.rs
│   │       ├── strings.rs
│   │       ├── uups_upgradeable.rs
│   │       └── uups_upgradeable_empty_proxy.rs
│   ├── tasks/
│   │   ├── accounts.ts
│   │   ├── addPausers.ts
│   │   ├── blockExplorerVerify.ts
│   │   ├── ownership.ts
│   │   ├── pauseContracts.ts
│   │   ├── taskDeploy.ts
│   │   ├── taskUtils.ts
│   │   ├── upgradeContracts.ts
│   │   └── utils/
│   │       └── loadVariables.ts
│   ├── test/
│   │   ├── acl/
│   │   │   ├── TestIntegrationACL.t.sol
│   │   │   ├── acl.t.sol
│   │   │   └── acl.ts
│   │   ├── coprocessorUtils.ts
│   │   ├── eip712UpgradeableCrossChain/
│   │   │   └── EIP712UpgradeableCrossChain.t.sol
│   │   ├── encryptedERC20/
│   │   │   ├── EncryptedERC20.HCU.ts
│   │   │   ├── EncryptedERC20.fixture.ts
│   │   │   ├── EncryptedERC20.gas.ts
│   │   │   └── EncryptedERC20.ts
│   │   ├── fhevm-foundry/
│   │   │   └── TestHostContractsDeployerTestUtils.t.sol
│   │   ├── fhevmExecutor/
│   │   │   └── fhevmExecutor.t.sol
│   │   ├── fhevmOperations/
│   │   │   ├── fhevmOperations1.ts
│   │   │   ├── fhevmOperations10.ts
│   │   │   ├── fhevmOperations11.ts
│   │   │   ├── fhevmOperations12.ts
│   │   │   ├── fhevmOperations13.ts
│   │   │   ├── fhevmOperations2.ts
│   │   │   ├── fhevmOperations3.ts
│   │   │   ├── fhevmOperations4.ts
│   │   │   ├── fhevmOperations5.ts
│   │   │   ├── fhevmOperations6.ts
│   │   │   ├── fhevmOperations7.ts
│   │   │   ├── fhevmOperations8.ts
│   │   │   ├── fhevmOperations9.ts
│   │   │   └── manual.ts
│   │   ├── fhevmjsMocked.ts
│   │   ├── fhevmjsTest/
│   │   │   └── fhevmjsTest.ts
│   │   ├── hcuLimit/
│   │   │   ├── HCULimit.invariants.t.sol
│   │   │   ├── HCULimit.t.sol
│   │   │   └── HCULimit.ts
│   │   ├── inputVerifier/
│   │   │   ├── InputVerifier.t.sol
│   │   │   └── inputVerifier.ts
│   │   ├── instance.ts
│   │   ├── kmsVerifier/
│   │   │   ├── kmsVerifier.t.sol
│   │   │   └── kmsVerifier.ts
│   │   ├── makePubliclyDecryptable/
│   │   │   └── makePubliclyDecryptable.ts
│   │   ├── pauserSet/
│   │   │   └── pauserSet.ts
│   │   ├── paymentUtils.ts
│   │   ├── rand/
│   │   │   ├── Rand.fixture.ts
│   │   │   └── Rand.ts
│   │   ├── reencryption/
│   │   │   └── reencryption.ts
│   │   ├── regressions/
│   │   │   └── Regression1.ts
│   │   ├── signers.ts
│   │   ├── tasks/
│   │   │   ├── ownership.ts
│   │   │   └── pausing.ts
│   │   ├── tracing/
│   │   │   └── tracing.ts
│   │   ├── types.ts
│   │   ├── upgrades/
│   │   │   └── upgrades.ts
│   │   └── utils.ts
│   ├── tsconfig.json
│   └── upgrade-manifest.json
├── kms-connector/
│   ├── .cargo/
│   │   ├── audit.toml
│   │   └── deny.toml
│   ├── .dockerignore
│   ├── .gitignore
│   ├── .sqlx/
│   │   ├── query-05206597d00f58583f577f3d54ddd767c5696857085178cca25df687aa0cd39c.json
│   │   ├── query-05f22646520c5835fc3235aa6378dccd4436ca4a07ab25a9c8abe21760d5b202.json
│   │   ├── query-083e8a8de715c2a8dc806edb5aad8c9f92d1087059e7531e6232fde40e633f4e.json
│   │   ├── query-17db0e005e1367157721bf62877d735a9fb755f5d9afe72f069a1872ff1b7fd6.json
│   │   ├── query-1b85ab5815750616e2d237a43313f031d9913a515c3571e80890753a83ba350d.json
│   │   ├── query-25c322913225c0b6a6813fa1e1ecf78356784a6cda4a8d62f9c37a18720229d7.json
│   │   ├── query-2cba0042171405be7ad8ae68b8f2df139f79dbd8a70ad48aca3c15ab6933ed35.json
│   │   ├── query-44bb0537af9736b1121d933649a456ef6f0921b6ea86d05d76fd48d4bffe7db6.json
│   │   ├── query-4c8325bc7c94536f1950569e396e474e7be7ba99b731a67227a64a2381cec5d6.json
│   │   ├── query-4d063e25b766d3c96b516388f0682b12fd16ab2b6f0601d702c099c9725087b2.json
│   │   ├── query-4f17703247a738656e4f9205ebfb0e000a2d9322f23643a7bf0bbf5bafcfce4e.json
│   │   ├── query-536fab7b8d99df255619355b084cdb4de9279b5ec84ad4d79772d326b1099fc6.json
│   │   ├── query-59428c72c6afbb794abc7a14db053e575e50199aadb1fc8bfec5b68a5bcb4394.json
│   │   ├── query-645793d339e40d5c50c62c6895dc47244389bc994fc385eb88bbacc0ef54569e.json
│   │   ├── query-6739603e46f698938947ef34317afbf2cecdd04c61548297cf8fa4e4ff22d309.json
│   │   ├── query-715c77041e59d60ba8d591c3894f2ade038600a0e6042af211567c97133f6555.json
│   │   ├── query-72b5875fec8f017644c045dc7897fdc6798aabf9da3016fad71d0f3227d26e8e.json
│   │   ├── query-79dc656fa7a15579244340280891556d71e06ad34b8ada1bd29fba836d36dee7.json
│   │   ├── query-7bc09b14c9d4e82e1f22b6cc850786687c5e2557760b1dbed418ccfb0353b6be.json
│   │   ├── query-7bc37c994ea75c732017ff6c4eb36a56d23191c2a428af3e8847fde85a701b36.json
│   │   ├── query-7e6031fa69c6a6884bb9b3a7b2e19db0fef204f71ad8dde9bd8bc808b0cb25fd.json
│   │   ├── query-7f96aa6c8b04c991cbffa6548229e57039a9137d1a6b96a7b677b41382b6f1a7.json
│   │   ├── query-828ed7aa3de4737fcc54dbb2ffdf07098ab6ef7810a1f27ac7d7e0b5a083db69.json
│   │   ├── query-82fb484240d66011079463d32cdd026f08caf373070a3edd62d3ff93f24beffc.json
│   │   ├── query-982d9be537f18de31bf6aeb851c900564147c5317a6c556322c253af063a7874.json
│   │   ├── query-9b9900b9362cd670096512cf1b90c4ab8497593e3f10112f24e381164e907dfd.json
│   │   ├── query-a44b1d4e88190c3319559b50ae6cd8ade6b26b04b71e9a90b4a64bbf48a9bff8.json
│   │   ├── query-a4880722c49af43d7f6cb9816c113e332879762cdf89f2b13171c248f5a0a477.json
│   │   ├── query-a70444056f27bd68660c86bade10eccfac9cb5fd677de32dcc7bea043d3ca237.json
│   │   ├── query-a7b4dbcc2bd1d95a9ec562782e467612eff6a1663688e7ed7b5cb181807fd5f3.json
│   │   ├── query-ac8229a3ceb462177827da9963f51aaced2c230e0ae6603866711ca949d4a99f.json
│   │   ├── query-ac82565c4c15f51c6df30bd691519619bb6ff80098fe4e077ed2b43cf6ac525a.json
│   │   ├── query-af73e253d2f8f12077e59607c44ff182930372d1452c32330464c911c970754d.json
│   │   ├── query-b2c95c332dbf3437ce4ffe7aaaf0ea28dc853750911a5ef4e0cf5dfdfad1f872.json
│   │   ├── query-b3ee6c99edad54e3ef0f8a19bdc036142463f678111f32cf1ae8607e4a281634.json
│   │   ├── query-b9a438ed8f6a3380ae46c3ce699cb3f3edcb8b3ccbcceecb0a4951f75fd7cbd5.json
│   │   ├── query-ba6fac6612b9e8bf95649f9a527a4843bcb0d52cff4fc012e58dba0cbd5faf8a.json
│   │   ├── query-bac064549047cb319d62b7d3a639cfc3933fc455e8e97407aacba220f251a61f.json
│   │   ├── query-be7952ac7f042f7b4756783cb2c40cdc4b92eb360bc5ae95bb3ce3805a3c0a00.json
│   │   ├── query-c4846436287bb74b8286442658da646740df133377bd8ffdb4e3451283ced0b7.json
│   │   ├── query-c83e2d51b055f9915570e440fe0f5c13488ce0aa0b02cb23c69849cf5890f5fd.json
│   │   ├── query-cf48957852364ef9eb8a6aad14b456ede34b98987dea31b6b8e70fc14116d91b.json
│   │   ├── query-cf60be82db94427c2ec3236b82ad353f0b8b222e7a3453b43b2f7542f9c8ea62.json
│   │   ├── query-d0b5c0db41828ffa93492074e25d8c3401f1858435db7f7dc2bc59a257616c1c.json
│   │   ├── query-d564a5a734d0c2292b5ffc423ed7ed720e1efaa5f58e5cba101988f85a7c653f.json
│   │   ├── query-f1e7aa434bafae2d6278099212ea4534323ef5337b7ef31877697eaa182362cc.json
│   │   ├── query-f4cec78c0611edc0cf747320db7f0fb1c9eaec89303c3f3e45617b155fa9aed8.json
│   │   ├── query-f6af77062d47b06b0a1064ef06a1bf168a7efc68fde95f9b98bd182ecb30255b.json
│   │   └── query-fd2c52acba0232ef2f5e755c1b4fb595ebaf02cb3561cbaa1cc086f5ab6dc2ae.json
│   ├── Cargo.toml
│   ├── Dockerfile.workspace
│   ├── README.md
│   ├── config/
│   │   ├── gw-listener.toml
│   │   ├── kms-worker.toml
│   │   └── tx-sender.toml
│   ├── connector-db/
│   │   ├── Dockerfile
│   │   ├── docker-compose.yml
│   │   ├── init_db.sh
│   │   └── migrations/
│   │       ├── 20250604084502_gw_events.sql
│   │       ├── 20250604141515_decryption_response.sql
│   │       ├── 20250604143523_kms_worker_notify.sql
│   │       ├── 20250606125742_tx_sender_notify.sql
│   │       ├── 20250826111757_keygen_crs.sql
│   │       ├── 20251007112229_add_otlp_context.sql
│   │       ├── 20251025081948_prss_init.sql
│   │       ├── 20251026091602_refresh_keygen_reshare.sql
│   │       ├── 20251027122128_add_already_sent.sql
│   │       ├── 20251104142103_add_last_block_polled.sql
│   │       ├── 20251113084850_add_decryption_error_counter.sql
│   │       ├── 20251208161022_implem_garbage_collection.sql
│   │       ├── 20260122130522_add_tx_hash.sql
│   │       └── 20260203091107_timestamp_to_timestamptz.sql
│   ├── crates/
│   │   ├── gw-listener/
│   │   │   ├── Cargo.toml
│   │   │   ├── Dockerfile
│   │   │   ├── src/
│   │   │   │   ├── bin/
│   │   │   │   │   └── gw_listener.rs
│   │   │   │   ├── core/
│   │   │   │   │   ├── config.rs
│   │   │   │   │   ├── gw_listener.rs
│   │   │   │   │   ├── mod.rs
│   │   │   │   │   └── publish.rs
│   │   │   │   ├── lib.rs
│   │   │   │   └── monitoring/
│   │   │   │       ├── health.rs
│   │   │   │       ├── metrics.rs
│   │   │   │       └── mod.rs
│   │   │   └── tests/
│   │   │       ├── block_tracking.rs
│   │   │       ├── catchup.rs
│   │   │       ├── common/
│   │   │       │   └── mod.rs
│   │   │       ├── health.rs
│   │   │       └── integration_test.rs
│   │   ├── kms-worker/
│   │   │   ├── Cargo.toml
│   │   │   ├── Dockerfile
│   │   │   ├── src/
│   │   │   │   ├── bin/
│   │   │   │   │   └── kms_worker.rs
│   │   │   │   ├── core/
│   │   │   │   │   ├── config.rs
│   │   │   │   │   ├── event_picker/
│   │   │   │   │   │   ├── mod.rs
│   │   │   │   │   │   ├── notifier.rs
│   │   │   │   │   │   └── picker.rs
│   │   │   │   │   ├── event_processor/
│   │   │   │   │   │   ├── decryption.rs
│   │   │   │   │   │   ├── kms.rs
│   │   │   │   │   │   ├── kms_client.rs
│   │   │   │   │   │   ├── mod.rs
│   │   │   │   │   │   ├── processor.rs
│   │   │   │   │   │   └── s3.rs
│   │   │   │   │   ├── kms_response_publisher.rs
│   │   │   │   │   ├── kms_worker.rs
│   │   │   │   │   └── mod.rs
│   │   │   │   ├── lib.rs
│   │   │   │   └── monitoring/
│   │   │   │       ├── health.rs
│   │   │   │       ├── metrics.rs
│   │   │   │       └── mod.rs
│   │   │   └── tests/
│   │   │       ├── acl.rs
│   │   │       ├── attempt_limit.rs
│   │   │       ├── common/
│   │   │       │   └── mod.rs
│   │   │       ├── event_picker/
│   │   │       │   ├── main.rs
│   │   │       │   ├── notif.rs
│   │   │       │   ├── parallel.rs
│   │   │       │   ├── polling.rs
│   │   │       │   └── simple.rs
│   │   │       ├── health.rs
│   │   │       ├── integration_tests.rs
│   │   │       ├── response_publisher.rs
│   │   │       └── s3.rs
│   │   ├── tx-sender/
│   │   │   ├── Cargo.toml
│   │   │   ├── Dockerfile
│   │   │   ├── src/
│   │   │   │   ├── bin/
│   │   │   │   │   └── tx_sender.rs
│   │   │   │   ├── core/
│   │   │   │   │   ├── config.rs
│   │   │   │   │   ├── kms_response_picker/
│   │   │   │   │   │   ├── mod.rs
│   │   │   │   │   │   ├── notifier.rs
│   │   │   │   │   │   └── picker.rs
│   │   │   │   │   ├── mod.rs
│   │   │   │   │   └── tx_sender.rs
│   │   │   │   ├── lib.rs
│   │   │   │   └── monitoring/
│   │   │   │       ├── garbage_collection.rs
│   │   │   │       ├── health.rs
│   │   │   │       ├── metrics.rs
│   │   │   │       └── mod.rs
│   │   │   └── tests/
│   │   │       ├── data/
│   │   │       │   └── tx_out_of_gas/
│   │   │       │       ├── 1_estimate_gas.json
│   │   │       │       ├── 2_get_nonce.json
│   │   │       │       ├── 3_send_tx_sync.json
│   │   │       │       └── 4_debug_trace_tx.json
│   │   │       ├── gc.rs
│   │   │       ├── health.rs
│   │   │       ├── integration_tests.rs
│   │   │       └── response_picker/
│   │   │           ├── main.rs
│   │   │           ├── notif.rs
│   │   │           ├── parallel.rs
│   │   │           └── polling.rs
│   │   └── utils/
│   │       ├── Cargo.toml
│   │       ├── src/
│   │       │   ├── cli.rs
│   │       │   ├── config/
│   │       │   │   ├── contract.rs
│   │       │   │   ├── deserialize.rs
│   │       │   │   ├── error.rs
│   │       │   │   ├── mod.rs
│   │       │   │   └── wallet.rs
│   │       │   ├── conn.rs
│   │       │   ├── lib.rs
│   │       │   ├── monitoring/
│   │       │   │   ├── health.rs
│   │       │   │   ├── mod.rs
│   │       │   │   ├── otlp.rs
│   │       │   │   └── server.rs
│   │       │   ├── provider.rs
│   │       │   ├── signal.rs
│   │       │   ├── tasks.rs
│   │       │   ├── tests/
│   │       │   │   ├── db/
│   │       │   │   │   ├── mod.rs
│   │       │   │   │   ├── requests.rs
│   │       │   │   │   └── responses.rs
│   │       │   │   ├── mod.rs
│   │       │   │   ├── rand.rs
│   │       │   │   └── setup/
│   │       │   │       ├── common.rs
│   │       │   │       ├── db.rs
│   │       │   │       ├── deps.rs
│   │       │   │       ├── gw.rs
│   │       │   │       ├── host.rs
│   │       │   │       ├── instance.rs
│   │       │   │       ├── kms.rs
│   │       │   │       ├── mod.rs
│   │       │   │       ├── s3.rs
│   │       │   │       └── writer.rs
│   │       │   └── types/
│   │       │       ├── db.rs
│   │       │       ├── fhe.rs
│   │       │       ├── grpc.rs
│   │       │       ├── gw_event.rs
│   │       │       ├── kms_response.rs
│   │       │       └── mod.rs
│   │       └── tests/
│   │           └── data/
│   │               ├── 3a002df21130bda55f78d4403a73007a797f4a888174a620bbffc9052a045239
│   │               └── core-client-config.toml
│   ├── docs/
│   │   └── architecture.md
│   └── rust-toolchain.toml
├── library-solidity/
│   ├── .env.example
│   ├── .eslintignore
│   ├── .eslintrc.yml
│   ├── .gitignore
│   ├── .gitpod.yml
│   ├── .lintstagedrc.json
│   ├── .npmignore
│   ├── .prettierignore
│   ├── .prettierrc.json
│   ├── .solcover.js
│   ├── .soldeerignore
│   ├── .solhintignore
│   ├── CustomProvider.ts
│   ├── README.md
│   ├── SECURITY.md
│   ├── ci/
│   │   ├── Dockerfile
│   │   ├── docker-compose.yml
│   │   ├── requirements.txt
│   │   ├── scripts/
│   │   │   ├── prepare_fhe_keys_ci.sh
│   │   │   └── prepare_fhe_keys_for_e2e_test.sh
│   │   └── tests/
│   │       └── ERC20.py
│   ├── codegen/
│   │   ├── .prettierignore
│   │   ├── .prettierrc.json
│   │   ├── README.md
│   │   ├── codegen.mjs
│   │   ├── overloads/
│   │   │   ├── e2e.json
│   │   │   ├── host-contracts.json
│   │   │   └── library-solidity.json
│   │   ├── package.json
│   │   ├── src/
│   │   │   ├── common.ts
│   │   │   ├── config.ts
│   │   │   ├── fheTypeInfos.ts
│   │   │   ├── generateOverloads.ts
│   │   │   ├── hcuLimitGenerator.ts
│   │   │   ├── index.ts
│   │   │   ├── main.ts
│   │   │   ├── operators.ts
│   │   │   ├── operatorsPrices.ts
│   │   │   ├── paths.ts
│   │   │   ├── pseudoRand.ts
│   │   │   ├── templateFHEDotSol.ts
│   │   │   ├── templateFheTypeDotSol.ts
│   │   │   ├── templateImpDotSol.ts
│   │   │   ├── templates/
│   │   │   │   ├── FHE.sol-template
│   │   │   │   ├── FheType.sol-template
│   │   │   │   ├── FhevmECDSA.sol-template
│   │   │   │   └── Impl.sol-template
│   │   │   ├── testgen.ts
│   │   │   ├── utils.ts
│   │   │   └── validate.ts
│   │   ├── tsconfig.base.json
│   │   ├── tsconfig.build.json
│   │   └── tsconfig.json
│   ├── codegen.config.json
│   ├── commitlint.config.ts
│   ├── config/
│   │   └── ZamaConfig.sol
│   ├── examples/
│   │   ├── CoprocessorSetup.sol
│   │   ├── Counter.sol
│   │   ├── EncryptedERC20.sol
│   │   ├── HeadsOrTails.sol
│   │   ├── MakePubliclyDecryptable.sol
│   │   ├── OnchainPublicDecrypt.sol
│   │   ├── Rand.sol
│   │   ├── TestEthereumCoprocessorConfig.sol
│   │   ├── TracingSubCalls.sol
│   │   ├── multisig/
│   │   │   ├── EncryptedSetter.sol
│   │   │   ├── MultiSigHelper.sol
│   │   │   └── SimpleMultiSig.sol
│   │   └── tests/
│   │       ├── FHEVMManualTestSuite.sol
│   │       ├── FHEVMTestSuite1.sol
│   │       ├── FHEVMTestSuite2.sol
│   │       ├── FHEVMTestSuite3.sol
│   │       ├── FHEVMTestSuite4.sol
│   │       ├── FHEVMTestSuite5.sol
│   │       ├── FHEVMTestSuite6.sol
│   │       └── FHEVMTestSuite7.sol
│   ├── foundry.toml
│   ├── hardhat.config.ts
│   ├── lib/
│   │   ├── FHE.sol
│   │   ├── FheType.sol
│   │   ├── Impl.sol
│   │   └── cryptography/
│   │       └── FhevmECDSA.sol
│   ├── lib-js/
│   │   ├── common.ts
│   │   ├── fheTypeInfos.ts
│   │   └── operatorsPrices.ts
│   ├── mlc_config.json
│   ├── package.json
│   ├── remappings.txt
│   ├── tasks/
│   │   ├── accounts.ts
│   │   ├── addPausers.ts
│   │   ├── getEthereumAddress.ts
│   │   ├── taskDeploy.ts
│   │   ├── taskUtils.ts
│   │   └── utils/
│   │       └── loadVariables.ts
│   ├── test/
│   │   ├── EthereumConfig.t.sol
│   │   ├── FHEDelegation.t.sol
│   │   ├── FHEDenyList.t.sol
│   │   ├── coprocessorConfig/
│   │   │   └── testEthereumCoprocessorConfig.ts
│   │   ├── coprocessorUtils.ts
│   │   ├── encryptedERC20/
│   │   │   ├── EncryptedERC20.HCU.ts
│   │   │   ├── EncryptedERC20.fixture.ts
│   │   │   └── EncryptedERC20.ts
│   │   ├── fhevmOperations/
│   │   │   ├── fhevmOperations1.ts
│   │   │   ├── fhevmOperations10.ts
│   │   │   ├── fhevmOperations11.ts
│   │   │   ├── fhevmOperations12.ts
│   │   │   ├── fhevmOperations13.ts
│   │   │   ├── fhevmOperations2.ts
│   │   │   ├── fhevmOperations3.ts
│   │   │   ├── fhevmOperations4.ts
│   │   │   ├── fhevmOperations5.ts
│   │   │   ├── fhevmOperations6.ts
│   │   │   ├── fhevmOperations7.ts
│   │   │   ├── fhevmOperations8.ts
│   │   │   ├── fhevmOperations9.ts
│   │   │   └── manual.ts
│   │   ├── fhevmjsMocked.ts
│   │   ├── fhevmjsTest/
│   │   │   └── fhevmjsTest.ts
│   │   ├── instance.ts
│   │   ├── makePubliclyDecryptable/
│   │   │   └── makePubliclyDecryptable.ts
│   │   ├── multiSig/
│   │   │   ├── MultiSig.fixture.ts
│   │   │   └── MultiSig.ts
│   │   ├── onchainPublicDecrypt/
│   │   │   └── OnchainPublicDecrypt.ts
│   │   ├── rand/
│   │   │   ├── Rand.fixture.ts
│   │   │   └── Rand.ts
│   │   ├── signers.ts
│   │   ├── tracing/
│   │   │   └── tracing.ts
│   │   ├── types.ts
│   │   └── utils.ts
│   └── tsconfig.json
├── package.json
├── sdk/
│   └── rust-sdk/
│       ├── .gitignore
│       ├── Cargo.toml
│       ├── README.md
│       ├── examples/
│       │   ├── demo.rs
│       │   ├── input.rs
│       │   ├── keygen.rs
│       │   ├── minimal-eip712-signing.rs
│       │   ├── minimal-encrypted-input.rs
│       │   ├── minimal-public-decryption-request.rs
│       │   ├── minimal-public-decryption-response.rs
│       │   ├── minimal-sdk-setup.rs
│       │   ├── minimal-user-decryption-request.rs
│       │   ├── minimal-user-decryption-response.rs
│       │   ├── minimal-user-keys-generation.rs
│       │   └── user-decryption.rs
│       ├── scripts/
│       │   └── run-examples.sh
│       ├── src/
│       │   ├── blockchain/
│       │   │   ├── calldata.rs
│       │   │   └── mod.rs
│       │   ├── decryption/
│       │   │   ├── mod.rs
│       │   │   ├── public/
│       │   │   │   ├── deserializer.rs
│       │   │   │   ├── mod.rs
│       │   │   │   ├── request.rs
│       │   │   │   ├── response.rs
│       │   │   │   ├── types.rs
│       │   │   │   └── verification.rs
│       │   │   └── user/
│       │   │       ├── deserializer.rs
│       │   │       ├── mod.rs
│       │   │       ├── request.rs
│       │   │       ├── response.rs
│       │   │       └── types.rs
│       │   ├── encryption/
│       │   │   ├── input.rs
│       │   │   ├── mod.rs
│       │   │   └── primitives.rs
│       │   ├── lib.rs
│       │   ├── logging.rs
│       │   ├── signature/
│       │   │   ├── eip712/
│       │   │   │   ├── builder.rs
│       │   │   │   ├── mod.rs
│       │   │   │   ├── types.rs
│       │   │   │   └── verification.rs
│       │   │   └── mod.rs
│       │   └── utils.rs
│       └── test_data/
│           └── user_decryption_test_data.json
├── test-suite/
│   ├── .gitignore
│   ├── CHANGELOG.md
│   ├── README.md
│   ├── e2e/
│   │   ├── .env.devnet
│   │   ├── .env.example
│   │   ├── .gitignore
│   │   ├── .prettierrc.json
│   │   ├── Dockerfile
│   │   ├── README.md
│   │   ├── codegen.config.json
│   │   ├── contracts/
│   │   │   ├── E2ECoprocessorConfigLocal.sol
│   │   │   ├── EncryptedERC20.sol
│   │   │   ├── HTTPPublicDecrypt.sol
│   │   │   ├── Rand.sol
│   │   │   ├── SmartWalletWithDelegation.sol
│   │   │   ├── UserDecrypt.sol
│   │   │   ├── operations/
│   │   │   │   ├── FHEVMManualTestSuite.sol
│   │   │   │   ├── FHEVMTestSuite1.sol
│   │   │   │   ├── FHEVMTestSuite2.sol
│   │   │   │   ├── FHEVMTestSuite3.sol
│   │   │   │   ├── FHEVMTestSuite4.sol
│   │   │   │   ├── FHEVMTestSuite5.sol
│   │   │   │   ├── FHEVMTestSuite6.sol
│   │   │   │   ├── FHEVMTestSuite7.sol
│   │   │   │   └── SlowLaneContention.sol
│   │   │   └── smoke/
│   │   │       ├── SmokeTestInput.sol
│   │   │       └── TestInput.sol
│   │   ├── hardhat.config.ts
│   │   ├── package.json
│   │   ├── run-tests.sh
│   │   ├── scripts/
│   │   │   ├── smoke-inputflow.ts
│   │   │   └── smoke-reporting.ts
│   │   ├── test/
│   │   │   ├── consensusWatchdog.test.ts
│   │   │   ├── consensusWatchdog.ts
│   │   │   ├── delegatedUserDecryption/
│   │   │   │   └── delegatedUserDecryption.ts
│   │   │   ├── encryptedERC20/
│   │   │   │   ├── EncryptedERC20.HCU.ts
│   │   │   │   ├── EncryptedERC20.fixture.ts
│   │   │   │   └── EncryptedERC20.ts
│   │   │   ├── fhevmOperations/
│   │   │   │   ├── fhevmOperations1.ts
│   │   │   │   ├── fhevmOperations10.ts
│   │   │   │   ├── fhevmOperations100.ts
│   │   │   │   ├── fhevmOperations101.ts
│   │   │   │   ├── fhevmOperations102.ts
│   │   │   │   ├── fhevmOperations103.ts
│   │   │   │   ├── fhevmOperations104.ts
│   │   │   │   ├── fhevmOperations105.ts
│   │   │   │   ├── fhevmOperations11.ts
│   │   │   │   ├── fhevmOperations12.ts
│   │   │   │   ├── fhevmOperations13.ts
│   │   │   │   ├── fhevmOperations14.ts
│   │   │   │   ├── fhevmOperations15.ts
│   │   │   │   ├── fhevmOperations16.ts
│   │   │   │   ├── fhevmOperations17.ts
│   │   │   │   ├── fhevmOperations18.ts
│   │   │   │   ├── fhevmOperations19.ts
│   │   │   │   ├── fhevmOperations2.ts
│   │   │   │   ├── fhevmOperations20.ts
│   │   │   │   ├── fhevmOperations21.ts
│   │   │   │   ├── fhevmOperations22.ts
│   │   │   │   ├── fhevmOperations23.ts
│   │   │   │   ├── fhevmOperations24.ts
│   │   │   │   ├── fhevmOperations25.ts
│   │   │   │   ├── fhevmOperations26.ts
│   │   │   │   ├── fhevmOperations27.ts
│   │   │   │   ├── fhevmOperations28.ts
│   │   │   │   ├── fhevmOperations29.ts
│   │   │   │   ├── fhevmOperations3.ts
│   │   │   │   ├── fhevmOperations30.ts
│   │   │   │   ├── fhevmOperations31.ts
│   │   │   │   ├── fhevmOperations32.ts
│   │   │   │   ├── fhevmOperations33.ts
│   │   │   │   ├── fhevmOperations34.ts
│   │   │   │   ├── fhevmOperations35.ts
│   │   │   │   ├── fhevmOperations36.ts
│   │   │   │   ├── fhevmOperations37.ts
│   │   │   │   ├── fhevmOperations38.ts
│   │   │   │   ├── fhevmOperations39.ts
│   │   │   │   ├── fhevmOperations4.ts
│   │   │   │   ├── fhevmOperations40.ts
│   │   │   │   ├── fhevmOperations41.ts
│   │   │   │   ├── fhevmOperations42.ts
│   │   │   │   ├── fhevmOperations43.ts
│   │   │   │   ├── fhevmOperations44.ts
│   │   │   │   ├── fhevmOperations45.ts
│   │   │   │   ├── fhevmOperations46.ts
│   │   │   │   ├── fhevmOperations47.ts
│   │   │   │   ├── fhevmOperations48.ts
│   │   │   │   ├── fhevmOperations49.ts
│   │   │   │   ├── fhevmOperations5.ts
│   │   │   │   ├── fhevmOperations50.ts
│   │   │   │   ├── fhevmOperations51.ts
│   │   │   │   ├── fhevmOperations52.ts
│   │   │   │   ├── fhevmOperations53.ts
│   │   │   │   ├── fhevmOperations54.ts
│   │   │   │   ├── fhevmOperations55.ts
│   │   │   │   ├── fhevmOperations56.ts
│   │   │   │   ├── fhevmOperations57.ts
│   │   │   │   ├── fhevmOperations58.ts
│   │   │   │   ├── fhevmOperations59.ts
│   │   │   │   ├── fhevmOperations6.ts
│   │   │   │   ├── fhevmOperations60.ts
│   │   │   │   ├── fhevmOperations61.ts
│   │   │   │   ├── fhevmOperations62.ts
│   │   │   │   ├── fhevmOperations63.ts
│   │   │   │   ├── fhevmOperations64.ts
│   │   │   │   ├── fhevmOperations65.ts
│   │   │   │   ├── fhevmOperations66.ts
│   │   │   │   ├── fhevmOperations67.ts
│   │   │   │   ├── fhevmOperations68.ts
│   │   │   │   ├── fhevmOperations69.ts
│   │   │   │   ├── fhevmOperations7.ts
│   │   │   │   ├── fhevmOperations70.ts
│   │   │   │   ├── fhevmOperations71.ts
│   │   │   │   ├── fhevmOperations72.ts
│   │   │   │   ├── fhevmOperations73.ts
│   │   │   │   ├── fhevmOperations74.ts
│   │   │   │   ├── fhevmOperations75.ts
│   │   │   │   ├── fhevmOperations76.ts
│   │   │   │   ├── fhevmOperations77.ts
│   │   │   │   ├── fhevmOperations78.ts
│   │   │   │   ├── fhevmOperations79.ts
│   │   │   │   ├── fhevmOperations8.ts
│   │   │   │   ├── fhevmOperations80.ts
│   │   │   │   ├── fhevmOperations81.ts
│   │   │   │   ├── fhevmOperations82.ts
│   │   │   │   ├── fhevmOperations83.ts
│   │   │   │   ├── fhevmOperations84.ts
│   │   │   │   ├── fhevmOperations85.ts
│   │   │   │   ├── fhevmOperations86.ts
│   │   │   │   ├── fhevmOperations87.ts
│   │   │   │   ├── fhevmOperations88.ts
│   │   │   │   ├── fhevmOperations89.ts
│   │   │   │   ├── fhevmOperations9.ts
│   │   │   │   ├── fhevmOperations90.ts
│   │   │   │   ├── fhevmOperations91.ts
│   │   │   │   ├── fhevmOperations92.ts
│   │   │   │   ├── fhevmOperations93.ts
│   │   │   │   ├── fhevmOperations94.ts
│   │   │   │   ├── fhevmOperations95.ts
│   │   │   │   ├── fhevmOperations96.ts
│   │   │   │   ├── fhevmOperations97.ts
│   │   │   │   ├── fhevmOperations98.ts
│   │   │   │   ├── fhevmOperations99.ts
│   │   │   │   └── manual.ts
│   │   │   ├── fhevmjsTest/
│   │   │   │   └── fhevmjsTest.ts
│   │   │   ├── httpPublicDecrypt/
│   │   │   │   └── httpPublicDecrypt.ts
│   │   │   ├── instance.ts
│   │   │   ├── makePubliclyDecryptable/
│   │   │   │   └── makePubliclyDecryptable.ts
│   │   │   ├── pausedProtocol/
│   │   │   │   ├── pausedGateway.ts
│   │   │   │   └── pausedHost.ts
│   │   │   ├── rand/
│   │   │   │   ├── Rand.fixture.ts
│   │   │   │   └── Rand.ts
│   │   │   ├── signers.ts
│   │   │   ├── slowlane/
│   │   │   │   └── slowLaneContention.ts
│   │   │   ├── types.ts
│   │   │   ├── userDecryption/
│   │   │   │   └── userDecryption.ts
│   │   │   ├── userInput/
│   │   │   │   └── inputFlow.ts
│   │   │   └── utils.ts
│   │   └── tsconfig.json
│   ├── fhevm/
│   │   ├── config/
│   │   │   ├── core-client/
│   │   │   │   └── config.toml
│   │   │   ├── kms-core/
│   │   │   │   └── config.toml
│   │   │   ├── prometheus/
│   │   │   │   └── prometheus.yml
│   │   │   └── relayer/
│   │   │       └── local.yaml
│   │   ├── docker-compose/
│   │   │   ├── coprocessor-docker-compose.yml
│   │   │   ├── core-docker-compose.yml
│   │   │   ├── database-docker-compose.yml
│   │   │   ├── gateway-mocked-payment-docker-compose.yml
│   │   │   ├── gateway-node-docker-compose.yml
│   │   │   ├── gateway-pause-docker-compose.yml
│   │   │   ├── gateway-sc-docker-compose.yml
│   │   │   ├── gateway-unpause-docker-compose.yml
│   │   │   ├── host-node-docker-compose.yml
│   │   │   ├── host-pause-docker-compose.yml
│   │   │   ├── host-sc-docker-compose.yml
│   │   │   ├── host-unpause-docker-compose.yml
│   │   │   ├── kms-connector-docker-compose.yml
│   │   │   ├── minio-docker-compose.yml
│   │   │   ├── relayer-docker-compose.yml
│   │   │   ├── test-suite-docker-compose.yml
│   │   │   └── tracing-docker-compose.yml
│   │   ├── fhevm-cli
│   │   └── scripts/
│   │       ├── debug-container.sh
│   │       ├── deploy-fhevm-stack.sh
│   │       ├── inject-coprocessor-drift.sh
│   │       ├── run-ciphertext-drift-e2e.sh
│   │       └── setup-kms-signer-address.sh
│   └── gateway-stress/
│       ├── .sqlx/
│       │   ├── query-2f49a66126dda8f3e5f043ad8fa119691568ca3216e1a04715aa02322bf3723d.json
│       │   ├── query-6007239279928f6691a5284666e99fb6f020f20264c157500dbad47d7ec3dfa9.json
│       │   ├── query-6471556ae0071cc8896a01ad0f2f350416bf00d6d617422422f2368f5ec7c826.json
│       │   ├── query-7eb5ee37fa8e57c641712b895a5f59e0c484429e78626ccd5ad8b6d55a12267b.json
│       │   ├── query-a9ac11a0896006a03fd4260810c31bf236ebe89054f4c7e981490c596799585b.json
│       │   ├── query-affa510bdee616839e36215c598d07a20ca7af56c37fca94c0c1759dc2eba8ea.json
│       │   └── query-d6597f8cda1d06ba8a5adedc650047a8646bfa1f3c666f2cf0f29257268b3542.json
│       ├── Cargo.toml
│       ├── Dockerfile
│       ├── README.md
│       ├── config/
│       │   └── config.toml
│       ├── rust-toolchain.toml
│       ├── scripts/
│       │   └── gen_handles.py
│       ├── src/
│       │   ├── bench.rs
│       │   ├── blockchain/
│       │   │   ├── manager.rs
│       │   │   ├── mod.rs
│       │   │   ├── nonce_manager.rs
│       │   │   ├── provider.rs
│       │   │   └── wallet.rs
│       │   ├── cli.rs
│       │   ├── config.rs
│       │   ├── db/
│       │   │   ├── connector.rs
│       │   │   ├── manager.rs
│       │   │   ├── mod.rs
│       │   │   ├── request_builder.rs
│       │   │   ├── response_tracker.rs
│       │   │   └── types.rs
│       │   ├── decryption/
│       │   │   ├── mod.rs
│       │   │   ├── public.rs
│       │   │   ├── types.rs
│       │   │   └── user.rs
│       │   └── main.rs
│       └── templates/
│           ├── db_bench.csv
│           ├── gw_bench.csv
│           └── small_bench.csv
└── typos.toml

SYMBOL INDEX (7481 symbols across 255 files)

FILE: ci/benchmark_parser.py
  class BenchType (line 107) | class BenchType(enum.Enum):
  function recursive_parse (line 116) | def recursive_parse(
  function _create_point (line 237) | def _create_point(
  function parse_benchmark_file (line 251) | def parse_benchmark_file(directory):
  function parse_estimate_file (line 266) | def parse_estimate_file(directory):
  function _parse_key_results (line 281) | def _parse_key_results(result_file, crate, bench_type):
  function parse_object_sizes (line 318) | def parse_object_sizes(result_file, crate):
  function parse_key_gen_time (line 330) | def parse_key_gen_time(result_file, crate):
  function get_parameters (line 342) | def get_parameters(bench_id, directory):
  function compute_ops_per_dollar (line 364) | def compute_ops_per_dollar(data_point, product_hourly_cost):
  function compute_ops_per_second (line 376) | def compute_ops_per_second(data_point):
  function _parse_file_to_json (line 387) | def _parse_file_to_json(directory, filename):
  function dump_results (line 392) | def dump_results(parsed_results, filename, input_args):
  function check_mandatory_args (line 421) | def check_mandatory_args(input_args):

FILE: ci/check-upgrade-versions.ts
  constant VERSION_RE (line 21) | const VERSION_RE = /(?<name>REINITIALIZER_VERSION|MAJOR_VERSION|MINOR_VE...
  function extractVersions (line 23) | function extractVersions(filePath: string) {
  function forgeInspect (line 32) | function forgeInspect(contract: string, root: string): string | null {

FILE: ci/contracts_bindings_update.py
  class ProjectConfig (line 22) | class ProjectConfig:
    method __init__ (line 25) | def __init__(self, name: str, root_dir: Path, skip_patterns: list[str]...
    method get_skip_args (line 32) | def get_skip_args(self) -> str:
  function parse_semver (line 55) | def parse_semver(version_str: str) -> tuple:
  function init_cli (line 60) | def init_cli() -> ArgumentParser:
  function main (line 88) | def main():
  class ExitStatus (line 106) | class ExitStatus(Enum):
  class BindingsUpdater (line 115) | class BindingsUpdater:
    method __init__ (line 127) | def __init__(self, config: ProjectConfig):
    method __del__ (line 135) | def __del__(self):
    method _check_forge_installed (line 139) | def _check_forge_installed():
    method check_bindings_up_to_date (line 175) | def check_bindings_up_to_date(self):
    method update_bindings (line 197) | def update_bindings(self):
    method check_version (line 215) | def check_version(self):
    method update_crate_version (line 252) | def update_crate_version(self):
  function log_info (line 292) | def log_info(msg: str):
  function log_success (line 296) | def log_success(msg: str):
  function log_error (line 300) | def log_error(msg: str):
  function log_warning (line 304) | def log_warning(msg: str):

FILE: ci/local_docs_link_check.py
  function check_content_for_dead_links (line 19) | def check_content_for_dead_links(
  function is_relative_to (line 88) | def is_relative_to(path: Path, other_path: Union[str, Path]) -> bool:
  function main (line 108) | def main():

FILE: ci/merge-address-constants.ts
  constant ADDRESS_RE (line 35) | const ADDRESS_RE = /^address\s+constant\s+(\w+)\s*=\s*(0x[0-9a-fA-F]+)\s...
  type AddressConstant (line 37) | interface AddressConstant {
  function parseAddressFile (line 47) | function parseAddressFile(content: string): { header: string; constants:...
  function mergeConstants (line 71) | function mergeConstants(
  function renderAddressFile (line 97) | function renderAddressFile(header: string, constants: AddressConstant[])...

FILE: coprocessor/fhevm-engine/db-migration/migrations/20240722111257_coprocessor.sql
  type computations (line 2) | CREATE TABLE IF NOT EXISTS computations (
  type ciphertexts (line 19) | CREATE TABLE IF NOT EXISTS ciphertexts (
  type input_blobs (line 33) | CREATE TABLE IF NOT EXISTS input_blobs (
  type tenants (line 42) | CREATE TABLE IF NOT EXISTS tenants (
  type computations_dependencies_index (line 59) | CREATE INDEX IF NOT EXISTS computations_dependencies_index ON computatio...
  type computations_completed_index (line 60) | CREATE INDEX IF NOT EXISTS computations_completed_index ON computations ...
  type computations_errors_index (line 61) | CREATE INDEX IF NOT EXISTS computations_errors_index ON computations (is...
  type tenants_by_api_key (line 62) | CREATE UNIQUE INDEX IF NOT EXISTS tenants_by_api_key ON tenants (tenant_...

FILE: coprocessor/fhevm-engine/db-migration/migrations/20250205130209_create_pbs_computations_table.sql
  type pbs_computations (line 1) | CREATE TABLE IF NOT EXISTS pbs_computations (
  type pbs_computations_handle_hash_idx (line 11) | CREATE INDEX IF NOT EXISTS pbs_computations_handle_hash_idx ON pbs_compu...
  type ciphertexts_handle_hash_idx (line 12) | CREATE INDEX IF NOT EXISTS ciphertexts_handle_hash_idx ON ciphertexts US...

FILE: coprocessor/fhevm-engine/db-migration/migrations/20250207092623_verify_proofs.sql
  type verify_proofs (line 1) | CREATE TABLE IF NOT EXISTS verify_proofs (
  type idx_verify_proofs_verified_retry (line 16) | CREATE INDEX IF NOT EXISTS idx_verify_proofs_verified_retry ON verify_pr...

FILE: coprocessor/fhevm-engine/db-migration/migrations/20250217133315_add_table_blocks_valid.sql
  type blocks_valid (line 1) | CREATE TABLE IF NOT EXISTS blocks_valid (

FILE: coprocessor/fhevm-engine/db-migration/migrations/20250221112128_gw_listener_last_block.sql
  type gw_listener_last_block (line 1) | CREATE TABLE IF NOT EXISTS gw_listener_last_block (

FILE: coprocessor/fhevm-engine/db-migration/migrations/20250303135355_fhevm_listner_auto_notify.sql
  function notify_work_available (line 2) | CREATE OR REPLACE FUNCTION notify_work_available()

FILE: coprocessor/fhevm-engine/db-migration/migrations/20250310120834_create_ciphertext_digest.sql
  type ciphertext_digest (line 3) | CREATE TABLE ciphertext_digest (

FILE: coprocessor/fhevm-engine/db-migration/migrations/20250317140442_create_allow_handle.sql
  type allowed_handles (line 1) | CREATE TABLE allowed_handles (

FILE: coprocessor/fhevm-engine/db-migration/migrations/20250512084614_fhevm_listner_auto_notify_acl.sql
  function notify_event_pbs_computations (line 2) | CREATE OR REPLACE FUNCTION notify_event_pbs_computations()
  function notify_event_allowed_handle (line 18) | CREATE OR REPLACE FUNCTION notify_event_allowed_handle()

FILE: coprocessor/fhevm-engine/db-migration/migrations/20250729115448_ciphertext_digest_txn_info.sql
  type idx_ciphertext_digest_txn_block_number (line 5) | CREATE INDEX IF NOT EXISTS idx_ciphertext_digest_txn_block_number ON cip...

FILE: coprocessor/fhevm-engine/db-migration/migrations/20250729123642_allowed_handles_txn_info.sql
  type idx_allowed_handles_txn_block_number (line 5) | CREATE INDEX IF NOT EXISTS idx_allowed_handles_txn_block_number ON allow...

FILE: coprocessor/fhevm-engine/db-migration/migrations/20250801080000_computations_transaction_id.sql
  type idx_computations_transaction_id (line 10) | CREATE INDEX IF NOT EXISTS idx_computations_transaction_id
  type idx_computations_schedule_order (line 13) | CREATE INDEX IF NOT EXISTS idx_computations_schedule_order
  type idx_computations_dependence_chain (line 17) | CREATE INDEX IF NOT EXISTS idx_computations_dependence_chain

FILE: coprocessor/fhevm-engine/db-migration/migrations/20250801080001_allowed_handles_computed_flag.sql
  type idx_allowed_handles_is_computed (line 10) | CREATE INDEX IF NOT EXISTS idx_allowed_handles_is_computed
  type idx_allowed_handles_allowed_at (line 12) | CREATE INDEX IF NOT EXISTS idx_allowed_handles_allowed_at
  type idx_allowed_handles_handle (line 15) | CREATE INDEX IF NOT EXISTS idx_allowed_handles_handle

FILE: coprocessor/fhevm-engine/db-migration/migrations/20250831080000_allowed_handles_schedule_order.sql
  type idx_allowed_handles_schedule_order (line 5) | CREATE INDEX IF NOT EXISTS idx_allowed_handles_schedule_order

FILE: coprocessor/fhevm-engine/db-migration/migrations/20250920080000_computations_scheduling.sql
  type idx_computations_is_allowed (line 15) | CREATE INDEX IF NOT EXISTS idx_computations_is_allowed
  type idx_computations_schedule_order (line 18) | CREATE INDEX IF NOT EXISTS idx_computations_schedule_order
  type idx_computations_pk (line 21) | CREATE INDEX IF NOT EXISTS idx_computations_pk

FILE: coprocessor/fhevm-engine/db-migration/migrations/20250929064611_create_transactions_table.sql
  type idx_pbs_computations_transactions (line 4) | CREATE INDEX IF NOT EXISTS idx_pbs_computations_transactions ON pbs_comp...
  type idx_allowed_handles_transactions (line 9) | CREATE INDEX IF NOT EXISTS idx_allowed_handles_transactions ON allowed_h...
  type idx_verify_proofs_transactions (line 14) | CREATE INDEX IF NOT EXISTS idx_verify_proofs_transactions ON verify_proo...
  type idx_ciphertext_digest_transactions (line 19) | CREATE INDEX IF NOT EXISTS idx_ciphertext_digest_transactions ON ciphert...
  type transactions (line 21) | CREATE TABLE transactions (

FILE: coprocessor/fhevm-engine/db-migration/migrations/20251002083309_add_transactions_index.sql
  type idx_transactions_completed_createdat (line 2) | CREATE INDEX idx_transactions_completed_createdat
  type idx_transactions_incomplete_createdat (line 7) | CREATE INDEX idx_transactions_incomplete_createdat

FILE: coprocessor/fhevm-engine/db-migration/migrations/20251006080000_computations_auto_notify.sql
  function notify_work_available (line 2) | CREATE OR REPLACE FUNCTION notify_work_available()

FILE: coprocessor/fhevm-engine/db-migration/migrations/20251013083601_delegations.sql
  type delegate_user_decrypt (line 1) | CREATE TABLE IF NOT EXISTS delegate_user_decrypt (
  type idx_delegate_user_decrypt_block_number (line 21) | CREATE INDEX IF NOT EXISTS idx_delegate_user_decrypt_block_number
  type idx_delegate_user_decrypt_on_gateway_reorg_out (line 24) | CREATE INDEX IF NOT EXISTS idx_delegate_user_decrypt_on_gateway_reorg_out
  type idx_delegate_user_decrypt_block_hash (line 27) | CREATE INDEX IF NOT EXISTS idx_delegate_user_decrypt_block_hash

FILE: coprocessor/fhevm-engine/db-migration/migrations/20251015000000_host_listener_poller_state.sql
  type host_listener_poller_state (line 1) | CREATE TABLE IF NOT EXISTS host_listener_poller_state (

FILE: coprocessor/fhevm-engine/db-migration/migrations/20251126110000_computations_created_at_index.sql
  type idx_computations_created_at (line 1) | CREATE INDEX IF NOT EXISTS idx_computations_created_at

FILE: coprocessor/fhevm-engine/db-migration/migrations/20251203140023_ciphertext_digest_idx_sent_and_handle.sql
  type idx_ciphertext_digest_handle (line 6) | CREATE INDEX IF NOT EXISTS idx_ciphertext_digest_handle
  type idx_ciphertext_digest_unsent (line 10) | CREATE INDEX IF NOT EXISTS idx_ciphertext_digest_unsent

FILE: coprocessor/fhevm-engine/db-migration/migrations/20251205070512_add_pbs_computations_created_at_idx.sql
  type idx_pending_tasks (line 4) | CREATE INDEX idx_pending_tasks

FILE: coprocessor/fhevm-engine/db-migration/migrations/20251205154454_create_dependence_chain_table.sql
  type dependence_chain (line 1) | CREATE TABLE dependence_chain (
  type idx_pending_dependence_chain (line 19) | CREATE INDEX idx_pending_dependence_chain
  type idx_dependence_chain_worker_id (line 23) | CREATE INDEX idx_dependence_chain_worker_id
  type idx_dependence_chain_worker_id_and_dependence_chain_id (line 26) | CREATE INDEX idx_dependence_chain_worker_id_and_dependence_chain_id
  type idx_dependence_chain_processing_by_worker (line 29) | CREATE INDEX idx_dependence_chain_processing_by_worker

FILE: coprocessor/fhevm-engine/db-migration/migrations/20251218162249_extend_dcid_table.sql
  type idx_pending_dependence_chain (line 13) | CREATE INDEX idx_pending_dependence_chain

FILE: coprocessor/fhevm-engine/db-migration/migrations/20251221080000_dependence_chain_index_processed_last_updated.sql
  type idx_dependence_chain_processed_last_updated (line 1) | CREATE INDEX idx_dependence_chain_processed_last_updated

FILE: coprocessor/fhevm-engine/db-migration/migrations/20251224110000_ciphertexts_partial_indexes.sql
  type idx_ciphertexts_tenant_handle (line 4) | CREATE INDEX IF NOT EXISTS idx_ciphertexts_tenant_handle
  type idx_ciphertexts_created_at (line 8) | CREATE INDEX IF NOT EXISTS idx_ciphertexts_created_at
  type idx_ciphertext_digest_ciphertext_null (line 13) | CREATE INDEX IF NOT EXISTS idx_ciphertext_digest_ciphertext_null
  type idx_ciphertext_digest_ciphertext128_null (line 16) | CREATE INDEX IF NOT EXISTS idx_ciphertext_digest_ciphertext128_null
  type idx_ciphertexts_ciphertext_null (line 19) | CREATE INDEX IF NOT EXISTS idx_ciphertexts_ciphertext_null
  type idx_ciphertexts_ciphertext128_null (line 22) | CREATE INDEX IF NOT EXISTS idx_ciphertexts_ciphertext128_null

FILE: coprocessor/fhevm-engine/db-migration/migrations/20251230155309_improve_sns_and_txsend_select_indexing.sql
  type idx_pbs_computations_pending_created_at (line 3) | CREATE INDEX IF NOT EXISTS idx_pbs_computations_pending_created_at
  type idx_ciphertexts_handle_not_null (line 7) | CREATE INDEX IF NOT EXISTS idx_ciphertexts_handle_not_null
  type idx_allowed_txn_is_sent (line 13) | CREATE INDEX IF NOT EXISTS idx_allowed_txn_is_sent
  type idx_allowed_txn_retries (line 16) | CREATE INDEX IF NOT EXISTS idx_allowed_txn_retries

FILE: coprocessor/fhevm-engine/db-migration/migrations/20260105120000_dependence_chain_proofs_indexing.sql
  type idx_verify_proofs_retry_count (line 3) | CREATE INDEX IF NOT EXISTS idx_verify_proofs_retry_count
  type idx_dependence_chain_unlock (line 8) | CREATE INDEX IF NOT EXISTS idx_dependence_chain_unlock

FILE: coprocessor/fhevm-engine/db-migration/migrations/20260106150619_create_ciphertexts128_table.sql
  type ciphertexts128 (line 1) | CREATE TABLE ciphertexts128 (
  type idx_ciphertexts128_handle (line 10) | CREATE INDEX idx_ciphertexts128_handle

FILE: coprocessor/fhevm-engine/db-migration/migrations/20260110190000_index_dependence_chain.sql
  type idx_dependence_chain_last_updated_at (line 1) | CREATE INDEX IF NOT EXISTS idx_dependence_chain_last_updated_at

FILE: coprocessor/fhevm-engine/db-migration/migrations/20260128095635_remove_tenants.sql
  type keys (line 18) | CREATE TABLE keys (
  type crs (line 35) | CREATE TABLE crs (
  type host_chains (line 48) | CREATE TABLE host_chains (
  type idx_allowed_handles_no_tenant (line 83) | CREATE UNIQUE INDEX idx_allowed_handles_no_tenant ON allowed_handles (ha...
  type idx_input_blobs_no_tenant (line 84) | CREATE UNIQUE INDEX idx_input_blobs_no_tenant ON input_blobs (blob_hash)
  type idx_ciphertext_digest_no_tenant (line 85) | CREATE UNIQUE INDEX idx_ciphertext_digest_no_tenant ON ciphertext_digest...
  type idx_ciphertexts_no_tenant (line 86) | CREATE UNIQUE INDEX idx_ciphertexts_no_tenant ON ciphertexts (handle, ci...
  type idx_ciphertexts128_no_tenant (line 87) | CREATE UNIQUE INDEX idx_ciphertexts128_no_tenant ON ciphertexts128 (handle)
  type idx_computations_no_tenant (line 88) | CREATE UNIQUE INDEX idx_computations_no_tenant ON computations (output_h...
  type idx_pbs_computations_no_tenant (line 89) | CREATE UNIQUE INDEX idx_pbs_computations_no_tenant ON pbs_computations (...

FILE: coprocessor/fhevm-engine/db-migration/migrations/20260204130000_dependence_chain_schedule_priority.sql
  type idx_pending_dependence_chain (line 7) | CREATE INDEX idx_pending_dependence_chain

FILE: coprocessor/fhevm-engine/fhevm-engine-common/build.rs
  function main (line 3) | fn main() {

FILE: coprocessor/fhevm-engine/fhevm-engine-common/src/bin/generate_keys.rs
  function main (line 3) | fn main() {

FILE: coprocessor/fhevm-engine/fhevm-engine-common/src/chain_id.rs
  type ChainId (line 12) | pub struct ChainId(i64);
    method as_i64 (line 23) | pub fn as_i64(self) -> i64 {
    method as_u64 (line 30) | pub fn as_u64(self) -> u64 {
    type Error (line 36) | type Error = InvalidChainId;
    method try_from (line 38) | fn try_from(value: i64) -> Result<Self, Self::Error> {
    type Error (line 50) | type Error = InvalidChainId;
    method try_from (line 52) | fn try_from(value: u64) -> Result<Self, Self::Error> {
    type Error (line 64) | type Error = InvalidChainId;
    method try_from (line 66) | fn try_from(value: U256) -> Result<Self, Self::Error> {
    method fmt (line 83) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  type InvalidChainId (line 16) | pub struct InvalidChainId {
  method from (line 77) | fn from(id: ChainId) -> Self {
  function valid_i64 (line 93) | fn valid_i64() {
  function valid_u64 (line 100) | fn valid_u64() {
  function zero_is_valid (line 107) | fn zero_is_valid() {
  function max_i64 (line 120) | fn max_i64() {
  function rejects_negative_i64 (line 127) | fn rejects_negative_i64() {
  function rejects_overflow_u64 (line 132) | fn rejects_overflow_u64() {
  function valid_u256 (line 138) | fn valid_u256() {
  function rejects_overflow_u256 (line 144) | fn rejects_overflow_u256() {
  function into_u256 (line 149) | fn into_u256() {
  function display (line 156) | fn display() {

FILE: coprocessor/fhevm-engine/fhevm-engine-common/src/crs.rs
  type CrsId (line 8) | pub type CrsId = Vec<u8>;
  type Crs (line 11) | pub struct Crs {
  type CrsCache (line 17) | pub struct CrsCache {
    method load (line 22) | pub async fn load(pool: &PgPool) -> Result<Self> {
    method get_latest (line 39) | pub fn get_latest(&self) -> Option<&Crs> {

FILE: coprocessor/fhevm-engine/fhevm-engine-common/src/db_keys.rs
  type DbKeyId (line 14) | pub type DbKeyId = Vec<u8>;
  type DbKeyCache (line 17) | pub struct DbKeyCache {
    method new (line 22) | pub fn new(capacity: usize) -> anyhow::Result<Self> {
    method fetch (line 30) | pub async fn fetch<'a, T>(&self, db_key_id: &DbKeyId, executor: T) -> ...
    method fetch_latest (line 47) | pub async fn fetch_latest<'a, T>(&self, executor: T) -> anyhow::Result...
    method populate (line 128) | pub async fn populate<'a, T>(
    method query_db_keys (line 168) | async fn query_db_keys<'a, T>(
  type DbKey (line 242) | pub struct DbKey {
  constant CHUNK_SIZE (line 258) | const CHUNK_SIZE: i32 = 64 * 1024;
  function read_keys_from_large_object_by_key_id_gw (line 260) | pub async fn read_keys_from_large_object_by_key_id_gw(
  function read_large_object_in_chunks (line 277) | async fn read_large_object_in_chunks(
  function write_large_object_in_chunks (line 362) | pub async fn write_large_object_in_chunks(
  function write_large_object_in_chunks_tx (line 373) | pub async fn write_large_object_in_chunks_tx(

FILE: coprocessor/fhevm-engine/fhevm-engine-common/src/gpu_memory.rs
  method move_to_current_device (line 16) | pub fn move_to_current_device(&mut self) {
  method get_size_on_gpu (line 34) | pub fn get_size_on_gpu(&self) -> u64 {
  function get_supported_ct_size_on_gpu (line 56) | pub fn get_supported_ct_size_on_gpu(ct_type: i16) -> u64 {
  function reserve_memory_on_gpu (line 66) | pub fn reserve_memory_on_gpu(amount: u64, idx: usize) {
  function release_memory_on_gpu (line 79) | pub fn release_memory_on_gpu(amount: u64, idx: usize) {
  function get_op_size_on_gpu (line 85) | pub fn get_op_size_on_gpu(

FILE: coprocessor/fhevm-engine/fhevm-engine-common/src/healthz_server.rs
  type HealthResponse (line 18) | struct HealthResponse {
    method from (line 26) | fn from(status: HealthStatus) -> Self {
  type Version (line 65) | pub struct Version {
  type HealthCheckService (line 71) | pub trait HealthCheckService: Send + Sync {
    method health_check (line 72) | fn health_check(&self) -> impl std::future::Future<Output = HealthStat...
    method is_alive (line 73) | fn is_alive(&self) -> impl std::future::Future<Output = bool> + Send;
    method get_version (line 74) | fn get_version(&self) -> Version;
  function default_get_version (line 79) | pub fn default_get_version() -> Version {
  type HttpServer (line 87) | pub struct HttpServer<S: HealthCheckService + Send + Sync + 'static> {
  function new (line 94) | pub fn new(service: Arc<S>, port: u16, cancel_token: CancellationToken) ...
  function start (line 101) | pub async fn start(&self) -> anyhow::Result<()> {
  function health_handler (line 130) | async fn health_handler(State(service): State<Arc<S>>) -> impl IntoRespo...
  function liveness_handler (line 141) | async fn liveness_handler(State(service): State<Arc<S>>) -> impl IntoRes...
  function version_handler (line 161) | async fn version_handler(State(service): State<Arc<S>>) -> impl IntoResp...
  type HealthStatus (line 168) | pub struct HealthStatus {
    method set_db_connected (line 180) | pub async fn set_db_connected(&mut self, pool: &PgPool) {
    method set_blockchain_connected (line 199) | pub async fn set_blockchain_connected(&mut self, provider: &Blockchain...
    method set_custom_check (line 218) | pub fn set_custom_check(&mut self, check: &'static str, value: bool, i...
    method add_error_details (line 223) | pub fn add_error_details(&mut self, details: String) {
    method is_healthy (line 227) | pub fn is_healthy(&self) -> bool {
    method push_error_details (line 231) | fn push_error_details(&mut self, details: &str) {
    method error_details (line 235) | pub fn error_details(&self) -> String {

FILE: coprocessor/fhevm-engine/fhevm-engine-common/src/host_chains.rs
  type HostChain (line 7) | pub struct HostChain {
  type HostChainsCache (line 14) | pub struct HostChainsCache {
    method load (line 19) | pub async fn load(pool: &PgPool) -> Result<Self> {
    method all (line 39) | pub fn all(&self) -> Vec<&HostChain> {
    method get_chain (line 43) | pub fn get_chain(&self, chain_id: ChainId) -> Option<&HostChain> {

FILE: coprocessor/fhevm-engine/fhevm-engine-common/src/keys.rs
  constant TFHE_PARAMS (line 22) | pub const TFHE_PARAMS: AtomicPatternParameters = cpu_meta_parameters.com...
  constant TFHE_COMPRESSION_PARAMS (line 24) | pub const TFHE_COMPRESSION_PARAMS: CompressionParameters = cpu_meta_para...
  constant TFHE_COMPACT_PK_PARAMS (line 28) | pub const TFHE_COMPACT_PK_PARAMS: DedicatedCompactPublicKeyParameters = ...
  constant TFHE_NOISE_SQUASHING_PARAMS (line 31) | pub const TFHE_NOISE_SQUASHING_PARAMS: MetaNoiseSquashingParameters = cp...
  constant TFHE_PKS_RERANDOMIZATION_PARAMS (line 34) | pub const TFHE_PKS_RERANDOMIZATION_PARAMS: ShortintKeySwitchingParameter...
  constant TFHE_PARAMS (line 39) | pub const TFHE_PARAMS: AtomicPatternParameters = gpu_meta_parameters.com...
  constant TFHE_COMPRESSION_PARAMS (line 41) | pub const TFHE_COMPRESSION_PARAMS: CompressionParameters = gpu_meta_para...
  constant MAX_BITS_TO_PROVE (line 45) | pub const MAX_BITS_TO_PROVE: usize = 2048;
  type FhevmKeys (line 48) | pub struct FhevmKeys {
    method new (line 80) | pub fn new() -> Self {
    method new_config (line 131) | pub fn new_config() -> Config {
    method set_server_key_for_current_thread (line 148) | pub fn set_server_key_for_current_thread(&self) {
    method set_gpu_server_key_for_current_thread (line 151) | pub fn set_gpu_server_key_for_current_thread(&self) {
    method from (line 268) | fn from(f: SerializedFhevmKeys) -> Self {
  type SerializedFhevmKeys (line 61) | pub struct SerializedFhevmKeys {
    constant DIRECTORY (line 160) | const DIRECTORY: &'static str = "../fhevm-keys";
    constant SKS (line 162) | const SKS: &'static str = "../fhevm-keys/sks";
    constant CKS (line 164) | const CKS: &'static str = "../fhevm-keys/cks";
    constant PKS (line 166) | const PKS: &'static str = "../fhevm-keys/pks";
    constant PUBLIC_PARAMS (line 168) | const PUBLIC_PARAMS: &'static str = "../fhevm-keys/pp";
    constant FULL_SKS (line 170) | const FULL_SKS: &'static str = "../fhevm-keys/sns_pk";
    constant GPU_CSKS (line 173) | const GPU_CSKS: &'static str = "../fhevm-keys/gpu-csks";
    constant GPU_CKS (line 175) | const GPU_CKS: &'static str = "../fhevm-keys/gpu-cks";
    constant GPU_PKS (line 177) | const GPU_PKS: &'static str = "../fhevm-keys/gpu-pks";
    constant GPU_PUBLIC_PARAMS (line 179) | const GPU_PUBLIC_PARAMS: &'static str = "../fhevm-keys/gpu-pp";
    method save_to_disk (line 182) | pub fn save_to_disk(self) {
    method load_from_disk (line 223) | pub fn load_from_disk(keys_directory: &str) -> Self {
    method from (line 252) | fn from(f: FhevmKeys) -> Self {
  method default (line 74) | fn default() -> Self {

FILE: coprocessor/fhevm-engine/fhevm-engine-common/src/metrics_server.rs
  type HttpServer (line 12) | struct HttpServer {
    method new (line 18) | pub fn new(addr: &str, cancel_token: CancellationToken) -> Self {
    method run (line 25) | pub async fn run(&self) -> io::Result<()> {
    method metrics_handler (line 49) | async fn metrics_handler() -> impl IntoResponse {
  function spawn (line 63) | pub fn spawn(addr: Option<String>, cancel_token: CancellationToken) -> O...
  function metrics_future (line 74) | pub fn metrics_future(

FILE: coprocessor/fhevm-engine/fhevm-engine-common/src/pg_pool.rs
  constant CODE_DEADLOCK_DETECTED (line 12) | const CODE_DEADLOCK_DETECTED: &str = "40P01";
  type PostgresPoolManager (line 15) | pub struct PostgresPoolManager {
    method connect_pool (line 26) | pub async fn connect_pool(
    method spawn_with_db_retry (line 119) | pub async fn spawn_with_db_retry<F, Fut>(&self, op: F, name: &str) -> ...
    method spawn_join_set_with_db_retry (line 136) | pub async fn spawn_join_set_with_db_retry<F, Fut>(
    method blocking_with_db_retry (line 158) | pub async fn blocking_with_db_retry<F, Fut>(
    method run_with_db_retry (line 174) | async fn run_with_db_retry<F, Fut>(self, operation: F) -> Result<(), S...
    method pool (line 230) | pub fn pool(&self) -> Pool<Postgres> {
    method span (line 234) | fn span(name: &str) -> tracing::Span {
  type Params (line 240) | pub struct Params {
  type ServiceError (line 250) | pub enum ServiceError {
  function enable_auto_explain (line 262) | async fn enable_auto_explain(
  function cancellable_sleep (line 292) | async fn cancellable_sleep(cancel_token: &CancellationToken, duration: D...

FILE: coprocessor/fhevm-engine/fhevm-engine-common/src/telemetry.rs
  type TracerProviderGuard (line 20) | pub struct TracerProviderGuard {
    method new (line 25) | fn new(trace_provider: SdkTracerProvider) -> Self {
    method shutdown_once (line 31) | fn shutdown_once(&mut self) {
  method drop (line 41) | fn drop(&mut self) {
  function init_json_subscriber (line 64) | pub fn init_json_subscriber(
  function init_tracing_otel_with_logs_only_fallback (line 105) | pub fn init_tracing_otel_with_logs_only_fallback(
  function setup_otel_with_tracer (line 119) | fn setup_otel_with_tracer(
  type MetricsConfig (line 147) | pub struct MetricsConfig {
    method fmt (line 191) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  method default (line 154) | fn default() -> Self {
  type Err (line 164) | type Err = String;
  method from_str (line 166) | fn from_str(s: &str) -> Result<Self, Self::Err> {
  function gen_linear_buckets (line 200) | pub fn gen_linear_buckets(conf: &MetricsConfig) -> Vec<f64> {
  function register_histogram (line 211) | pub fn register_histogram(config: Option<&MetricsConfig>, name: &str, de...
  function short_hex_id (line 218) | pub fn short_hex_id(value: &[u8]) -> String {
  function record_short_hex (line 222) | pub fn record_short_hex(span: &Span, field: &'static str, value: &[u8]) {
  function record_short_hex_if_some (line 226) | pub fn record_short_hex_if_some<T: AsRef<[u8]>>(
  function set_current_span_error (line 236) | pub fn set_current_span_error(error: &impl fmt::Display) {
  type TransactionMetrics (line 248) | pub struct TransactionMetrics {
    method new (line 255) | pub fn new(capacity: NonZeroUsize) -> Self {
    method is_new_transaction (line 264) | async fn is_new_transaction(&self, txn_hash: &[u8]) -> bool {
    method is_transaction_completed (line 275) | async fn is_transaction_completed(&self, txn_hash: &[u8]) -> bool {
    method begin_transaction (line 287) | pub async fn begin_transaction(
    method clean_up_transactions (line 317) | async fn clean_up_transactions(&self, pool: &sqlx::PgPool) {
    method end_transaction (line 348) | pub async fn end_transaction(
    method get_transaction_latency (line 413) | async fn get_transaction_latency(
  function try_begin_transaction (line 433) | pub async fn try_begin_transaction(
  function try_end_l1_transaction (line 452) | pub async fn try_end_l1_transaction(
  function try_end_zkproof_transaction (line 503) | pub async fn try_end_zkproof_transaction(
  function otel_guard_shutdown_once_disarms_provider (line 522) | fn otel_guard_shutdown_once_disarms_provider() {

FILE: coprocessor/fhevm-engine/fhevm-engine-common/src/tfhe_ops.rs
  function deserialize_fhe_ciphertext (line 20) | pub fn deserialize_fhe_ciphertext(
  function trivial_encrypt_be_bytes (line 78) | pub fn trivial_encrypt_be_bytes(output_type: i16, input_bytes: &[u8]) ->...
  function current_ciphertext_version (line 263) | pub fn current_ciphertext_version() -> i16 {
  function try_expand_ciphertext_list (line 267) | pub fn try_expand_ciphertext_list(
  function extract_ct_list (line 289) | pub fn extract_ct_list(
  function check_fhe_operand_types (line 432) | pub fn check_fhe_operand_types(
  function validate_fhe_type (line 709) | pub fn validate_fhe_type(input_type: i32) -> Result<(), FhevmError> {
  function does_fhe_operation_support_scalar (line 719) | pub fn does_fhe_operation_support_scalar(op: &SupportedFheOperations) ->...
  function does_fhe_operation_support_both_encrypted_operands (line 734) | pub fn does_fhe_operation_support_both_encrypted_operands(op: &Supported...
  function perform_fhe_operation (line 739) | pub fn perform_fhe_operation(
  function perform_fhe_operation (line 749) | pub fn perform_fhe_operation(
  function perform_fhe_operation_impl (line 767) | pub fn perform_fhe_operation_impl(
  function to_be_u4_bit (line 3128) | pub fn to_be_u4_bit(inp: &[u8]) -> u8 {
  function to_be_u8_bit (line 3132) | pub fn to_be_u8_bit(inp: &[u8]) -> u8 {
  function to_constant_size_array (line 3140) | fn to_constant_size_array<const SIZE: usize>(inp: &[u8]) -> [u8; SIZE] {
  function to_be_u16_bit (line 3161) | pub fn to_be_u16_bit(inp: &[u8]) -> u16 {
  function to_be_u32_bit (line 3167) | pub fn to_be_u32_bit(inp: &[u8]) -> u32 {
  function to_be_u64_bit (line 3173) | pub fn to_be_u64_bit(inp: &[u8]) -> u64 {
  function to_be_u128_bit (line 3179) | pub fn to_be_u128_bit(inp: &[u8]) -> u128 {
  function to_be_u160_bit (line 3186) | pub fn to_be_u160_bit(inp: &[u8]) -> U256 {
  function to_be_u256_bit (line 3198) | pub fn to_be_u256_bit(inp: &[u8]) -> U256 {
  function to_be_u512_bit (line 3207) | pub fn to_be_u512_bit(inp: &[u8]) -> StaticUnsignedBigInt<8> {
  function to_be_u1024_bit (line 3217) | pub fn to_be_u1024_bit(inp: &[u8]) -> StaticUnsignedBigInt<16> {
  function to_be_u2048_bit (line 3227) | pub fn to_be_u2048_bit(inp: &[u8]) -> StaticUnsignedBigInt<32> {
  function arr_non_zero (line 3237) | fn arr_non_zero(inp: &[u8]) -> bool {
  function be_number_random_bits (line 3246) | fn be_number_random_bits(inp: &[u8]) -> u32 {
  function random_bits_from_arr (line 3267) | fn random_bits_from_arr() {
  function generate_random_number (line 3287) | pub fn generate_random_number(

FILE: coprocessor/fhevm-engine/fhevm-engine-common/src/types.rs
  type FhevmError (line 20) | pub enum FhevmError {
    method fmt (line 145) | fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
  function panic_payload_to_string (line 348) | fn panic_payload_to_string(payload: Box<dyn std::any::Any + Send>) -> St...
  type SupportedFheCiphertexts (line 359) | pub enum SupportedFheCiphertexts {
    method serialize (line 417) | pub fn serialize(&self) -> (i16, Vec<u8>) {
    method to_ciphertext64 (line 438) | pub fn to_ciphertext64(self) -> BaseRadixCiphertext<Ciphertext> {
    method type_num (line 460) | pub fn type_num(&self) -> i16 {
    method type_name (line 482) | pub fn type_name(&self) -> &'static str {
    method decrypt (line 500) | pub fn decrypt(&self, client_key: &tfhe::ClientKey) -> String {
    method compress (line 558) | pub fn compress(&self) -> std::result::Result<Vec<u8>, FhevmError> {
    method decompress (line 594) | pub fn decompress(ct_type: i16, list: &[u8], gpu_idx: usize) -> Result...
    method decompress (line 608) | pub fn decompress(ct_type: i16, list: &[u8], _: usize) -> Result<Self> {
    method decompress_no_memcheck (line 615) | pub fn decompress_no_memcheck(ct_type: i16, list: &[u8]) -> Result<Sel...
    method decompress_impl (line 620) | pub fn decompress_impl(ct_type: i16, list: &CompressedCiphertextList) ...
    method is_ebytes (line 662) | pub fn is_ebytes(&self) -> bool {
    method add_to_re_randomization_context (line 680) | pub fn add_to_re_randomization_context(&self, context: &mut ReRandomiz...
    method add_re_randomization_metadata (line 722) | pub fn add_re_randomization_metadata(&mut self, hash_data: &[u8]) {
    method add_to_rerandomisation_context (line 764) | pub fn add_to_rerandomisation_context(&self, context: &mut ReRandomiza...
    method re_randomise (line 783) | pub fn re_randomise(
  type SupportedFheOperations (line 378) | pub enum SupportedFheOperations {
    method op_type (line 846) | pub fn op_type(&self) -> FheOperationType {
    method is_comparison (line 880) | pub fn is_comparison(&self) -> bool {
    method does_have_more_than_one_scalar (line 892) | pub fn does_have_more_than_one_scalar(&self) -> bool {
    method supports_bool_inputs (line 901) | pub fn supports_bool_inputs(&self) -> bool {
    method supports_ebytes_inputs (line 913) | pub fn supports_ebytes_inputs(&self) -> bool {
    type Error (line 948) | type Error = FhevmError;
    method try_from (line 950) | fn try_from(value: i16) -> Result<Self, Self::Error> {
    type Error (line 995) | type Error = FhevmError;
    method try_from (line 997) | fn try_from(value: i32) -> Result<Self, Self::Error> {
  type FheOperationType (line 410) | pub enum FheOperationType {
  function from (line 1008) | fn from(value: SupportedFheOperations) -> Self {
  type Handle (line 1013) | pub type Handle = Vec<u8>;
  constant HANDLE_LEN (line 1014) | pub const HANDLE_LEN: usize = 32;
  function get_ct_type (line 1016) | pub fn get_ct_type(handle: &[u8]) -> Result<i16, FhevmError> {
  function is_ebytes_type (line 1023) | pub fn is_ebytes_type(inp: i16) -> bool {
  type SchedulePriority (line 1029) | pub enum SchedulePriority {
  function from (line 1036) | fn from(value: SchedulePriority) -> Self {
  type AllowEvents (line 1042) | pub enum AllowEvents {
    type Error (line 1052) | type Error = AllowEventsError;
    method try_from (line 1053) | fn try_from(value: i16) -> Result<Self, Self::Error> {
  type AllowEventsError (line 1047) | pub enum AllowEventsError {
  type BlockchainProvider (line 1062) | pub type BlockchainProvider = FillProvider<
  function compress_scalar_returns_error (line 1075) | fn compress_scalar_returns_error() {

FILE: coprocessor/fhevm-engine/fhevm-engine-common/src/utils.rs
  constant SAFE_SER_DESER_LIMIT (line 14) | pub const SAFE_SER_DESER_LIMIT: u64 = 1024 * 1024 * 16;
  constant SAFE_SER_DESER_KEY_LIMIT (line 15) | pub const SAFE_SER_DESER_KEY_LIMIT: u64 = 1024 * 1024 * 1024 * 2;
  constant SAFE_SER_DESER_SNS_KEY_LIMIT (line 16) | pub const SAFE_SER_DESER_SNS_KEY_LIMIT: u64 = 1024 * 1024 * 1024 * 2;
  function safe_serialize (line 18) | pub fn safe_serialize<T: Serialize + Named + Versionize>(object: &T) -> ...
  function safe_deserialize (line 25) | pub fn safe_deserialize<T: DeserializeOwned + Named + Unversionize>(
  function safe_deserialize_conformant (line 32) | pub fn safe_deserialize_conformant<
  function safe_serialize_key (line 46) | pub fn safe_serialize_key<T: Serialize + Named + Versionize>(object: &T)...
  function safe_deserialize_key (line 53) | pub fn safe_deserialize_key<T: DeserializeOwned + Named + Unversionize>(
  function safe_deserialize_sns_key (line 60) | pub fn safe_deserialize_sns_key<T: DeserializeOwned + Named + Unversioni...
  function to_hex (line 67) | pub fn to_hex(blob: &[u8]) -> String {
  type HeartBeat (line 93) | pub struct HeartBeat {
    method new (line 98) | pub fn new() -> Self {
    method now_timestamp (line 105) | fn now_timestamp(&self) -> u64 {
    method update (line 109) | pub fn update(&self) {
    method is_recent (line 114) | pub fn is_recent(&self, freshness: &Duration) -> bool {
  method default (line 121) | fn default() -> Self {
  type DatabaseURL (line 128) | pub struct DatabaseURL(String);
    method from (line 131) | fn from(s: &str) -> Self {
    method from (line 138) | fn from(s: String) -> Self {
    method new_with_app_name (line 160) | pub fn new_with_app_name(base: &str, app_name: &str) -> Self {
    method default_app_name (line 181) | fn default_app_name() -> String {
    method as_str (line 192) | pub fn as_str(&self) -> &str {
    method into_inner (line 196) | pub fn into_inner(self) -> String {
    method mask_password (line 200) | fn mask_password(options: &PgConnectOptions) -> String {
    method parse (line 213) | pub fn parse(&self) -> Result<PgConnectOptions, sqlx::Error> {
    method fmt (line 219) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
    method fmt (line 230) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  method default (line 146) | fn default() -> Self {
  type Err (line 240) | type Err = sqlx::Error;
  method from_str (line 242) | fn from_str(s: &str) -> Result<Self, Self::Err> {
  function log_backend (line 249) | pub fn log_backend() -> bool {
  function log_backend_impl (line 254) | fn log_backend_impl() -> bool {
  function log_backend_impl (line 267) | fn log_backend_impl() -> bool {

FILE: coprocessor/fhevm-engine/fhevm-engine-common/tests/utils.rs
  function mask_database_url (line 4) | async fn mask_database_url() {

FILE: coprocessor/fhevm-engine/gw-listener/build.rs
  function main (line 10) | fn main() {

FILE: coprocessor/fhevm-engine/gw-listener/src/aws_s3.rs
  type S3Policy (line 12) | pub struct S3Policy {
    constant DEFAULT (line 22) | const DEFAULT: Self = Self {
  function create_s3_client (line 32) | pub async fn create_s3_client(
  type AwsS3Client (line 63) | pub struct AwsS3Client {}
  function find_key (line 65) | pub async fn find_key(
  type AwsS3Interface (line 120) | pub trait AwsS3Interface: Send + Sync {
    method get_bucket_key (line 97) | async fn get_bucket_key(
    method get_bucket_key (line 121) | async fn get_bucket_key(
  function bucket_from_domain (line 129) | fn bucket_from_domain(url: &Url) -> anyhow::Result<String> {
  function split_url (line 140) | fn split_url(s3_bucket_url: &String) -> anyhow::Result<(String, String)> {
  function download_key_from_s3 (line 175) | pub async fn download_key_from_s3<A: AwsS3Interface>(
  function test_split_devnet_url (line 213) | fn test_split_devnet_url() {

FILE: coprocessor/fhevm-engine/gw-listener/src/bin/gw_listener.rs
  type Conf (line 20) | struct Conf {
  function install_signal_handlers (line 119) | fn install_signal_handlers(cancel_token: CancellationToken) -> anyhow::R...
  function main (line 133) | async fn main() -> anyhow::Result<()> {

FILE: coprocessor/fhevm-engine/gw-listener/src/database.rs
  constant CHUNK_SIZE (line 10) | const CHUNK_SIZE: usize = 128 * 1024 * 1024;
  type KeyRecord (line 13) | pub(crate) struct KeyRecord {
    method is_valid (line 21) | pub fn is_valid(&self) -> bool {
  function insert_key (line 29) | pub async fn insert_key(
  function insert_crs (line 54) | pub async fn insert_crs(

FILE: coprocessor/fhevm-engine/gw-listener/src/digest.rs
  type DomainSep (line 7) | pub type DomainSep = [u8; DSEP_LEN];
  constant DSEP_LEN (line 8) | pub const DSEP_LEN: usize = 8;
  constant DSEP_PUBDATA_KEY (line 10) | pub const DSEP_PUBDATA_KEY: DomainSep = *b"PDAT_KEY";
  constant DSEP_PUBDATA_CRS (line 12) | pub const DSEP_PUBDATA_CRS: DomainSep = *b"PDAT_CRS";
  function digest (line 14) | fn digest(domain_separator: DomainSep, bytes: &[u8]) -> [u8; 32] {
  function digest_key (line 25) | pub fn digest_key(bytes: &[u8]) -> [u8; 32] {
  function digest_crs (line 31) | pub fn digest_crs(bytes: &[u8]) -> [u8; 32] {

FILE: coprocessor/fhevm-engine/gw-listener/src/drift_detector.rs
  type EventContext (line 18) | pub(crate) struct EventContext {
  type CiphertextDigest (line 26) | type CiphertextDigest = FixedBytes<32>;
  type DigestPair (line 29) | struct DigestPair {
  type Submission (line 35) | struct Submission {
  type ConsensusState (line 41) | struct ConsensusState {
  type HandleState (line 49) | struct HandleState {
    method new (line 62) | fn new(context: EventContext, expected_senders: Vec<Address>) -> Self {
  type HandleOutcome (line 78) | enum HandleOutcome {
  type DriftDetector (line 85) | pub(crate) struct DriftDetector {
    method new (line 103) | pub(crate) fn new(
    method set_replaying (line 123) | pub(crate) fn set_replaying(&mut self, replaying: bool) {
    method set_current_expected_senders (line 127) | pub(crate) fn set_current_expected_senders(&mut self, expected_senders...
    method observe_submission (line 131) | pub(crate) fn observe_submission(
    method handle_consensus (line 215) | pub(crate) async fn handle_consensus(
    method refresh_pending_consensus_checks (line 244) | async fn refresh_pending_consensus_checks(
    method try_check_local_consensus (line 263) | async fn try_check_local_consensus(
    method evict_stale (line 355) | fn evict_stale(&mut self, now: Instant) {
    method flush_metrics (line 438) | pub(crate) fn flush_metrics(&mut self) {
    method evaluate_open_handles (line 447) | fn evaluate_open_handles(&mut self, now: Instant) {
    method earliest_open_block (line 491) | pub(crate) fn earliest_open_block(&self) -> Option<u64> {
    method finalize_completed_without_consensus (line 498) | fn finalize_completed_without_consensus(&mut self) {
    method finish_if_complete (line 536) | fn finish_if_complete(&mut self, handle: CiphertextDigest) {
    method end_of_batch (line 558) | pub(crate) async fn end_of_batch(&mut self, db_pool: &Pool<Postgres>) ...
    method end_of_rebuild (line 568) | pub(crate) async fn end_of_rebuild(&mut self, db_pool: &Pool<Postgres>...
    method classify_handle (line 574) | fn classify_handle(&self, state: &HandleState, now: Instant) -> Handle...
  function has_multiple_variants (line 607) | fn has_multiple_variants(submissions: &[Submission]) -> bool {
  function variant_summaries (line 614) | fn variant_summaries(submissions: &[Submission]) -> Vec<String> {
  function sender_count_for_variant (line 644) | fn sender_count_for_variant(submissions: &[Submission], digests: DigestP...
  function rebuild_preserves_state_across_batches (line 657) | fn rebuild_preserves_state_across_batches() {
  function make_submission_event (line 710) | fn make_submission_event(
  function make_consensus_event (line 725) | fn make_consensus_event(
  function context (line 740) | fn context(block_number: u64) -> EventContext {
  function context_at (line 750) | fn context_at(block_number: u64, at: Instant) -> EventContext {
  function submit_digest_event_and_drift_check (line 760) | fn submit_digest_event_and_drift_check(
  function submit_at (line 774) | fn submit_at(
  function senders (line 789) | fn senders() -> Vec<Address> {
  function detector (line 797) | fn detector() -> DriftDetector {
  function make_consensus_state (line 806) | fn make_consensus_state(
  function make_consensus_state_at (line 821) | fn make_consensus_state_at(
  function earliest_open_block_tracks_oldest_open_handle (line 846) | fn earliest_open_block_tracks_oldest_open_handle() {
  function rebuild_replays_silently_then_alerts_once_on_evaluate (line 903) | fn rebuild_replays_silently_then_alerts_once_on_evaluate() {
  function consensus_handle_is_not_dropped_until_local_check_completes (line 940) | fn consensus_handle_is_not_dropped_until_local_check_completes() {
  function matching_submissions_keep_single_variant (line 998) | fn matching_submissions_keep_single_variant() {
  function differing_submissions_trigger_drift_once (line 1029) | fn differing_submissions_trigger_drift_once() {
  function handle_keeps_expected_senders_snapshot_after_rotation (line 1056) | fn handle_keeps_expected_senders_snapshot_after_rotation() {
  function all_expected_submissions_without_consensus_alert_and_drop_after_finalize (line 1119) | fn all_expected_submissions_without_consensus_alert_and_drop_after_final...
  function consensus_on_final_submission_survives_finalize_pass (line 1144) | fn consensus_on_final_submission_survives_finalize_pass() {
  function consensus_with_missing_submission_after_grace_alerts_and_drops (line 1179) | fn consensus_with_missing_submission_after_grace_alerts_and_drops() {
  function timeout_without_consensus_alerts_and_drops (line 1224) | fn timeout_without_consensus_alerts_and_drops() {
  function missing_submission_within_grace_period_is_not_evicted (line 1247) | fn missing_submission_within_grace_period_is_not_evicted() {
  function timeout_within_no_consensus_window_is_not_evicted (line 1300) | fn timeout_within_no_consensus_window_is_not_evicted() {
  function consensus_before_any_submission_creates_handle_state (line 1329) | fn consensus_before_any_submission_creates_handle_state() {
  function equivocation_warns_but_does_not_duplicate_submission (line 1370) | fn equivocation_warns_but_does_not_duplicate_submission() {
  function duplicate_submission_same_digests_is_ignored (line 1407) | fn duplicate_submission_same_digests_is_ignored() {
  function local_check_not_ready_evicts_after_timeout (line 1437) | fn local_check_not_ready_evicts_after_timeout() {
  function flush_resets_counters (line 1480) | fn flush_resets_counters() {
  function setup_db (line 1499) | async fn setup_db() -> (Pool<Postgres>, Option<test_harness::instance::D...
  function consensus_mismatch_increments_drift_metric (line 1518) | async fn consensus_mismatch_increments_drift_metric() {
  function rebuild_defers_consensus_check_until_alerts_resume (line 1554) | async fn rebuild_defers_consensus_check_until_alerts_resume() {
  function consensus_defers_when_local_digests_are_null (line 1609) | async fn consensus_defers_when_local_digests_are_null() {
  function unexpected_sender_does_not_block_completion (line 1679) | async fn unexpected_sender_does_not_block_completion() {
  function consensus_no_drift_when_local_digests_match (line 1740) | async fn consensus_no_drift_when_local_digests_match() {

FILE: coprocessor/fhevm-engine/gw-listener/src/gw_listener.rs
  type DigestMismatchError (line 38) | struct DigestMismatchError {
    method fmt (line 43) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
  type ListenerProgress (line 51) | struct ListenerProgress {
  type GatewayListener (line 57) | pub struct GatewayListener<
  function new (line 72) | pub fn new(
  function run (line 90) | pub async fn run(&self) -> anyhow::Result<()> {
  function run_get_logs (line 131) | async fn run_get_logs(
  function fetch_expected_senders (line 393) | async fn fetch_expected_senders(
  function rebuild_drift_detector (line 422) | async fn rebuild_drift_detector(
  function process_ciphertext_commits_log (line 495) | async fn process_ciphertext_commits_log(
  function process_gateway_config_log (line 525) | fn process_gateway_config_log(
  function verify_proof_request (line 556) | async fn verify_proof_request(
  function activate_key (line 597) | async fn activate_key(
  function activate_crs (line 666) | async fn activate_crs(
  function reset_sleep_duration (line 703) | fn reset_sleep_duration(&self, sleep_duration: &mut u64) {
  function sleep_with_backoff (line 707) | async fn sleep_with_backoff(&self, sleep_duration: &mut u64) {
  function get_listener_progress (line 712) | async fn get_listener_progress(
  function update_listener_progress (line 738) | async fn update_listener_progress(
  function health_check (line 777) | pub async fn health_check(&self) -> HealthStatus {
  function key_id_to_database_bytes (line 846) | pub fn key_id_to_database_bytes(key_id: KeyId) -> [u8; 32] {
  function to_key_prefix (line 850) | pub fn to_key_prefix(val: KeyType) -> &'static str {
  function key_id_to_aws_key (line 857) | pub fn key_id_to_aws_key(key_id: KeyId) -> String {
  function test_key_id_consistency (line 863) | fn test_key_id_consistency() {

FILE: coprocessor/fhevm-engine/gw-listener/src/http_server.rs
  type HealthResponse (line 22) | struct HealthResponse {
    method from (line 31) | fn from(status: HealthStatus) -> Self {
  type HttpServer (line 46) | pub struct HttpServer<
  function new (line 60) | pub fn new(
  function start (line 72) | pub async fn start(&self) -> anyhow::Result<()> {
  function health_handler (line 101) | async fn health_handler<
  function liveness_handler (line 118) | async fn liveness_handler<

FILE: coprocessor/fhevm-engine/gw-listener/src/lib.rs
  type KeyId (line 18) | pub(crate) type KeyId = Uint<256, 4>;
  type KeyType (line 21) | pub enum KeyType {
    type Error (line 27) | type Error = anyhow::Error;
    method try_from (line 28) | fn try_from(value: u8) -> anyhow::Result<KeyType> {
  type ConfigSettings (line 38) | pub struct ConfigSettings {
  function chain_id_from_env (line 66) | pub fn chain_id_from_env() -> Option<ChainId> {
  method default (line 84) | fn default() -> Self {
  type HealthStatus (line 110) | pub struct HealthStatus {
    method healthy (line 122) | pub fn healthy() -> Self {
    method unhealthy (line 131) | pub fn unhealthy(

FILE: coprocessor/fhevm-engine/gw-listener/src/sks_key.rs
  function extract_server_key_without_ns (line 5) | pub fn extract_server_key_without_ns(sns_key: &[u8]) -> anyhow::Result<V...

FILE: coprocessor/fhevm-engine/gw-listener/tests/gw_listener_tests.rs
  type TestLogs (line 52) | struct TestLogs {
    method new (line 57) | fn new() -> Self {
    method add (line 64) | fn add(&mut self, data: &[u8]) {
    method contains (line 69) | fn contains(&self, substr: &str) -> bool {
  type Writer (line 74) | struct Writer {
    method new (line 79) | fn new(logs: TestLogs) -> Self {
    method write (line 85) | fn write(&mut self, buf: &[u8]) -> std::io::Result<usize> {
    method flush (line 90) | fn flush(&mut self) -> std::io::Result<()> {
    type Writer (line 96) | type Writer = Self;
    method make_writer (line 98) | fn make_writer(&'a self) -> Self::Writer {
  type TestEnvironment (line 105) | struct TestEnvironment {
    method new (line 116) | async fn new() -> anyhow::Result<Self> {
    method wait_for_log (line 170) | async fn wait_for_log(&self, log: &str) -> anyhow::Result<()> {
  constant RETRY_EVENT_TO_DB (line 181) | const RETRY_EVENT_TO_DB: u64 = 20;
  constant LOG_RETRY_COUNT (line 182) | const LOG_RETRY_COUNT: u64 = 50;
  constant RETRY_DELAY (line 183) | const RETRY_DELAY: Duration = Duration::from_millis(500);
  function verify_proof_request_inserted_into_db (line 187) | async fn verify_proof_request_inserted_into_db() -> anyhow::Result<()> {
  function has_not_public_key (line 250) | async fn has_not_public_key(db_pool: &Pool<Postgres>, key_id: U256) -> a...
  function has_public_key (line 254) | async fn has_public_key(db_pool: &Pool<Postgres>, key_id: U256) -> anyho...
  function has_public_key_gen (line 258) | async fn has_public_key_gen(
  function has_not_server_key (line 284) | async fn has_not_server_key(db_pool: &Pool<Postgres>, key_id: U256) -> a...
  function has_server_key (line 288) | async fn has_server_key(db_pool: &Pool<Postgres>, key_id: U256) -> anyho...
  function has_server_key_gen (line 292) | async fn has_server_key_gen(
  function has_not_crs (line 318) | async fn has_not_crs(db_pool: &Pool<Postgres>, crs_id: U256) -> anyhow::...
  function has_crs (line 322) | async fn has_crs(db_pool: &Pool<Postgres>, crs_id: U256) -> anyhow::Resu...
  function has_crs_gen (line 326) | async fn has_crs_gen(db_pool: &Pool<Postgres>, retry: bool, crs_id: U256...
  type AwsS3ClientMocked (line 349) | pub struct AwsS3ClientMocked(Client);
  method get_bucket_key (line 353) | async fn get_bucket_key(
  function rules (line 374) | fn rules(
  function keygen_ok_simple (line 451) | async fn keygen_ok_simple() -> anyhow::Result<()> {
  function keygen_ok_catchup_positive (line 513) | async fn keygen_ok_catchup_positive() -> anyhow::Result<()> {
  function keygen_ok_catchup_negative (line 519) | async fn keygen_ok_catchup_negative() -> anyhow::Result<()> {
  function keygen_ok_catchup_gen (line 523) | async fn keygen_ok_catchup_gen(positive: bool) -> anyhow::Result<()> {
  function keygen_compromised_key (line 601) | async fn keygen_compromised_key() -> anyhow::Result<()> {
  function keygen_bad_key_or_bucket (line 661) | async fn keygen_bad_key_or_bucket() -> anyhow::Result<()> {
  function keygen_only_public_or_server_key (line 718) | async fn keygen_only_public_or_server_key() -> anyhow::Result<()> {

FILE: coprocessor/fhevm-engine/host-listener/build.rs
  function build_contracts (line 9) | fn build_contracts() {
  function main (line 76) | fn main() {

FILE: coprocessor/fhevm-engine/host-listener/src/bin/main.rs
  function main (line 5) | async fn main() -> anyhow::Result<()> {

FILE: coprocessor/fhevm-engine/host-listener/src/bin/poller.rs
  type Args (line 18) | struct Args {
  function main (line 126) | async fn main() -> anyhow::Result<()> {

FILE: coprocessor/fhevm-engine/host-listener/src/cmd/block_history.rs
  type BlockHash (line 6) | pub type BlockHash = FixedBytes<32>;
  type BlockSummary (line 9) | pub struct BlockSummary {
    method from (line 17) | fn from(block: Block) -> Self {
    method from (line 23) | fn from(block_header: Header) -> Self {
  type BlockHistory (line 33) | pub struct BlockHistory {
    method new (line 42) | pub fn new(expected_reorg_duration: usize) -> Self {
    method size (line 51) | pub fn size(&self) -> usize {
    method is_ready_to_detect_reorg (line 55) | pub fn is_ready_to_detect_reorg(&self) -> bool {
    method is_known (line 61) | pub fn is_known(&self, block_hash: &BlockHash) -> bool {
    method find_block_by_number (line 74) | pub fn find_block_by_number(
    method tip (line 90) | pub fn tip(&self) -> Option<BlockSummary> {
    method add_block (line 94) | pub fn add_block(&mut self, block: BlockSummary) {
    method estimated_block_time (line 101) | pub fn estimated_block_time(&self) -> Option<u64> {
  constant MAXIMUM_NUMBER_OF_COMPETING_CHAIN (line 37) | const MAXIMUM_NUMBER_OF_COMPETING_CHAIN: usize = 5;
  constant MINIMUM_HISTORY_SIZE (line 38) | const MINIMUM_HISTORY_SIZE: usize = 2;
  constant MINIMUM_BLOCK_TIME_SECONDS (line 39) | const MINIMUM_BLOCK_TIME_SECONDS: u64 = 1;
  function test_block_history (line 125) | fn test_block_history() {
  function test_estimated_block_time (line 158) | fn test_estimated_block_time() {

FILE: coprocessor/fhevm-engine/host-listener/src/cmd/mod.rs
  constant REORG_RETRY_GET_LOGS (line 34) | const REORG_RETRY_GET_LOGS: u64 = 10;
  constant RETRY_GET_LOGS_DELAY_IN_MS (line 35) | const RETRY_GET_LOGS_DELAY_IN_MS: u64 = 100;
  constant REORG_RETRY_GET_BLOCK (line 36) | const REORG_RETRY_GET_BLOCK: u64 = 10;
  constant RETRY_GET_BLOCK_DELAY_IN_MS (line 37) | const RETRY_GET_BLOCK_DELAY_IN_MS: u64 = 100;
  constant DEFAULT_BLOCK_TIME (line 39) | const DEFAULT_BLOCK_TIME: u64 = 12;
  constant DEFAULT_DEPENDENCE_CACHE_SIZE (line 40) | pub const DEFAULT_DEPENDENCE_CACHE_SIZE: u16 = 10_000;
  constant DEFAULT_DEPENDENCE_BY_CONNEXITY (line 41) | pub const DEFAULT_DEPENDENCE_BY_CONNEXITY: bool = false;
  constant DEFAULT_DEPENDENCE_CROSS_BLOCK (line 42) | pub const DEFAULT_DEPENDENCE_CROSS_BLOCK: bool = true;
  constant TIMEOUT_REQUEST_ON_WEBSOCKET (line 44) | const TIMEOUT_REQUEST_ON_WEBSOCKET: u64 = 15;
  type Args (line 48) | pub struct Args {
  type InfiniteLogIter (line 176) | pub struct InfiniteLogIter {
    method new (line 229) | fn new(args: &Args) -> Self {
    method get_chain_id (line 265) | async fn get_chain_id(&self) -> anyhow::Result<ChainId> {
    method resolve_end_at_block (line 279) | async fn resolve_end_at_block(
    method catchup_block_from (line 297) | async fn catchup_block_from(
    method get_blocks_logs_range_no_retry (line 325) | async fn get_blocks_logs_range_no_retry(
    method deduce_block_summary (line 378) | async fn deduce_block_summary(
    method split_by_block (line 412) | async fn split_by_block(
    method consume_catchup_blocks (line 472) | async fn consume_catchup_blocks(&mut self) {
    method get_block_by_number (line 544) | pub async fn get_block_by_number(&self, number: u64) -> Result<Block> {
    method get_current_block (line 548) | async fn get_current_block(&self) -> Result<Block> {
    method get_block_by_id (line 552) | async fn get_block_by_id(&self, block_id: BlockId) -> Result<Block> {
    method get_block (line 589) | async fn get_block(&self, block_hash: BlockHash) -> Result<Block> {
    method get_logs_at_hash (line 627) | async fn get_logs_at_hash(
    method get_missing_ancestors (line 679) | async fn get_missing_ancestors(
    method populate_catchup_logs_from_missing_blocks (line 715) | async fn populate_catchup_logs_from_missing_blocks(
    method check_missing_ancestors (line 743) | async fn check_missing_ancestors(
    method new_log_stream_no_retry (line 773) | async fn new_log_stream_no_retry(&mut self) -> Result<()> {
    method new_log_stream (line 795) | async fn new_log_stream(&mut self) {
    method next_block (line 802) | async fn next_block(&mut self) -> Result<BlockOrTimeoutOrNone> {
    method attach_logs_to (line 824) | async fn attach_logs_to(
    method find_last_block_and_logs (line 836) | async fn find_last_block_and_logs(&self) -> Result<BlockLogs<Log>> {
    method end_at_block_reached (line 841) | async fn end_at_block_reached(&self) -> bool {
    method next (line 856) | async fn next(&mut self) -> Option<BlockLogs<Log>> {
    method reset_for_catchup_loop (line 926) | fn reset_for_catchup_loop(&mut self) {
  type BlockOrTimeoutOrNone (line 200) | enum BlockOrTimeoutOrNone {
  function too_much_blocks_or_events (line 208) | pub fn too_much_blocks_or_events(
  function websocket_config (line 224) | fn websocket_config() -> WebSocketConfig {
  function db_insert_block (line 936) | async fn db_insert_block(
  function main (line 984) | pub async fn main(args: Args) -> anyhow::Result<()> {

FILE: coprocessor/fhevm-engine/host-listener/src/database/dependence_chains.rs
  type Transaction (line 15) | struct Transaction {
    method new (line 28) | fn new(tx_hash: TransactionHash) -> Self {
  function ensure_logs_order (line 43) | fn ensure_logs_order(logs: &mut [LogTfhe]) {
  constant AVG_LOGS_PER_TX (line 52) | const AVG_LOGS_PER_TX: usize = 8;
  function scan_transactions (line 53) | fn scan_transactions(
  function fill_tx_dependence_maps (line 88) | async fn fill_tx_dependence_maps(
  function grouping_to_chains_connex (line 155) | async fn grouping_to_chains_connex(
  function grouping_to_chains_no_fork (line 253) | fn grouping_to_chains_no_fork(
  function dependence_chains (line 410) | pub async fn dependence_chains(
  function caller (line 482) | fn caller() -> Address {
  function tfhe_event (line 486) | fn tfhe_event(data: E) -> alloy::primitives::Log<E> {
  function push_event (line 493) | fn push_event(
  function new_handle (line 515) | fn new_handle() -> Handle {
  function input_handle (line 557) | fn input_handle(logs: &mut Vec<LogTfhe>, tx: TransactionHash) -> Handle {
  function input_shared_handle (line 573) | fn input_shared_handle(
  function op1 (line 592) | fn op1(
  function op2 (line 613) | fn op2(
  function test_dependence_chains_1_local_chain (line 636) | async fn test_dependence_chains_1_local_chain() {
  function test_dependence_chains_2_local_chain (line 651) | async fn test_dependence_chains_2_local_chain() {
  function test_dependence_chains_2_local_chain_mixed (line 671) | async fn test_dependence_chains_2_local_chain_mixed() {
  function test_dependence_chains_2_local_chain_mixed_bis (line 694) | async fn test_dependence_chains_2_local_chain_mixed_bis() {
  function past_chain (line 731) | fn past_chain(last_byte: u8) -> Chain {
  function test_dependence_chains_1_known_past_handle (line 745) | async fn test_dependence_chains_1_known_past_handle() {
  function test_dependence_chains_1_unknown_past_handle (line 766) | async fn test_dependence_chains_1_unknown_past_handle() {
  function test_dependence_chains_1_local_and_known_past_handle (line 782) | async fn test_dependence_chains_1_local_and_known_past_handle() {
  function test_dependence_chains_2_local_duplicated_handle (line 804) | async fn test_dependence_chains_2_local_duplicated_handle() {
  function test_dependence_chains_duplicated_trivial_encrypt (line 821) | async fn test_dependence_chains_duplicated_trivial_encrypt() {
  function test_dependence_chains_dep_with_bad_order (line 837) | async fn test_dependence_chains_dep_with_bad_order() {
  function test_dependence_chains_2_local_non_allowed_handle (line 857) | async fn test_dependence_chains_2_local_non_allowed_handle() {
  function test_dependence_chains_auction (line 876) | async fn test_dependence_chains_auction() {
  function test_dependence_chains_2_local_chain_connex (line 918) | async fn test_dependence_chains_2_local_chain_connex() {
  function test_dependence_chains_2_local_chain_mixed_connex (line 938) | async fn test_dependence_chains_2_local_chain_mixed_connex() {
  function test_dependence_chains_2_local_chain_mixed_1_past_connex (line 958) | async fn test_dependence_chains_2_local_chain_mixed_1_past_connex() {
  function test_dependence_chains_2_local_chain_mixed_2_past_connex (line 985) | async fn test_dependence_chains_2_local_chain_mixed_2_past_connex() {
  function test_past_chain_fork (line 1011) | async fn test_past_chain_fork() {
  function test_current_block_fork (line 1032) | async fn test_current_block_fork() {

FILE: coprocessor/fhevm-engine/host-listener/src/database/ingest.rs
  type BlockLogs (line 19) | pub struct BlockLogs<T> {
  type IngestOptions (line 27) | pub struct IngestOptions {
  function block_date_time_utc (line 40) | fn block_date_time_utc(timestamp: u64) -> PrimitiveDateTime {
  function propagate_slow_lane_to_dependents (line 49) | fn propagate_slow_lane_to_dependents(
  function classify_slow_by_split_dependency_closure (line 84) | fn classify_slow_by_split_dependency_closure(
  function ingest_block_logs (line 142) | pub async fn ingest_block_logs(
  function update_finalized_blocks (line 329) | pub async fn update_finalized_blocks(
  function fixture_chain (line 405) | fn fixture_chain(hash: u8, dependencies: &[u8]) -> Chain {
  function propagates_slow_lane_transitively_on_known_dependencies (line 425) | fn propagates_slow_lane_transitively_on_known_dependencies() {
  function classifies_slow_by_split_dependency_closure_sum (line 443) | fn classifies_slow_by_split_dependency_closure_sum() {

FILE: coprocessor/fhevm-engine/host-listener/src/database/tfhe_event_propagate.rs
  type FheOperation (line 36) | type FheOperation = i32;
  type Handle (line 37) | pub type Handle = FixedBytes<32>;
  type TransactionHash (line 38) | pub type TransactionHash = FixedBytes<32>;
  type ToType (line 39) | pub type ToType = u8;
  type ScalarByte (line 40) | pub type ScalarByte = FixedBytes<1>;
  type ClearConst (line 41) | pub type ClearConst = Uint<256, 4>;
  type ChainHash (line 42) | pub type ChainHash = TransactionHash;
  type Chain (line 56) | pub struct Chain {
  type ChainCache (line 68) | pub type ChainCache = RwLock<lru::LruCache<Handle, ChainHash>>;
  type OrderedChains (line 69) | pub type OrderedChains = Vec<Chain>;
  constant MINIMUM_BUCKET_CACHE_SIZE (line 71) | const MINIMUM_BUCKET_CACHE_SIZE: u16 = 16;
  constant SLOW_LANE_RESET_ADVISORY_LOCK_KEY_BASE (line 72) | const SLOW_LANE_RESET_ADVISORY_LOCK_KEY_BASE: i64 = 1_907_000_000;
  constant SLOW_LANE_RESET_BATCH_SIZE (line 73) | const SLOW_LANE_RESET_BATCH_SIZE: i64 = 5_000;
  constant MAX_RETRY_FOR_TRANSIENT_ERROR (line 74) | const MAX_RETRY_FOR_TRANSIENT_ERROR: usize = 20;
  constant MAX_RETRY_ON_UNKNOWN_ERROR (line 75) | const MAX_RETRY_ON_UNKNOWN_ERROR: usize = 5;
  constant RECONNECTION_DELAY (line 78) | const RECONNECTION_DELAY: Duration = Duration::from_millis(100);
  type DbErrorCode (line 80) | type DbErrorCode = std::borrow::Cow<'static, str>;
  constant STATEMENT_CANCELLED (line 81) | const STATEMENT_CANCELLED: DbErrorCode = DbErrorCode::Borrowed("57014");
  function slow_lane_reset_advisory_lock_key (line 83) | fn slow_lane_reset_advisory_lock_key(chain_id: ChainId) -> i64 {
  function retry_on_sqlx_error (line 87) | pub fn retry_on_sqlx_error(err: &SqlxError, retry_count: &mut usize) -> ...
  type Database (line 111) | pub struct Database {
    method new (line 135) | pub async fn new(
    method record_slow_lane_marked_chains (line 157) | pub(crate) fn record_slow_lane_marked_chains(&self, count: u64) {
    method promote_all_dep_chains_to_fast_priority (line 166) | pub async fn promote_all_dep_chains_to_fast_priority(
    method find_slow_dep_chain_ids (line 222) | pub async fn find_slow_dep_chain_ids(
    method new_pool (line 257) | async fn new_pool(url: &DatabaseURL) -> PgPool {
    method new_transaction (line 282) | pub async fn new_transaction(&self) -> Result<Transaction<'_>, SqlxErr...
    method pool (line 286) | pub async fn pool(&self) -> sqlx::Pool<Postgres> {
    method reconnect (line 290) | pub async fn reconnect(&mut self) {
    method insert_computation_bytes (line 302) | async fn insert_computation_bytes(
    method insert_computation (line 330) | async fn insert_computation(
    method insert_computation_inner (line 353) | async fn insert_computation_inner(
    method insert_tfhe_event (line 404) | pub async fn insert_tfhe_event(
    method update_block_as_finalized (line 495) | pub async fn update_block_as_finalized(
    method mark_block_as_valid (line 520) | pub async fn mark_block_as_valid(
    method get_finalized_blocks_number (line 554) | pub async fn get_finalized_blocks_number(
    method poller_get_last_caught_up_block (line 578) | pub async fn poller_get_last_caught_up_block(
    method poller_set_last_caught_up_block (line 595) | pub async fn poller_set_last_caught_up_block(
    method read_last_valid_block (line 618) | pub async fn read_last_valid_block(&self) -> Option<i64> {
    method handle_acl_event (line 634) | pub async fn handle_acl_event(
    method insert_pbs_computations (line 808) | pub async fn insert_pbs_computations(
    method insert_allowed_handle (line 830) | pub async fn insert_allowed_handle(
    method record_transaction_begin (line 850) | async fn record_transaction_begin(
    method insert_delegation (line 868) | async fn insert_delegation(
    method block_notification (line 902) | pub async fn block_notification(&mut self) -> Result<(), SqlxError> {
    method update_dependence_chain (line 908) | pub async fn update_dependence_chain(
  type LogTfhe (line 120) | pub struct LogTfhe {
  type Transaction (line 132) | pub type Transaction<'l> = sqlx::Transaction<'l, Postgres>;
  function event_to_op_int (line 978) | fn event_to_op_int(op: &TfheContractEvents) -> FheOperation {
  function event_name (line 1014) | pub fn event_name(op: &TfheContractEvents) -> &'static str {
  function tfhe_result_handle (line 1050) | pub fn tfhe_result_handle(op: &TfheContractEvents) -> Option<Handle> {
  function acl_result_handles (line 1086) | pub fn acl_result_handles(event: &Log<AclContractEvents>) -> Vec<Handle> {
  function tfhe_inputs_handle (line 1106) | pub fn tfhe_inputs_handle(op: &TfheContractEvents) -> Vec<Handle> {

FILE: coprocessor/fhevm-engine/host-listener/src/health_check.rs
  constant IS_ALIVE_TICK_FRESHNESS (line 12) | const IS_ALIVE_TICK_FRESHNESS: Duration = Duration::from_secs(20);
  constant CONNECTED_TICK_FRESHNESS (line 13) | const CONNECTED_TICK_FRESHNESS: Duration = Duration::from_secs(5);
  type HealthCheck (line 17) | pub struct HealthCheck {
  method health_check (line 26) | async fn health_check(&self) -> HealthStatus {
  method is_alive (line 54) | async fn is_alive(&self) -> bool {
  method get_version (line 61) | fn get_version(&self) -> Version {

FILE: coprocessor/fhevm-engine/host-listener/src/poller/http_client.rs
  type HttpChainClient (line 22) | pub struct HttpChainClient {
    method new (line 33) | pub fn new(
    method chain_id (line 68) | pub async fn chain_id(&self) -> Result<u64> {
    method latest_block_number (line 75) | pub async fn latest_block_number(&self) -> Result<u64> {
    method logs_for_block (line 82) | pub async fn logs_for_block(&self, block: u64) -> Result<Vec<Log>> {
    method header_for_block (line 90) | pub async fn header_for_block(&self, block_number: u64) -> Result<Head...
    method build_filter (line 102) | fn build_filter(block: u64, addresses: &[Address]) -> Filter {
  function filter_builder_sets_addresses_and_block_bounds (line 117) | fn filter_builder_sets_addresses_and_block_bounds() {
  function filter_builder_skips_addresses_when_empty (line 151) | fn filter_builder_skips_addresses_when_empty() {

FILE: coprocessor/fhevm-engine/host-listener/src/poller/metrics.rs
  function inc_blocks_processed (line 24) | pub(crate) fn inc_blocks_processed(chain_id: &str, count: u64) {
  function inc_db_errors (line 30) | pub(crate) fn inc_db_errors(chain_id: &str, count: u64) {
  function inc_rpc_errors (line 43) | pub(crate) fn inc_rpc_errors(chain_id: &str, count: u64) {

FILE: coprocessor/fhevm-engine/host-listener/src/poller/mod.rs
  constant MAX_DB_RETRIES (line 30) | const MAX_DB_RETRIES: u64 = 10;
  constant MAX_CONSECUTIVE_RPC_FAILURES (line 33) | const MAX_CONSECUTIVE_RPC_FAILURES: u64 = 3;
  function handle_rpc_failure (line 35) | fn handle_rpc_failure<E: std::fmt::Display>(
  type PollerConfig (line 68) | pub struct PollerConfig {
  function run_poller (line 91) | pub async fn run_poller(config: PollerConfig) -> Result<()> {
  function ingest_with_retry (line 354) | async fn ingest_with_retry(

FILE: coprocessor/fhevm-engine/host-listener/tests/host_listener_integration_tests.rs
  constant NB_EVENTS_PER_WALLET (line 55) | const NB_EVENTS_PER_WALLET: i64 = 50;
  function emit_events (line 57) | async fn emit_events<P, N>(
  function wallets (line 146) | fn wallets(anvil: &AnvilInstance) -> Vec<EthereumWallet> {
  type SetupProvider (line 156) | type SetupProvider = FillProvider<
  type Setup (line 170) | struct Setup {
  function setup_with_block_time (line 182) | async fn setup_with_block_time(
  function setup (line 262) | async fn setup(node_chain_id: Option<u64>) -> Result<Setup, anyhow::Erro...
  function trivial_encrypt_handle (line 266) | fn trivial_encrypt_handle(val: U256, to_type: u8) -> FixedBytes<32> {
  function fhe_add_handle (line 276) | fn fhe_add_handle(
  function ingest_blocks_for_receipts (line 294) | async fn ingest_blocks_for_receipts(
  function ingest_dependent_burst_seeded (line 349) | async fn ingest_dependent_burst_seeded(
  function emit_dependent_burst_seeded (line 373) | async fn emit_dependent_burst_seeded(
  function dep_chain_id_for_output_handle (line 436) | async fn dep_chain_id_for_output_handle(
  function wait_for_next_block (line 460) | async fn wait_for_next_block(
  function wait_for_event_counts (line 489) | async fn wait_for_event_counts(
  function test_slow_lane_threshold_matrix_locally (line 520) | async fn test_slow_lane_threshold_matrix_locally() -> Result<(), anyhow:...
  function test_schedule_priority_migration_contract (line 566) | async fn test_schedule_priority_migration_contract() -> Result<(), anyho...
  function test_slow_lane_cross_block_sustained_below_cap_stays_fast_locally (line 645) | async fn test_slow_lane_cross_block_sustained_below_cap_stays_fast_locally(
  function test_slow_lane_cross_block_parent_lookup_finds_known_slow_parent_locally (line 729) | async fn test_slow_lane_cross_block_parent_lookup_finds_known_slow_paren...
  function test_slow_lane_priority_is_monotonic_across_blocks_locally (line 781) | async fn test_slow_lane_priority_is_monotonic_across_blocks_locally(
  function test_slow_lane_off_mode_promotes_all_chains_on_startup_locally (line 842) | async fn test_slow_lane_off_mode_promotes_all_chains_on_startup_locally(
  function test_slow_lane_contention_prefers_fast_chain (line 883) | async fn test_slow_lane_contention_prefers_fast_chain(
  function test_only_catchup_loop_requires_negative_start_at_block (line 977) | async fn test_only_catchup_loop_requires_negative_start_at_block(
  function test_listener_restart_and_chain_reorg (line 1018) | async fn test_listener_restart_and_chain_reorg() -> Result<(), anyhow::E...
  function check_finalization_status (line 1022) | async fn check_finalization_status(setup: &Setup) {
  function test_listener_no_event_loss (line 1097) | async fn test_listener_no_event_loss(
  function test_health (line 1206) | async fn test_health() -> Result<(), anyhow::Error> {
  function test_catchup_and_listen (line 1242) | async fn test_catchup_and_listen() -> Result<(), anyhow::Error> {
  function test_catchup_only (line 1309) | async fn test_catchup_only() -> Result<(), anyhow::Error> {
  type CatchupOutcome (line 1360) | struct CatchupOutcome {
  function run_catchup_only_scenario (line 1369) | async fn run_catchup_only_scenario<F>(
  function test_catchup_only_absolute_end (line 1420) | async fn test_catchup_only_absolute_end() -> Result<(), anyhow::Error> {
  function test_catchup_only_relative_end (line 1451) | async fn test_catchup_only_relative_end() -> Result<(), anyhow::Error> {
  constant NB_DELEGATION_PER_WALLET (line 1519) | const NB_DELEGATION_PER_WALLET: usize = 15;
  function emit_delegations (line 1521) | async fn emit_delegations<P, N>(
  function test_listener_delegations (line 1575) | async fn test_listener_delegations() -> Result<(), anyhow::Error> {

FILE: coprocessor/fhevm-engine/host-listener/tests/poller_integration_tests.rs
  function poller_state_round_trip (line 34) | async fn poller_state_round_trip() -> Result<(), Box<dyn std::error::Err...
  type EventKind (line 62) | enum EventKind {
  function poller_catches_up_to_safe_tip (line 69) | async fn poller_catches_up_to_safe_tip(

FILE: coprocessor/fhevm-engine/scheduler/src/dfg.rs
  type ExecNode (line 25) | pub struct ExecNode {
    method fmt (line 30) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
  type DFGOp (line 44) | pub struct DFGOp {
  method default (line 51) | fn default() -> Self {
  type ComponentEdge (line 60) | pub type ComponentEdge = ();
  type ComponentNode (line 62) | pub struct ComponentNode {
    method build (line 225) | pub fn build(
    method add_input (line 281) | pub fn add_input(&mut self, handle: &[u8], cct: DFGTxInput) {
    method fmt (line 288) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
  function is_needed (line 79) | fn is_needed(graph: &Dag<(bool, usize), OpEdge>, index: usize) -> bool {
  function finalize (line 117) | pub fn finalize(graph: &mut Dag<(bool, usize), OpEdge>) -> Vec<usize> {
  type ComponentNodes (line 159) | type ComponentNodes = Result<(Vec<ComponentNode>, Vec<(Handle, Handle)>)>;
  function build_component_nodes (line 160) | pub fn build_component_nodes(
  type DFComponentGraph (line 308) | pub struct DFComponentGraph {
    method build (line 316) | pub fn build(&mut self, nodes: &mut Vec<ComponentNode>) -> Result<()> {
    method resolve_dependences (line 398) | pub fn resolve_dependences(&mut self, fetched_handles: &HashSet<Handle...
    method add_input (line 465) | pub fn add_input(&mut self, handle: &[u8], input: &DFGTxInput) -> Resu...
    method add_output (line 477) | pub fn add_output(
    method set_uncomputable (line 539) | fn set_uncomputable(
    method get_results (line 574) | pub fn get_results(&mut self) -> Vec<DFGTxResult> {
    method get_intermediate_handles (line 577) | pub fn get_intermediate_handles(&mut self) -> Vec<(Handle, Handle)> {
    method fmt (line 593) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
  type DFGResult (line 612) | pub struct DFGResult {
  type OpEdge (line 617) | pub type OpEdge = u8;
  type OpNode (line 618) | pub struct OpNode {
    method fmt (line 625) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
    method check_ready_inputs (line 633) | fn check_ready_inputs(&mut self, ct_map: &mut HashMap<Handle, Option<D...
  type DFGraph (line 654) | pub struct DFGraph {
    method add_node (line 658) | pub fn add_node(
    method add_dependence (line 672) | pub fn add_dependence(
  function add_execution_dependences (line 690) | pub fn add_execution_dependences<TNode, TEdge>(
  function partition_preserving_parallelism (line 723) | pub fn partition_preserving_parallelism<TNode, TEdge>(
  function partition_components (line 765) | pub fn partition_components<TNode, TEdge>(

FILE: coprocessor/fhevm-engine/scheduler/src/dfg/scheduler.rs
  constant OPERATION_RERANDOMISATION_DOMAIN_SEPARATOR (line 27) | const OPERATION_RERANDOMISATION_DOMAIN_SEPARATOR: [u8; 8] = *b"TFHE_Rrd";
  constant COMPACT_PUBLIC_ENCRYPTION_DOMAIN_SEPARATOR (line 28) | const COMPACT_PUBLIC_ENCRYPTION_DOMAIN_SEPARATOR: [u8; 8] = *b"TFHE_Enc";
  type PartitionStrategy (line 30) | pub enum PartitionStrategy {
  type DeviceSelection (line 35) | enum DeviceSelection {
  type Scheduler (line 43) | pub struct Scheduler<'a> {
  type PartitionResult (line 54) | type PartitionResult = (HashMap<Handle, Result<TaskResult>>, NodeIndex);
  function is_ready_task (line 56) | fn is_ready_task(&self, node: &ExecNode) -> bool {
  function new (line 61) | pub fn new(
  function schedule (line 81) | pub async fn schedule(&mut self) -> Result<()> {
  function get_keys (line 117) | fn get_keys(
  function get_keys (line 124) | fn get_keys(
  function schedule_coarse_grain (line 152) | async fn schedule_coarse_grain(&mut self, strategy: PartitionStrategy) -...
  function re_randomise_operation_inputs (line 254) | fn re_randomise_operation_inputs(
  type ComponentSet (line 276) | type ComponentSet = Vec<(DFGraph, HashMap<Handle, Option<DFGTxInput>>, H...
  function execute_partition (line 277) | fn execute_partition(
  function try_execute_node (line 403) | fn try_execute_node(
  type OpResult (line 470) | type OpResult = Result<CompressedCiphertext>;
  function run_computation (line 471) | fn run_computation(

FILE: coprocessor/fhevm-engine/scheduler/src/dfg/types.rs
  type CompressedCiphertext (line 5) | pub struct CompressedCiphertext {
  type TaskResult (line 10) | pub struct TaskResult {
  type DFGTxResult (line 15) | pub struct DFGTxResult {
    method fmt (line 21) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
  type DFGTxInput (line 36) | pub enum DFGTxInput {
    method fmt (line 41) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
  type DFGTaskInput (line 50) | pub enum DFGTaskInput {
    method fmt (line 56) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
  type SchedulerError (line 66) | pub enum SchedulerError {
    method fmt (line 78) | fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {

FILE: coprocessor/fhevm-engine/sns-worker/src/aws_upload.rs
  constant EVENT_CIPHERTEXTS_UPLOADED (line 29) | pub const EVENT_CIPHERTEXTS_UPLOADED: &str = "event_ciphertexts_uploaded";
  constant DEFAULT_BATCH_SIZE (line 34) | const DEFAULT_BATCH_SIZE: usize = 10;
  function spawn_resubmit_task (line 36) | pub(crate) async fn spawn_resubmit_task(
  function spawn_uploader (line 60) | pub(crate) async fn spawn_uploader(
  function run_uploader_loop (line 84) | async fn run_uploader_loop(
  type UploadResult (line 215) | enum UploadResult {
  function upload_ciphertexts (line 228) | async fn upload_ciphertexts(
  function compute_digest (line 440) | pub fn compute_digest(ct: &[u8]) -> Vec<u8> {
  function fetch_pending_uploads (line 450) | async fn fetch_pending_uploads(
  function do_resubmits_loop (line 569) | async fn do_resubmits_loop(
  function try_resubmit (line 632) | async fn try_resubmit(
  function check_is_ready (line 681) | pub(crate) async fn check_is_ready(client: &Client, conf: &Config) -> (b...
  function check_object_exists (line 692) | async fn check_object_exists(
  function check_bucket_exists (line 709) | async fn check_bucket_exists(

FILE: coprocessor/fhevm-engine/sns-worker/src/bin/sns_worker.rs
  function handle_sigint (line 9) | fn handle_sigint(token: CancellationToken) {
  function construct_config (line 17) | fn construct_config() -> Config {
  function main (line 64) | async fn main() {

FILE: coprocessor/fhevm-engine/sns-worker/src/bin/utils/daemon_cli.rs
  type Args (line 13) | pub struct Args {
  function parse_args (line 131) | pub fn parse_args() -> Args {

FILE: coprocessor/fhevm-engine/sns-worker/src/executor.rs
  constant S3_HEALTH_CHECK_TIMEOUT (line 46) | const S3_HEALTH_CHECK_TIMEOUT: Duration = Duration::from_secs(5);
  type Order (line 49) | pub enum Order {
    method fmt (line 55) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  type SwitchNSquashService (line 63) | pub struct SwitchNSquashService {
    method create (line 129) | pub async fn create(
    method run (line 148) | pub async fn run(&self, pool_mngr: &PostgresPoolManager) {
  method health_check (line 76) | async fn health_check(&self) -> HealthStatus {
  method is_alive (line 107) | async fn is_alive(&self) -> bool {
  method get_version (line 118) | fn get_version(&self) -> Version {
  function get_keyset (line 180) | async fn get_keyset(
  function run_loop (line 188) | pub(crate) async fn run_loop(
  function garbage_collect (line 288) | pub async fn garbage_collect(pool: &PgPool, limit: u32) -> Result<(), Ex...
  function fetch_and_execute_sns_tasks (line 355) | async fn fetch_and_execute_sns_tasks(
  function query_sns_tasks (line 442) | pub async fn query_sns_tasks(
  function enqueue_upload_tasks (line 510) | async fn enqueue_upload_tasks(
  function process_tasks (line 525) | fn process_tasks(
  function compute_task (line 567) | fn compute_task(
  function update_ciphertext128 (line 684) | async fn update_ciphertext128(
  function update_computations_status (line 736) | async fn update_computations_status(
  function notify_ciphertext128_ready (line 759) | async fn notify_ciphertext128_ready(
  function decompress_ct (line 771) | fn decompress_ct(
  function decrypt_big_ct (line 783) | fn decrypt_big_ct(
  function update_last_active (line 804) | async fn update_last_active(last_active_at: Arc<RwLock<SystemTime>>) {

FILE: coprocessor/fhevm-engine/sns-worker/src/keyset.rs
  constant SKS_KEY_WITH_NOISE_SQUASHING_SIZE (line 12) | const SKS_KEY_WITH_NOISE_SQUASHING_SIZE: usize = 1_150 * 1_000_000;
  function fetch_latest_key_id_gw (line 14) | async fn fetch_latest_key_id_gw(pool: &PgPool) -> Result<Option<(DbKeyId...
  function fetch_latest_keyset (line 30) | pub(crate) async fn fetch_latest_keyset(
  function fetch_keyset_by_id (line 42) | async fn fetch_keyset_by_id(
  function fetch_client_key (line 99) | pub async fn fetch_client_key(

FILE: coprocessor/fhevm-engine/sns-worker/src/lib.rs
  constant UPLOAD_QUEUE_SIZE (line 50) | pub const UPLOAD_QUEUE_SIZE: usize = 20;
  constant SAFE_SER_LIMIT (line 51) | pub const SAFE_SER_LIMIT: u64 = 1024 * 1024 * 66;
  type InternalEvents (line 52) | pub type InternalEvents = Option<tokio::sync::mpsc::Sender<&'static str>>;
  type ServerKey (line 55) | type ServerKey = tfhe::CudaServerKey;
  type ServerKey (line 57) | type ServerKey = tfhe::ServerKey;
  type KeySet (line 60) | pub struct KeySet {
  type DBConfig (line 68) | pub struct DBConfig {
  type SNSMetricsConfig (line 85) | pub struct SNSMetricsConfig {
  type S3Config (line 91) | pub struct S3Config {
  type S3RetryPolicy (line 99) | pub struct S3RetryPolicy {
  type HealthCheckConfig (line 108) | pub struct HealthCheckConfig {
  type Config (line 114) | pub struct Config {
    method fmt (line 145) | fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
  type SchedulePolicy (line 127) | pub enum SchedulePolicy {
    method from (line 134) | fn from(value: String) -> Self {
  type Ciphertext128Format (line 155) | pub enum Ciphertext128Format {
    method from_i16 (line 165) | pub fn from_i16(value: i16) -> Option<Self> {
    method fmt (line 212) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
  function from (line 177) | fn from(format: Ciphertext128Format) -> Self {
  type BigCiphertext (line 183) | pub struct BigCiphertext {
    method new_with_format_id (line 189) | pub fn new_with_format_id(bytes: Vec<u8>, format_id: i16) -> Option<Se...
    method new (line 194) | pub fn new(bytes: Vec<u8>, format: Ciphertext128Format) -> Self {
    method is_empty (line 198) | pub fn is_empty(&self) -> bool {
    method bytes (line 202) | pub fn bytes(&self) -> &[u8] {
    method format (line 206) | pub fn format(&self) -> Ciphertext128Format {
  type HandleItem (line 224) | pub struct HandleItem {
    method enqueue_upload_task (line 248) | pub(crate) async fn enqueue_upload_task(
    method update_ct128_uploaded (line 266) | pub(crate) async fn update_ct128_uploaded(
    method update_ct64_uploaded (line 294) | pub(crate) async fn update_ct64_uploaded(
  method from (line 320) | fn from(err: ExecutionError) -> Self {
  type ExecutionError (line 331) | pub enum ExecutionError {
  type UploadJob (line 376) | pub enum UploadJob {
    method handle (line 387) | pub fn handle(&self) -> &[u8] {
  function run_computation_loop (line 396) | pub async fn run_computation_loop(
  function run_uploader_loop (line 440) | pub async fn run_uploader_loop(
  function create_s3_client (line 472) | pub async fn create_s3_client(conf: &Config) -> (Arc<aws_sdk_s3::Client>...
  function run_all (line 500) | pub async fn run_all(

FILE: coprocessor/fhevm-engine/sns-worker/src/metrics.rs
  function spawn_gauge_update_routine (line 68) | pub fn spawn_gauge_update_routine(period: std::time::Duration, db_pool: ...

FILE: coprocessor/fhevm-engine/sns-worker/src/squash_noise.rs
  type SquashNoiseCiphertext (line 115) | pub(crate) trait SquashNoiseCiphertext {
    method squash_noise_and_serialize (line 119) | fn squash_noise_and_serialize(
    method decrypt_squash_noise (line 126) | fn decrypt_squash_noise(
    method decrypt_squash_noise_compressed (line 134) | fn decrypt_squash_noise_compressed(
    method squash_noise_and_serialize (line 142) | fn squash_noise_and_serialize(
    method decrypt_squash_noise (line 252) | fn decrypt_squash_noise(
    method decrypt_squash_noise_compressed (line 274) | fn decrypt_squash_noise_compressed(
  function safe_serialize (line 303) | pub fn safe_serialize<T: Serialize + Named + Versionize>(
  function safe_deserialize (line 313) | pub fn safe_deserialize<T: serde::de::DeserializeOwned + Named + tfhe::U...

FILE: coprocessor/fhevm-engine/sns-worker/src/tests/mod.rs
  constant LISTEN_CHANNEL (line 32) | const LISTEN_CHANNEL: &str = "sns_worker_chan";
  function init_tracing (line 36) | pub fn init_tracing() {
  function test_fhe_ciphertext128_with_compression (line 44) | async fn test_fhe_ciphertext128_with_compression() {
  function test_batch_execution (line 78) | async fn test_batch_execution() {
  function test_fhe_ciphertext128_no_compression (line 104) | async fn test_fhe_ciphertext128_no_compression() {
  function test_decryptable (line 121) | async fn test_decryptable(
  function run_batch_computations (line 148) | async fn run_batch_computations(
  function test_lifo_mode (line 219) | async fn test_lifo_mode() {
  function test_garbage_collect (line 307) | async fn test_garbage_collect() {
  type TestEnvironment (line 404) | struct TestEnvironment {
  function setup (line 415) | async fn setup(enable_compression: bool) -> anyhow::Result<TestEnvironme...
  function setup_localstack (line 480) | async fn setup_localstack(
  function recreate_bucket (line 509) | async fn recreate_bucket(s3_client: &aws_sdk_s3::Client, bucket_name: &s...
  type TestFile (line 528) | struct TestFile {
  function write_test_file (line 537) | fn write_test_file(filename: &str) {
  function read_test_file (line 555) | fn read_test_file(filename: &str) -> TestFile {
  function fetch_latest_key_id_gw (line 562) | async fn fetch_latest_key_id_gw(pool: &sqlx::PgPool) -> DbKeyId {
  function fetch_host_chain_id (line 569) | async fn fetch_host_chain_id(pool: &sqlx::PgPool) -> i64 {
  function insert_ciphertext64 (line 576) | async fn insert_ciphertext64(
  function insert_into_pbs_computations (line 592) | async fn insert_into_pbs_computations(
  function clean_up (line 609) | async fn clean_up(pool: &sqlx::PgPool) -> anyhow::Result<()> {
  function assert_ciphertext128 (line 625) | async fn assert_ciphertext128(
  function assert_ciphertext_uploaded (line 697) | async fn assert_ciphertext_uploaded(
  function assert_ciphertext_uploaded (line 714) | async fn assert_ciphertext_uploaded(
  function assert_ciphertext_s3_object_count (line 725) | async fn assert_ciphertext_s3_object_count(
  function assert_ciphertext_s3_object_count (line 735) | async fn assert_ciphertext_s3_object_count(
  function build_test_config (line 743) | fn build_test_config(url: DatabaseURL, enable_compression: bool) -> Conf...

FILE: coprocessor/fhevm-engine/stress-test-generator/src/args.rs
  type Args (line 5) | pub struct Args {
  function parse_args (line 23) | pub fn parse_args() -> Args {

FILE: coprocessor/fhevm-engine/stress-test-generator/src/auction.rs
  type BidEntry (line 18) | pub struct BidEntry {
  type ContractState (line 24) | pub struct ContractState {
  function batch_submit_encrypted_bids (line 33) | pub async fn batch_submit_encrypted_bids(
  function process_bid_entry (line 142) | pub async fn process_bid_entry(
  function process_batch_payment (line 235) | pub async fn process_batch_payment(
  function confirm_and_finalize_bid (line 279) | pub async fn confirm_and_finalize_bid(

FILE: coprocessor/fhevm-engine/stress-test-generator/src/bin/stress_generator.rs
  constant MAX_RETRIES (line 53) | const MAX_RETRIES: usize = 500;
  constant MAX_NUMBER_OF_BIDS (line 54) | const MAX_NUMBER_OF_BIDS: usize = 10;
  function main (line 57) | async fn main() {
  type AppState (line 89) | struct AppState {
    method new (line 95) | fn new(sender: mpsc::Sender<Job>) -> Self {
    method add_job (line 102) | async fn add_job(
    method update_job_status (line 112) | async fn update_job_status(&self, job_id: u64, new: JobStatus) {
    method cancel_job (line 121) | async fn cancel_job(&self, job_id: u64) {
  type JobStatus (line 149) | enum JobStatus {
    method fmt (line 157) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
  function run_service (line 167) | async fn run_service(ctx: Context) -> Result<(), Box<dyn std::error::Err...
  function get_job (line 217) | async fn get_job(
  type EnqueuedJob (line 234) | struct EnqueuedJob {
  type RunningJob (line 241) | struct RunningJob {
  function enqueue_job (line 246) | async fn enqueue_job(
  function get_running_job (line 279) | async fn get_running_job(
  function get_queued_job (line 306) | async fn get_queued_job(
  function cancel_job (line 325) | async fn cancel_job(
  function parse_and_execute (line 335) | async fn parse_and_execute(ctx: Context) -> Result<(), Box<dyn std::erro...
  function spawn_and_wait_all (line 399) | async fn spawn_and_wait_all(
  function generate_transactions_at_rate (line 427) | async fn generate_transactions_at_rate(
  function generate_transactions_count (line 503) | async fn generate_transactions_count(
  function generate_transaction (line 545) | async fn generate_transaction(

FILE: coprocessor/fhevm-engine/stress-test-generator/src/dex.rs
  function dex_swap_request_update_dex_balance (line 15) | async fn dex_swap_request_update_dex_balance(
  function dex_swap_request_finalize (line 66) | async fn dex_swap_request_finalize(
  function dex_swap_request_transaction (line 112) | pub async fn dex_swap_request_transaction(
  function dex_swap_claim_prepare (line 273) | async fn dex_swap_claim_prepare(
  function dex_swap_claim_update_dex_balance (line 417) | async fn dex_swap_claim_update_dex_balance(
  function dex_swap_claim_transaction (line 464) | pub async fn dex_swap_claim_transaction(

FILE: coprocessor/fhevm-engine/stress-test-generator/src/erc20.rs
  function erc20_transaction (line 16) | pub async fn erc20_transaction(

FILE: coprocessor/fhevm-engine/stress-test-generator/src/erc7984.rs
  function confidential_transfer_from (line 14) | pub async fn confidential_transfer_from(
  function try_decrease (line 141) | pub async fn try_decrease(

FILE: coprocessor/fhevm-engine/stress-test-generator/src/synthetics.rs
  function add_chain_transaction (line 15) | pub async fn add_chain_transaction(
  function mul_chain_transaction (line 79) | pub async fn mul_chain_transaction(
  function generate_pub_decrypt_handles_types (line 143) | pub async fn generate_pub_decrypt_handles_types(
  function generate_user_decrypt_handles_types (line 186) | pub async fn generate_user_decrypt_handles_types(

FILE: coprocessor/fhevm-engine/stress-test-generator/src/utils.rs
  function tfhe_event (line 19) | pub fn tfhe_event(data: TfheContractEvents) -> Log<TfheContractEvents> {
  constant DEF_TYPE (line 26) | pub const DEF_TYPE: FheType = FheType::FheUint64;
  constant HOST_CHAIN_ID (line 27) | pub const HOST_CHAIN_ID: i64 = 12345;
  type FheType (line 30) | pub enum FheType {
    method from (line 46) | fn from(value: u8) -> Self {
  function next_random_handle (line 65) | pub fn next_random_handle(ct_type: FheType) -> Handle {
  function new_transaction_id (line 83) | pub fn new_transaction_id() -> Handle {
  function default_dependence_cache_size (line 92) | pub fn default_dependence_cache_size() -> u16 {
  type Transaction (line 97) | pub enum Transaction {
  type ERCTransferVariant (line 113) | pub enum ERCTransferVariant {
  type GeneratorKind (line 119) | pub enum GeneratorKind {
  type Dependence (line 124) | pub enum Dependence {
  type Inputs (line 130) | pub enum Inputs {
  type Scenario (line 136) | pub struct Scenario {
  type Job (line 148) | pub struct Job {
  type Context (line 155) | pub struct Context {
  function allow_handle (line 164) | pub async fn allow_handle(
  function allow_handles (line 197) | pub async fn allow_handles(
  function as_scalar_uint (line 232) | pub fn as_scalar_uint(big_int: &BigInt) -> ClearConst {
  function generate_trivial_encrypt (line 238) | pub async fn generate_trivial_encrypt(
  function query_and_save_pks (line 273) | pub async fn query_and_save_pks(
  function get_ciphertext_digests (line 297) | pub async fn get_ciphertext_digests(
  type EnvConfig (line 326) | pub struct EnvConfig {
    method new (line 360) | pub fn new() -> Self {
  method default (line 353) | fn default() -> Self {
  function insert_tfhe_event (line 414) | pub async fn insert_tfhe_event(
  function pool (line 439) | pub async fn pool(listener_event_to_db: &ListenerDatabase) -> sqlx::Pool...

FILE: coprocessor/fhevm-engine/stress-test-generator/src/zk_gen.rs
  constant SIZE (line 17) | const SIZE: usize = 92;
  constant CACHED_INPUTS_COUNT (line 18) | const CACHED_INPUTS_COUNT: u8 = 16;
  type ContractKey (line 20) | type ContractKey = (String, String);
  type ContractValues (line 21) | type ContractValues = Vec<Option<Handle>>;
  type ContractInputs (line 22) | type ContractInputs = RwLock<HashMap<ContractKey, ContractValues>>;
  type ZkData (line 36) | struct ZkData {
    method assemble (line 44) | pub fn assemble(&self) -> anyhow::Result<[u8; SIZE]> {
  function insert_proof (line 63) | async fn insert_proof(
  function wait_for_verification_and_handle (line 105) | async fn wait_for_verification_and_handle(
  function generate_random_handle_amount_if_none (line 143) | pub async fn generate_random_handle_amount_if_none(
  function generate_random_handle_vec (line 155) | pub async fn generate_random_handle_vec(
  function generate_and_insert_inputs_batch (line 218) | pub async fn generate_and_insert_inputs_batch(
  function get_inputs_vector (line 277) | pub async fn get_inputs_vector(
  function generate_input_verification_transaction (line 319) | pub async fn generate_input_verification_transaction(

FILE: coprocessor/fhevm-engine/test-harness/src/db_utils.rs
  constant ACL_CONTRACT_ADDR (line 14) | pub const ACL_CONTRACT_ADDR: &str = "0x339EcE85B9E11a3A3AA557582784a15d7...
  function import_file_into_db (line 17) | pub async fn import_file_into_db(pool: &PgPool, file_path: &str) -> Resu...
  function insert_ciphertext64 (line 36) | pub async fn insert_ciphertext64(
  function insert_into_pbs_computations (line 57) | pub async fn insert_into_pbs_computations(
  function insert_ciphertext_digest (line 75) | pub async fn insert_ciphertext_digest(
  function wait_for_ciphertext (line 103) | pub async fn wait_for_ciphertext(
  function setup_test_key (line 136) | pub async fn setup_test_key(
  function insert_random_keys_and_host_chain (line 231) | pub async fn insert_random_keys_and_host_chain(
  function truncate_tables (line 310) | pub async fn truncate_tables(db_pool: &sqlx::PgPool, tables: Vec<&str>) ...

FILE: coprocessor/fhevm-engine/test-harness/src/health_check.rs
  function wait_url_success (line 5) | pub async fn wait_url_success(url: &str, retry: u64, delay: u64) -> bool {
  function wait_alive (line 27) | pub async fn wait_alive(url: &str, retry: u64, delay: u64) -> bool {
  function wait_healthy (line 32) | pub async fn wait_healthy(url: &str, retry: u64, delay: u64) -> bool {

FILE: coprocessor/fhevm-engine/test-harness/src/instance.rs
  type DBInstance (line 12) | pub struct DBInstance {
    method db_url (line 19) | pub fn db_url(&self) -> &str {
  function setup_test_db (line 44) | pub async fn setup_test_db(mode: ImportMode) -> Result<DBInstance, Box<d...
  function setup_test_app_existing_localhost (line 58) | async fn setup_test_app_existing_localhost(
  constant POSTGRES_PORT (line 81) | const POSTGRES_PORT: u16 = 5432;
  function setup_test_app_custom_docker (line 83) | async fn setup_test_app_custom_docker(
  type ImportMode (line 113) | pub enum ImportMode {
  function create_database (line 120) | async fn create_database(
  function get_sns_pk_size (line 170) | pub async fn get_sns_pk_size(pool: &sqlx::PgPool) -> Result<i64, sqlx::E...

FILE: coprocessor/fhevm-engine/test-harness/src/localstack.rs
  function pick_free_port (line 10) | pub fn pick_free_port() -> u16 {
  constant LOCALSTACK_PORT (line 18) | pub const LOCALSTACK_PORT: u16 = 4566;
  type LocalstackContainer (line 20) | pub struct LocalstackContainer {
  function start_localstack (line 25) | pub async fn start_localstack() -> anyhow::Result<LocalstackContainer> {
  function create_aws_aws_kms_client (line 40) | pub async fn create_aws_aws_kms_client(host_port: u16) -> anyhow::Result...
  function create_localstack_kms_signing_key (line 52) | pub async fn create_localstack_kms_signing_key(

FILE: coprocessor/fhevm-engine/test-harness/src/s3_utils.rs
  function assert_key_exists (line 13) | pub async fn assert_key_exists(
  function assert_object_count (line 50) | pub async fn assert_object_count(client: Client, bucket: &String, expect...

FILE: coprocessor/fhevm-engine/tfhe-worker/benches/dex.rs
  function main (line 22) | fn main() {
  function sample_count (line 192) | fn sample_count(default_count: usize) -> usize {
  function next_log_index (line 199) | fn next_log_index() -> u64 {
  function log_with_tx (line 204) | fn log_with_tx(
  function scalar_u128_handle (line 220) | fn scalar_u128_handle(value: u128) -> Handle {
  function insert_event (line 226) | async fn insert_event(
  function insert_trivial_encrypt (line 244) | async fn insert_trivial_encrypt(
  function schedule_dex (line 268) | async fn schedule_dex(
  function swap_request_whitepaper (line 1230) | async fn swap_request_whitepaper(
  function swap_request_no_cmux (line 1247) | async fn swap_request_no_cmux(
  function swap_claim_whitepaper (line 1264) | async fn swap_claim_whitepaper(
  function swap_claim_no_cmux (line 1272) | async fn swap_claim_no_cmux(
  function swap_request_whitepaper_dep (line 1280) | async fn swap_request_whitepaper_dep(
  function swap_request_no_cmux_dep (line 1297) | async fn swap_request_no_cmux_dep(
  function swap_claim_whitepaper_dep (line 1314) | async fn swap_claim_whitepaper_dep(
  function swap_claim_no_cmux_dep (line 1322) | async fn swap_claim_no_cmux_dep(

FILE: coprocessor/fhevm-engine/tfhe-worker/benches/erc20.rs
  function main (line 18) | fn main() {
  function sample_count (line 110) | fn sample_count(default_count: usize) -> usize {
  function next_log_index (line 117) | fn next_log_index() -> u64 {
  function log_with_tx (line 122) | fn log_with_tx(
  function schedule_erc20 (line 138) | async fn schedule_erc20(
  function schedule_erc20_whitepaper (line 445) | async fn schedule_erc20_whitepaper(
  function schedule_erc20_no_cmux (line 453) | async fn schedule_erc20_no_cmux(
  function schedule_dependent_erc20_whitepaper (line 461) | async fn schedule_dependent_erc20_whitepaper(
  function schedule_dependent_erc20_no_cmux (line 469) | async fn schedule_dependent_erc20_no_cmux(

FILE: coprocessor/fhevm-engine/tfhe-worker/benches/synthetics.rs
  function main (line 18) | fn main() {
  function sample_count (line 83) | fn sample_count(default_count: usize) -> usize {
  function next_log_index (line 90) | fn next_log_index() -> u64 {
  function log_with_tx (line 95) | fn log_with_tx(
  function counter_increment (line 111) | async fn counter_increment(
  function tree_reduction (line 224) | async fn tree_reduction(

FILE: coprocessor/fhevm-engine/tfhe-worker/benches/utils.rs
  type TestInstance (line 21) | pub struct TestInstance {
    method db_url (line 38) | pub fn db_url(&self) -> &str {
  method drop (line 30) | fn drop(&mut self) {
  function random_handle (line 43) | pub fn random_handle() -> u64 {
  function setup_test_app (line 47) | pub async fn setup_test_app() -> Result<TestInstance, Box<dyn std::error...
  constant LOCAL_DB_URL (line 55) | const LOCAL_DB_URL: &str = "postgresql://postgres:postgres@127.0.0.1:543...
  function setup_test_app_existing_db (line 57) | async fn setup_test_app_existing_db() -> Result<TestInstance, Box<dyn st...
  function start_coprocessor (line 67) | async fn start_coprocessor(rx: Receiver<bool>, db_url: &str) {
  function setup_test_app_custom_docker (line 104) | async fn setup_test_app_custom_docker() -> Result<TestInstance, Box<dyn ...
  function wait_until_all_allowed_handles_computed (line 143) | pub async fn wait_until_all_allowed_handles_computed(
  function to_ty (line 167) | pub fn to_ty(ty: i32) -> ToType {
  function as_scalar_uint (line 171) | pub fn as_scalar_uint(big_int: &BigInt) -> ClearConst {
  function as_handle (line 176) | pub fn as_handle(v: u64) -> Handle {
  function next_handle (line 182) | pub fn next_handle(counter: &mut u64) -> Handle {
  function tfhe_event (line 188) | pub fn tfhe_event(data: TfheContractEvents) -> Log<TfheContractEvents> {
  function listener_event_db (line 195) | pub async fn listener_event_db(
  function default_dependence_cache_size (line 206) | pub fn default_dependence_cache_size() -> u16 {
  function insert_tfhe_event (line 210) | pub async fn insert_tfhe_event(
  function allow_handle (line 230) | pub async fn allow_handle(
  function zero_address (line 245) | pub fn zero_address() -> alloy::primitives::Address {
  function scalar_flag (line 251) | pub fn scalar_flag(is_scalar: bool) -> FixedBytes<1> {
  function from (line 273) | fn from(params: PBSParameters) -> Self {
  function from (line 298) | fn from(params: ShortintKeySwitchingParameters) -> Self {
  function from (line 308) | fn from(params: CompactPublicKeyEncryptionParameters) -> Self {
  function from (line 319) | fn from((comp_params, pbs_params): (CompressionParameters, ClassicPBSPar...
  function from (line 325) | fn from(
  function from (line 337) | fn from((comp_params, pbs_params): (CompressionParameters, PBSParameters...
  function from (line 361) | fn from(params: AtomicPatternParameters) -> Self {
  constant MULTI_BIT_THREADS_ARRAY (line 389) | const MULTI_BIT_THREADS_ARRAY: [((MessageModulus, CarryModulus, LweBskGr...
  function multi_bit_num_threads (line 459) | pub fn multi_bit_num_threads(
  type ParametersSet (line 482) | pub enum ParametersSet {
    method from_env (line 489) | pub fn from_env() -> Result<Self, String> {
  function init_parameters_set (line 500) | pub fn init_parameters_set() {
  type DesiredNoiseDistribution (line 506) | pub enum DesiredNoiseDistribution {
  type DesiredBackend (line 514) | pub enum DesiredBackend {
    method matches_parameter_name_backend (line 521) | fn matches_parameter_name_backend(&self, param_name: &str) -> bool {
  function filter_parameters (line 530) | pub fn filter_parameters<'a, P: Copy + Into<PBSParameters>>(
  type CryptoParametersRecord (line 562) | pub struct CryptoParametersRecord<Scalar: UnsignedInteger> {
  function noise_distribution_as_string (line 595) | pub fn noise_distribution_as_string(noise_distribution: DynamicDistribut...
  function serialize_distribution (line 602) | pub fn serialize_distribution<S>(
  type PolynomialMultiplication (line 617) | enum PolynomialMultiplication {
  type IntegerRepresentation (line 623) | enum IntegerRepresentation {
  type ExecutionType (line 630) | enum ExecutionType {
  type KeySetType (line 636) | enum KeySetType {
  type OperandType (line 642) | enum OperandType {
  type OperatorType (line 648) | pub enum OperatorType {
  type BenchmarkParametersRecord (line 654) | struct BenchmarkParametersRecord<Scalar: UnsignedInteger> {
  function write_to_json (line 675) | pub fn write_to_json<
  function write_atomic_u64_bench_params (line 727) | pub async fn write_atomic_u64_bench_params(
  constant GPU_MAX_SUPPORTED_POLYNOMIAL_SIZE (line 753) | pub const GPU_MAX_SUPPORTED_POLYNOMIAL_SIZE: usize = 16384;
  constant FAST_BENCH_BIT_SIZES (line 755) | const FAST_BENCH_BIT_SIZES: [usize; 1] = [64];
  constant BENCH_BIT_SIZES (line 756) | const BENCH_BIT_SIZES: [usize; 8] = [4, 8, 16, 32, 40, 64, 128, 256];
  constant MULTI_BIT_CPU_SIZES (line 757) | const MULTI_BIT_CPU_SIZES: [usize; 6] = [4, 8, 16, 32, 40, 64];
  type EnvConfig (line 761) | pub struct EnvConfig {
    method new (line 774) | pub fn new() -> Self {
    method bit_sizes (line 812) | pub fn bit_sizes(&self) -> Vec<usize> {

FILE: coprocessor/fhevm-engine/tfhe-worker/src/bin/tfhe_worker.rs
  function main (line 1) | fn main() {

FILE: coprocessor/fhevm-engine/tfhe-worker/src/bin/utils.rs
  type Args (line 9) | struct Args {
  type Commands (line 15) | enum Commands {
  function extract_server_key_without_ns (line 28) | pub fn extract_server_key_without_ns(src_path: String, dest_path: &Strin...
  function main (line 69) | fn main() {

FILE: coprocessor/fhevm-engine/tfhe-worker/src/daemon_cli.rs
  type Args (line 9) | pub struct Args {
  function parse_args (line 118) | pub fn parse_args() -> Args {

FILE: coprocessor/fhevm-engine/tfhe-worker/src/dependence_chain.rs
  constant CLEANUP_INTERVAL_SECS (line 35) | const CLEANUP_INTERVAL_SECS: u32 = 300;
  constant CLEANUP_BATCH_SIZE (line 36) | const CLEANUP_BATCH_SIZE: i64 = 1000;
  constant CLEANUP_AGE_THRESHOLD_SECONDS (line 37) | const CLEANUP_AGE_THRESHOLD_SECONDS: u32 = 48 * 60 * 60;
  type LockingReason (line 40) | pub enum LockingReason {
    method from (line 48) | fn from(s: &str) -> Self {
  type LockMngr (line 61) | pub struct LockMngr {
    method new (line 112) | pub fn new(worker_id: Uuid, pool: sqlx::Pool<Postgres>) -> Self {
    method new_with_conf (line 126) | pub fn new_with_conf(
    method acquire_next_lock (line 147) | pub async fn acquire_next_lock(
    method acquire_early_lock (line 228) | pub async fn acquire_early_lock(
    method release_all_owned_locks (line 292) | pub async fn release_all_owned_locks(&mut self) -> Result<u64, sqlx::E...
    method release_current_lock (line 321) | pub async fn release_current_lock(
    method set_processing_error (line 434) | pub async fn set_processing_error(&self, err: Option<String>) -> Resul...
    method extend_or_release_current_lock (line 473) | pub async fn extend_or_release_current_lock(
    method do_cleanup (line 550) | pub async fn do_cleanup(&mut self) -> Result<u64, sqlx::Error> {
    method get_current_lock (line 581) | pub fn get_current_lock(&self) -> Option<DatabaseChainLock> {
    method worker_id (line 585) | pub fn worker_id(&self) -> Uuid {
    method enabled (line 589) | pub fn enabled(&self) -> bool {
    method take_lock (line 594) | fn take_lock(&mut self) {
  type DatabaseChainLock (line 78) | pub struct DatabaseChainLock {
    method fmt (line 96) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> fmt::Result {
  type LockExpiresAt (line 91) | struct LockExpiresAt {
  function delete_old_processed_dependence_chains (line 603) | async fn delete_old_processed_dependence_chains(

FILE: coprocessor/fhevm-engine/tfhe-worker/src/health_check.rs
  constant ACTIVITY_FRESHNESS (line 8) | const ACTIVITY_FRESHNESS: Duration = Duration::from_secs(10);
  constant CONNECTED_TICK_FRESHNESS (line 9) | const CONNECTED_TICK_FRESHNESS: Duration = Duration::from_secs(5);
  type HealthCheck (line 13) | pub struct HealthCheck {
    method new (line 20) | pub fn new(database_url: DatabaseURL) -> Self {
    method update_db_access (line 29) | pub fn update_db_access(&self) {
    method update_activity (line 33) | pub fn update_activity(&self) {
  method health_check (line 39) | async fn health_check(&self) -> HealthStatus {
  method is_alive (line 60) | async fn is_alive(&self) -> bool {
  method get_version (line 64) | fn get_version(&self) -> Version {

FILE: coprocessor/fhevm-engine/tfhe-worker/src/lib.rs
  function start_runtime (line 19) | pub fn start_runtime(
  function async_main (line 52) | pub async fn async_main(
  function generate_dump_fhe_keys (line 113) | pub fn generate_dump_fhe_keys() {

FILE: coprocessor/fhevm-engine/tfhe-worker/src/tests/dependence_chain.rs
  constant NUM_SAMPLE_CHAINS (line 9) | const NUM_SAMPLE_CHAINS: usize = 10;
  function test_acquire_next_lock (line 13) | async fn test_acquire_next_lock() {
  function test_acquire_next_lock_prefers_fast_lane (line 61) | async fn test_acquire_next_lock_prefers_fast_lane() {
  function test_acquire_early_lock_ignores_priority (line 109) | async fn test_acquire_early_lock_ignores_priority() {
  function test_work_stealing (line 157) | async fn test_work_stealing() {
  function assert_reacquire_lock (line 211) | async fn assert_reacquire_lock(pool: &sqlx::PgPool, dependence_mgr: &mut...
  function assert_locks_available (line 259) | async fn assert_locks_available(pool: &sqlx::PgPool, expected_locks_coun...
  function insert_sample_dcids (line 279) | async fn insert_sample_dcids(
  function test_extend_or_release_lock (line 309) | async fn test_extend_or_release_lock() {
  function test_extend_or_release_lock_2 (line 375) | async fn test_extend_or_release_lock_2() {
  function test_cleanup (line 421) | async fn test_cleanup() {
  function setup (line 448) | async fn setup() -> TestInstance {

FILE: coprocessor/fhevm-engine/tfhe-worker/src/tests/errors.rs
  function test_coprocessor_input_errors (line 11) | async fn test_coprocessor_input_errors() -> Result<(), Box<dyn std::erro...
  function test_coprocessor_computation_errors (line 70) | async fn test_coprocessor_computation_errors() -> Result<(), Box<dyn std...
  function test_type_mismatch_error (line 120) | async fn test_type_mismatch_error() -> Result<(), Box<dyn std::error::Er...
  function test_binary_boolean_inputs_error (line 169) | async fn test_binary_boolean_inputs_error() -> Result<(), Box<dyn std::e...
  function test_unary_boolean_inputs_error (line 218) | async fn test_unary_boolean_inputs_error() -> Result<(), Box<dyn std::er...

FILE: coprocessor/fhevm-engine/tfhe-worker/src/tests/event_helpers.rs
  constant TEST_CHAIN_ID (line 16) | pub const TEST_CHAIN_ID: u64 = 42;
  type EventHarness (line 18) | pub struct EventHarness {
  function setup_event_harness (line 24) | pub async fn setup_event_harness() -> Result<EventHarness, Box<dyn std::...
  function next_handle (line 43) | pub fn next_handle() -> Handle {
  function zero_address (line 54) | pub fn zero_address() -> Address {
  function to_ty (line 60) | pub fn to_ty(ty: i32) -> ToType {
  function as_scalar_uint (line 64) | pub fn as_scalar_uint(value: &BigInt) -> ClearConst {
  function scalar_flag (line 69) | pub fn scalar_flag(is_scalar: bool) -> FixedBytes<1> {
  function scalar_u128_handle (line 73) | pub fn scalar_u128_handle(value: u128) -> Handle {
  function tfhe_event (line 79) | pub fn tfhe_event(data: TfheContractEvents) -> Log<TfheContractEvents> {
  function next_log_index (line 86) | fn next_log_index() -> u64 {
  function log_with_tx (line 91) | pub fn log_with_tx(
  function insert_event (line 107) | pub async fn insert_event(
  function insert_trivial_encrypt (line 129) | pub async fn insert_trivial_encrypt(
  function allow_handle (line 154) | pub async fn allow_handle(
  function decrypt_handles (line 171) | pub async fn decrypt_handles(
  function wait_until_computed (line 179) | pub async fn wait_until_computed(app: &TestInstance) -> Result<(), Box<d...
  function wait_for_error (line 183) | pub async fn wait_for_error(

FILE: coprocessor/fhevm-engine/tfhe-worker/src/tests/health_check.rs
  function test_health_check (line 6) | async fn test_health_check() -> Result<(), Box<dyn std::error::Error>> {

FILE: coprocessor/fhevm-engine/tfhe-worker/src/tests/inputs.rs
  function test_fhe_inputs (line 9) | async fn test_fhe_inputs() -> Result<(), Box<dyn std::error::Error>> {

FILE: coprocessor/fhevm-engine/tfhe-worker/src/tests/migrations.rs
  constant TARGET_MIGRATION_VERSION (line 7) | const TARGET_MIGRATION_VERSION: i64 = 20260128095635;
  function run_migrations_before_target (line 10) | async fn run_migrations_before_target(pool: &PgPool) -> String {
  function seed_old_schema_data (line 39) | async fn seed_old_schema_data(pool: &PgPool) -> i32 {
  function column_exists (line 156) | async fn column_exists(pool: &PgPool, table: &str, column: &str) -> bool {
  function table_exists (line 171) | async fn table_exists(pool: &PgPool, table: &str) -> bool {
  function index_exists (line 185) | async fn index_exists(pool: &PgPool, index_name: &str) -> bool {
  function column_default (line 199) | async fn column_default(pool: &PgPool, table: &str, column: &str) -> Opt...
  function test_remove_tenants_migration_with_data (line 212) | async fn test_remove_tenants_migration_with_data() {
  function test_remove_tenants_migration_rejects_multiple_tenants (line 410) | async fn test_remove_tenants_migration_rejects_multiple_tenants() {
  function test_remove_tenants_migration_empty_db (line 446) | async fn test_remove_tenants_migration_empty_db() {

FILE: coprocessor/fhevm-engine/tfhe-worker/src/tests/mod.rs
  function setup_test_key (line 18) | async fn setup_test_key() -> Result<(), Box<dyn std::error::Error>> {

FILE: coprocessor/fhevm-engine/tfhe-worker/src/tests/operators_from_events.rs
  constant LOCAL_SUPPORTED_TYPES (line 18) | const LOCAL_SUPPORTED_TYPES: &[i32] = &[
  constant FULL_SUPPORTED_TYPES (line 27) | const FULL_SUPPORTED_TYPES: &[i32] = &[
  function supported_types (line 42) | pub fn supported_types() -> &'static [i32] {
  function as_scalar_handle (line 49) | fn as_scalar_handle(big_int: &BigInt) -> Handle {
  function binary_op_to_event (line 58) | fn binary_op_to_event(
  function test_fhe_binary_operands_events (line 227) | async fn test_fhe_binary_operands_events() -> Result<(), Box<dyn std::er...
  function unary_op_to_event (line 322) | fn unary_op_to_event(
  function test_fhe_unary_operands_events (line 352) | async fn test_fhe_unary_operands_events() -> Result<(), Box<dyn std::err...
  function test_fhe_if_then_else_events (line 435) | async fn test_fhe_if_then_else_events() -> Result<(), Box<dyn std::error...
  function test_fhe_cast_events (line 582) | async fn test_fhe_cast_events() -> Result<(), Box<dyn std::error::Error>> {
  function test_op_trivial_encrypt (line 677) | async fn test_op_trivial_encrypt() -> Result<(), Box<dyn std::error::Err...

FILE: coprocessor/fhevm-engine/tfhe-worker/src/tests/random.rs
  constant RANDOM_SUPPORTED_TYPES_CPU (line 12) | const RANDOM_SUPPORTED_TYPES_CPU: &[i32] = &[
  constant RANDOM_SUPPORTED_TYPES_GPU (line 27) | const RANDOM_SUPPORTED_TYPES_GPU: &[i32] = &[
  function random_test_supported_types (line 39) | fn random_test_supported_types() -> &'static [i32] {
  function test_fhe_random_basic (line 49) | async fn test_fhe_random_basic() -> Result<(), Box<dyn std::error::Error...
  function test_fhe_random_bounded (line 152) | async fn test_fhe_random_bounded() -> Result<(), Box<dyn std::error::Err...

FILE: coprocessor/fhevm-engine/tfhe-worker/src/tests/scheduling_bench.rs
  function sample_count (line 9) | fn sample_count(default_count: usize) -> usize {
  function schedule_erc20_whitepaper (line 18) | async fn schedule_erc20_whitepaper() -> Result<(), Box<dyn std::error::E...
  function schedule_erc20_no_cmux (line 144) | async fn schedule_erc20_no_cmux() -> Result<(), Box<dyn std::error::Erro...
  function schedule_dependent_erc20_no_cmux (line 269) | async fn schedule_dependent_erc20_no_cmux() -> Result<(), Box<dyn std::e...
  function counter_increment (line 399) | async fn counter_increment() -> Result<(), Box<dyn std::error::Error>> {
  function tree_reduction (line 444) | async fn tree_reduction() -> Result<(), Box<dyn std::error::Error>> {

FILE: coprocessor/fhevm-engine/tfhe-worker/src/tests/test_cases.rs
  type BinaryOperatorTestCase (line 9) | pub struct BinaryOperatorTestCase {
  type UnaryOperatorTestCase (line 20) | pub struct UnaryOperatorTestCase {
  function supported_bits (line 28) | fn supported_bits() -> &'static [i32] {
  function supported_bits_to_bit_type_in_db (line 32) | fn supported_bits_to_bit_type_in_db(inp: i32) -> i32 {
  function generate_binary_test_cases (line 50) | pub fn generate_binary_test_cases() -> Vec<BinaryOperatorTestCase> {
  function generate_unary_test_cases (line 146) | pub fn generate_unary_test_cases() -> Vec<UnaryOperatorTestCase> {
  function compute_expected_unary_output (line 185) | fn compute_expected_unary_output(inp: &BigInt, op: SupportedFheOperation...
  function compute_expected_binary_output (line 206) | fn compute_expected_binary_output(

FILE: coprocessor/fhevm-engine/tfhe-worker/src/tests/utils.rs
  type TestInstance (line 13) | pub struct TestInstance {
    method db_url (line 32) | pub fn db_url(&self) -> &str {
    method db_docker_id (line 36) | pub fn db_docker_id(&self) -> Option<String> {
    method health_check_url (line 40) | pub fn health_check_url(&self) -> String {
  method drop (line 23) | fn drop(&mut self) {
  function default_dependence_cache_size (line 45) | pub fn default_dependence_cache_size() -> u16 {
  function setup_test_app (line 49) | pub async fn setup_test_app() -> Result<TestInstance, Box<dyn std::error...
  constant LOCAL_DB_URL (line 57) | const LOCAL_DB_URL: &str = "postgresql://postgres:postgres@127.0.0.1:543...
  function setup_test_app_existing_db (line 59) | async fn setup_test_app_existing_db() -> Result<TestInstance, Box<dyn st...
  function start_coprocessor (line 70) | async fn start_coprocessor(rx: Receiver<bool>, db_url: &str) -> u16 {
  function setup_test_app_custom_docker (line 108) | async fn setup_test_app_custom_docker() -> Result<TestInstance, Box<dyn ...
  function wait_until_all_allowed_handles_computed (line 153) | pub async fn wait_until_all_allowed_handles_computed(
  type DecryptionResult (line 180) | pub struct DecryptionResult {
  function latest_db_key (line 185) | pub async fn latest_db_key(pool: &sqlx::PgPool) -> (DbKey, Crs) {
  function decrypt_ciphertexts (line 197) | pub async fn decrypt_ciphertexts(

FILE: coprocessor/fhevm-engine/tfhe-worker/src/tfhe_worker.rs
  constant EVENT_CIPHERTEXT_COMPUTED (line 22) | const EVENT_CIPHERTEXT_COMPUTED: &str = "event_ciphertext_computed";
  function run_tfhe_worker (line 64) | pub async fn run_tfhe_worker(
  function tfhe_worker_cycle (line 82) | async fn tfhe_worker_cycle(
  function query_ciphertexts (line 244) | async fn query_ciphertexts<'a>(
  function query_for_work (line 276) | async fn query_for_work<'a>(
  function build_transaction_graph_and_execute (line 449) | async fn build_transaction_graph_and_execute<'a>(
  function upload_transaction_graph_results (line 529) | async fn upload_transaction_graph_results<'a>(
  function set_computation_error (line 667) | async fn set_computation_error<'a>(

FILE: coprocessor/fhevm-engine/tfhe-worker/src/types.rs
  type CoprocessorError (line 5) | pub enum CoprocessorError {
    method fmt (line 13) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
    method from (line 34) | fn from(err: sqlx::Error) -> Self {
    method from (line 40) | fn from(err: SchedulerError) -> Self {

FILE: coprocessor/fhevm-engine/transaction-sender/build.rs
  function main (line 10) | fn main() {

FILE: coprocessor/fhevm-engine/transaction-sender/src/bin/transaction_sender.rs
  type SignerType (line 33) | enum SignerType {
  type Conf (line 40) | struct Conf {
  function install_signal_handlers (line 162) | fn install_signal_handlers(cancel_token: CancellationToken) -> anyhow::R...
  function parse_args (line 176) | fn parse_args() -> Conf {
  type Provider (line 184) | type Provider = FillProvider<
  function get_provider (line 192) | async fn get_provider(
  function main (line 241) | async fn main() -> anyhow::Result<()> {

FILE: coprocessor/fhevm-engine/transaction-sender/src/config.rs
  constant DEFAULT_GAS_LIMIT_OVERPROVISION_PERCENT (line 3) | pub const DEFAULT_GAS_LIMIT_OVERPROVISION_PERCENT: u32 = 120;
  type ConfigSettings (line 6) | pub struct ConfigSettings {
  method default (line 44) | fn default() -> Self {

FILE: coprocessor/fhevm-engine/transaction-sender/src/http_server.rs
  type HealthResponse (line 20) | struct HealthResponse {
    method from (line 29) | fn from(status: HealthStatus) -> Self {
  type HttpServer (line 44) | pub struct HttpServer<P>
  function new (line 57) | pub fn new(
  function start (line 69) | pub async fn start(&self) -> anyhow::Result<()> {
  function health_handler (line 98) | async fn health_handler<P: Provider<Ethereum> + Clone + 'static>(
  function liveness_handler (line 112) | async fn liveness_handler<P: Provider<Ethereum> + Clone + 'static>(

FILE: coprocessor/fhevm-engine/transaction-sender/src/lib.rs
  constant REVIEW (line 27) | pub const REVIEW: &str = "review";
  type CombinedSigner (line 30) | pub trait CombinedSigner: TxSigner<Signature> + Signer<Signature> {}
  type AbstractSigner (line 34) | pub type AbstractSigner = Arc<dyn CombinedSigner + Send + Sync>;
  function make_abstract_signer (line 36) | pub fn make_abstract_signer<S>(signer: S) -> AbstractSigner
  type HealthStatus (line 45) | pub struct HealthStatus {
    method healthy (line 57) | pub fn healthy() -> Self {
    method unhealthy (line 66) | pub fn unhealthy(
  function get_chain_id (line 82) | pub async fn get_chain_id(ws_url: Url, retry_interval: Duration) -> u64 {
  function is_backend_gone (line 123) | pub fn is_backend_gone(err: &Error) -> bool {

FILE: coprocessor/fhevm-engine/transaction-sender/src/metrics.rs
  function spawn_gauge_update_routine (line 73) | pub fn spawn_gauge_update_routine(period: std::time::Duration, db_pool: ...

FILE: coprocessor/fhevm-engine/transaction-sender/src/nonce_managed_provider.rs
  type FillersWithoutNonceManagement (line 20) | pub type FillersWithoutNonceManagement =
  type NonceManagedProvider (line 27) | pub struct NonceManagedProvider<P>
  function new (line 40) | pub fn new(provider: P, signer_address: Option<Address>) -> Self {
  function send_transaction (line 48) | pub async fn send_transaction(
  function send_transaction_sync (line 68) | pub async fn send_transaction_sync(
  function overprovision_gas_limit (line 95) | pub async fn overprovision_gas_limit(
  function send_sync_with_overprovision (line 134) | pub async fn send_sync_with_overprovision(
  function get_chain_id (line 145) | pub async fn get_chain_id(&self) -> TransportResult<u64> {
  function get_transaction_count (line 149) | pub async fn get_transaction_count(&self, address: Address) -> Transport...
  function get_block_number (line 153) | pub async fn get_block_number(&self) -> TransportResult<u64> {
  function inner (line 157) | pub fn inner(&self) -> &P {

FILE: coprocessor/fhevm-engine/transaction-sender/src/ops/add_ciphertext.rs
  type AddCiphertextOperation (line 29) | pub struct AddCiphertextOperation<P>
  function send_transaction (line 45) | async fn send_transaction(
  function already_added_error (line 173) | fn already_added_error(&self, err: &RpcError<TransportErrorKind>) -> Opt...
  function set_txn_is_sent (line 182) | async fn set_txn_is_sent(
  function new (line 222) | pub fn new(
  function increment_txn_limited_retries_count (line 244) | async fn increment_txn_limited_retries_count(
  function increment_txn_unlimited_retries_count (line 280) | async fn increment_txn_unlimited_retries_count(
  function stop_retrying_add_ciphertext_on_config_error (line 317) | async fn stop_retrying_add_ciphertext_on_config_error(
  function channel (line 344) | fn channel(&self) -> &str {
  function execute (line 348) | async fn execute(&self) -> anyhow::Result<bool> {
  function delete_ct128_from_db (line 463) | async fn delete_ct128_from_db(

FILE: coprocessor/fhevm-engine/transaction-sender/src/ops/common.rs
  function try_into_array (line 10) | pub(crate) fn try_into_array<const SIZE: usize>(vec: Vec<u8>) -> Result<...
  type CoprocessorConfigError (line 37) | pub(crate) enum CoprocessorConfigError {
  function try_extract_non_retryable_config_error (line 57) | pub(crate) fn try_extract_non_retryable_config_error(

FILE: coprocessor/fhevm-engine/transaction-sender/src/ops/mod.rs
  type TransactionOperation (line 5) | pub trait TransactionOperation<P>: Send + Sync
    method channel (line 9) | fn channel(&self) -> &str;
    method execute (line 11) | async fn execute(&self) -> anyhow::Result<bool>;

FILE: coprocessor/fhevm-engine/transaction-sender/src/ops/verify_proof.rs
  type VerifyProofOperation (line 34) | pub(crate) struct VerifyProofOperation<P>
  function new (line 51) | pub(crate) async fn new(
  function remove_proof_by_id (line 71) | async fn remove_proof_by_id(&self, zk_proof_id: i64) -> anyhow::Result<(...
  function update_retry_count_by_proof_id (line 82) | async fn update_retry_count_by_proof_id(
  function remove_proofs_by_retry_count (line 107) | async fn remove_proofs_by_retry_count(&self) -> anyhow::Result<()> {
  function process_proof (line 122) | async fn process_proof(
  function stop_retrying_verify_proof_on_config_error (line 239) | async fn stop_retrying_verify_proof_on_config_error(
  function channel (line 267) | fn channel(&self) -> &str {
  function execute (line 271) | async fn execute(&self) -> anyhow::Result<bool> {

FILE: coprocessor/fhevm-engine/transaction-sender/src/transaction_sender.rs
  type TransactionSender (line 15) | pub struct TransactionSender<P>
  function new (line 33) | pub async fn new(
  function run (line 74) | pub async fn run(&self) -> anyhow::Result<()> {
  function reset_sleep_duration (line 213) | fn reset_sleep_duration(&self, sleep_duration: &mut u64) {
  function sleep_with_backoff (line 217) | async fn sleep_with_backoff(&self, sleep_duration: &mut u64) {
  function health_check (line 223) | pub async fn health_check(&self) -> HealthStatus {

FILE: coprocessor/fhevm-engine/transaction-sender/tests/add_ciphertext_tests.rs
  function add_ciphertext_digests (line 25) | async fn add_ciphertext_digests(#[case] signer_type: SignerType) -> anyh...
  function ciphertext_digest_already_added (line 123) | async fn ciphertext_digest_already_added(#[case] signer_type: SignerType...
  function recover_from_transport_error (line 217) | async fn recover_from_transport_error(#[case] signer_type: SignerType) -...
  function stop_on_backend_gone (line 304) | async fn stop_on_backend_gone(#[case] signer_type: SignerType) -> anyhow...
  function retry_mechanism (line 411) | async fn retry_mechanism(#[case] signer_type: SignerType) -> anyhow::Res...
  function retry_on_aws_kms_error (line 512) | async fn retry_on_aws_kms_error(#[case] signer_type: SignerType) -> anyh...
  function stop_retrying_add_ciphertext_on_gw_config_error (line 606) | async fn stop_retrying_add_ciphertext_on_gw_config_error(

FILE: coprocessor/fhevm-engine/transaction-sender/tests/common.rs
  type SignerType (line 36) | pub enum SignerType {
  function is_coprocessor_config_error (line 41) | pub fn is_coprocessor_config_error(err: &str) -> bool {
  type TestEnvironment (line 47) | pub struct TestEnvironment {
    method new (line 61) | pub async fn new(signer_type: SignerType) -> anyhow::Result<Self> {
    method new_with_config (line 71) | pub async fn new_with_config(
    method ws_endpoint_url (line 148) | pub fn ws_endpoint_url(&self) -> Url {
    method recreate_anvil (line 152) | pub fn recreate_anvil(&mut self) -> anyhow::Result<()> {
    method drop_anvil (line 161) | pub fn drop_anvil(&mut self) {
    method stop_localstack (line 167) | pub async fn stop_localstack(&mut self) {
    method new_anvil (line 173) | fn new_anvil() -> anyhow::Result<AnvilInstance> {
    method new_anvil_with_port (line 177) | fn new_anvil_with_port(port: u16) -> anyhow::Result<AnvilInstance> {
    method truncate_tables (line 181) | async fn truncate_tables(db_pool: &sqlx::PgPool, tables: Vec<&str>) ->...

FILE: coprocessor/fhevm-engine/transaction-sender/tests/overprovision_gas_limit_tests.rs
  function overprovision_gas_limit (line 17) | async fn overprovision_gas_limit(#[case] signer_type: SignerType) -> any...
  function overprovision_estimate_failure (line 66) | async fn overprovision_estimate_failure(#[case] signer_type: SignerType)...

FILE: coprocessor/fhevm-engine/transaction-sender/tests/verify_proof_tests.rs
  function verify_proof_response_success (line 36) | async fn verify_proof_response_success(#[case] signer_type: SignerType) ...
  function verify_proof_response_empty_handles_success (line 150) | async fn verify_proof_response_empty_handles_success(
  function verify_proof_response_concurrent_success (line 269) | async fn verify_proof_response_concurrent_success(
  function reject_proof_response_success (line 388) | async fn reject_proof_response_success(#[case] signer_type: SignerType) ...
  function verify_proof_response_reversal_already_verified (line 496) | async fn verify_proof_response_reversal_already_verified(
  function reject_proof_response_reversal_already_rejected (line 598) | async fn reject_proof_response_reversal_already_rejected(
  function verify_proof_response_other_reversal (line 699) | async fn verify_proof_response_other_reversal(
  function reject_proof_response_other_reversal (line 798) | async fn reject_proof_response_other_reversal(
  function verify_proof_response_other_reversal_gas_estimation (line 893) | async fn verify_proof_response_other_reversal_gas_estimation(
  function reject_proof_response_other_reversal_gas_estimation (line 991) | async fn reject_proof_response_other_reversal_gas_estimation(
  function verify_proof_max_retries_remove_entry (line 1089) | async fn verify_proof_max_retries_remove_entry(
  function verify_proof_max_retries_do_not_remove_entry (line 1179) | async fn verify_proof_max_retries_do_not_remove_entry(
  function stop_retrying_verify_proof_on_gw_config_error (line 1281) | async fn stop_retrying_verify_proof_on_gw_config_error(

FILE: coprocessor/fhevm-engine/zkproof-worker/src/auxiliary.rs
  constant SIZE (line 4) | const SIZE: usize = 92;
  type ZkData (line 8) | pub(crate) struct ZkData {
    method assemble (line 21) | pub fn assemble(&self) -> anyhow::Result<[u8; SIZE]> {
  function test_assemble_valid_addresses (line 46) | fn test_assemble_valid_addresses() {

FILE: coprocessor/fhevm-engine/zkproof-worker/src/bin/zkproof_worker.rs
  type Args (line 15) | pub struct Args {
  function parse_args (line 74) | pub fn parse_args() -> Args {
  function main (line 82) | async fn main() {

FILE: coprocessor/fhevm-engine/zkproof-worker/src/lib.rs
  constant MAX_INPUT_INDEX (line 25) | pub const MAX_INPUT_INDEX: u8 = u8::MAX - 1;
  type ExecutionError (line 28) | pub enum ExecutionError {
  method from (line 76) | fn from(err: ExecutionError) -> Self {
  type Config (line 87) | pub struct Config {
  method fmt (line 108) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {

FILE: coprocessor/fhevm-engine/zkproof-worker/src/tests/mod.rs
  function test_verify_proof (line 11) | async fn test_verify_proof() {
  function test_verify_empty_input_list (line 46) | async fn test_verify_empty_input_list() {
  function test_max_input_index (line 75) | async fn test_max_input_index() {
  function test_verify_proof_rerandomises_ciphertexts_before_storage (line 132) | async fn test_verify_proof_rerandomises_ciphertexts_before_storage() {

FILE: coprocessor/fhevm-engine/zkproof-worker/src/tests/utils.rs
  function setup (line 19) | pub async fn setup() -> anyhow::Result<(PostgresPoolManager, DBInstance)> {
  function is_valid (line 68) | pub(crate) async fn is_valid(
  type StoredCiphertext (line 92) | pub(crate) struct StoredCiphertext {
  type DecryptionResult (line 100) | pub(crate) struct DecryptionResult {
  function wait_for_handles (line 105) | pub(crate) async fn wait_for_handles(
  function fetch_stored_ciphertexts (line 132) | pub(crate) async fn fetch_stored_ciphertexts(
  function decrypt_ciphertexts (line 166) | pub(crate) async fn decrypt_ciphertexts(
  function compress_inputs_without_rerandomization (line 197) | pub(crate) async fn compress_inputs_without_rerandomization(
  type ZkInput (line 233) | pub(crate) enum ZkInput {
    method cleartext (line 242) | pub(crate) fn cleartext(&self) -> String {
  function generate_zk_pok_with_inputs (line 253) | pub(crate) async fn generate_zk_pok_with_inputs(
  function generate_sample_zk_pok (line 287) | pub(crate) async fn generate_sample_zk_pok(pool: &sqlx::PgPool, aux_data...
  function generate_empty_input_list (line 298) | pub(crate) async fn generate_empty_input_list(pool: &sqlx::PgPool, aux_d...
  function insert_proof (line 303) | pub(crate) async fn insert_proof(
  function aux_fixture (line 331) | pub(crate) fn aux_fixture(acl_contract_address: String) -> (ZkData, [u8;...

FILE: coprocessor/fhevm-engine/zkproof-worker/src/verifier.rs
  constant MAX_CACHED_KEYS (line 37) | pub const MAX_CACHED_KEYS: usize = 100;
  constant EVENT_CIPHERTEXT_COMPUTED (line 38) | const EVENT_CIPHERTEXT_COMPUTED: &str = "event_ciphertext_computed";
  constant RAW_CT_HASH_DOMAIN_SEPARATOR (line 40) | const RAW_CT_HASH_DOMAIN_SEPARATOR: [u8; 8] = *b"ZK-w_rct";
  constant HANDLE_HASH_DOMAIN_SEPARATOR (line 41) | const HANDLE_HASH_DOMAIN_SEPARATOR: [u8; 8] = *b"ZK-w_hdl";
  constant RERANDOMISATION_DOMAIN_SEPARATOR (line 42) | const RERANDOMISATION_DOMAIN_SEPARATOR: [u8; 8] = *b"ZKw_Rrnd";
  constant COMPACT_PUBLIC_ENCRYPTION_DOMAIN_SEPARATOR (line 43) | const COMPACT_PUBLIC_ENCRYPTION_DOMAIN_SEPARATOR: [u8; 8] = *b"TFHE_Enc";
  type Ciphertext (line 45) | pub(crate) struct Ciphertext {
  type ZkProofService (line 52) | pub struct ZkProofService {
    method create (line 89) | pub async fn create(conf: Config, token: CancellationToken) -> Option<...
    method run (line 115) | pub async fn run(&self) -> Result<(), ExecutionError> {
  method health_check (line 60) | async fn health_check(&self) -> HealthStatus {
  method is_alive (line 66) | async fn is_alive(&self) -> bool {
  method get_version (line 77) | fn get_version(&self) -> Version {
  function execute_verify_proofs_loop (line 126) | pub async fn execute_verify_proofs_loop(
  function execute_worker (line 187) | async fn execute_worker(
  function execute_verify_proof_routine (line 258) | async fn execute_verify_proof_routine(
  function verify_proof (line 404) | pub(crate) fn verify_proof(
  function verify_proof_only (line 451) | fn verify_proof_only(
  function expand_verified_list (line 504) | fn expand_verified_list(
  function set_ciphertext_metadata (line 526) | fn set_ciphertext_metadata(
  function re_randomise_ciphertexts (line 560) | fn re_randomise_ciphertexts(
  function finalize_ciphertext (line 589) | fn finalize_ciphertext(
  function get_remaining_tasks (line 626) | async fn get_remaining_tasks(pool: &PgPool) -> Result<i64, ExecutionErro...
  function insert_ciphertexts (line 647) | pub(crate) async fn insert_ciphertexts(
  function update_last_active (line 683) | async fn update_last_active(last_active_at: Arc<RwLock<SystemTime>>) {

FILE: gateway-contracts/hardhat.config.ts
  constant NUM_ACCOUNTS (line 29) | const NUM_ACCOUNTS = 30;
  constant ADDRESSES_DIR (line 32) | const ADDRESSES_DIR = resolve(__dirname, "addresses");
  constant GATEWAY_ADDRESSES_ENV_FILE_NAME (line 33) | const GATEWAY_ADDRESSES_ENV_FILE_NAME = ".env.gateway";
  constant GATEWAY_ADDRESSES_SOLIDITY_FILE_NAME (line 34) | const GATEWAY_ADDRESSES_SOLIDITY_FILE_NAME = "GatewayAddresses.sol";

FILE: gateway-contracts/rust_bindings/src/address.rs
  type AddressEmptyCode (line 64) | pub struct AddressEmptyCode {
  constant _ (line 74) | const _: () = {
  type AddressErrors (line 139) | pub enum AddressErrors {
    constant SELECTORS (line 151) | pub const SELECTORS: &'static [[u8; 4usize]] = &[[153u8, 150u8, 179u8,...
    constant NAME (line 155) | const NAME: &'static str = "AddressErrors";
    constant MIN_DATA_LENGTH (line 156) | const MIN_DATA_LENGTH: usize = 32usize;
    constant COUNT (line 157) | const COUNT: usize = 1usize;
    method selector (line 159) | fn selector(&self) -> [u8; 4] {
    method selector_at (line 167) | fn selector_at(i: usize) -> ::core::option::Option<[u8; 4]> {
    method valid_selector (line 171) | fn valid_selector(selector: [u8; 4]) -> bool {
    method abi_decode_raw (line 176) | fn abi_decode_raw(
    method abi_decode_raw_validate (line 207) | fn abi_decode_raw_validate(
    method abi_encoded_size (line 237) | fn abi_encoded_size(&self) -> usize {
    method abi_encode_raw (line 247) | fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
  function new (line 263) | pub const fn new<
  function deploy (line 275) | pub fn deploy<
  function deploy_builder (line 291) | pub fn deploy_builder<
  type AddressInstance (line 309) | pub struct AddressInstance<P, N = alloy_contract::private::Ethereum> {
  function fmt (line 317) | fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
  function new (line 331) | pub const fn new(
  function deploy (line 347) | pub async fn deploy(
  function deploy_builder (line 360) | pub fn deploy_builder(provider: P) -> alloy_contract::RawCallBuilder<P, ...
  function address (line 368) | pub const fn address(&self) -> &alloy_sol_types::private::Address {
  function set_address (line 373) | pub fn set_address(&mut self, address: alloy_sol_types::private::Address) {
  function at (line 377) | pub fn at(mut self, address: alloy_sol_types::private::Address) -> Self {
  function provider (line 383) | pub const fn provider(&self) -> &P {
  function with_cloned_provider (line 390) | pub fn with_cloned_provider(self) -> AddressInstance<P, N> {
  function call_builder (line 408) | pub fn call_builder<C: alloy_sol_types::SolCall>(
  function event_filter (line 425) | pub fn event_filter<E: alloy_sol_types::SolEvent>(

FILE: gateway-contracts/rust_bindings/src/ciphertext_commits.rs
  type CiphertextMaterial (line 644) | pub struct CiphertextMaterial {
  constant _ (line 662) | const _: () = {
  type SnsCiphertextMaterial (line 929) | pub struct SnsCiphertextMaterial {
  constant _ (line 947) | const _: () = {
  type AddressEmptyCode (line 1215) | pub struct AddressEmptyCode {
  constant _ (line 1225) | const _: () = {
  type CiphertextMaterialNotFound (line 1295) | pub struct CiphertextMaterialNotFound {
  constant _ (line 1305) | const _: () = {
  type CoprocessorAlreadyAdded (line 1377) | pub struct CoprocessorAlreadyAdded {
  constant _ (line 1389) | const _: () = {
  type CoprocessorSignerDoesNotMatchTxSender (line 1471) | pub struct CoprocessorSignerDoesNotMatchTxSender {
  constant _ (line 1483) | const _: () = {
  type ERC1967InvalidImplementation (line 1567) | pub struct ERC1967InvalidImplementation {
  constant _ (line 1577) | const _: () = {
  type ERC1967NonPayable (line 1649) | pub struct ERC1967NonPayable;
  constant _ (line 1656) | const _: () = {
  type EmptyCtHandles (line 1722) | pub struct EmptyCtHandles;
  constant _ (line 1729) | const _: () = {
  type FailedCall (line 1795) | pub struct FailedCall;
  constant _ (line 1802) | const _: () = {
  type HostChainNotRegistered (line 1868) | pub struct HostChainNotRegistered {
  constant _ (line 1878) | const _: () = {
  type InvalidInitialization (line 1950) | pub struct InvalidInitialization;
  constant _ (line 1957) | const _: () = {
  type KmsSignerDoesNotMatchTxSender (line 2023) | pub struct KmsSignerDoesNotMatchTxSender {
  constant _ (line 2035) | const _: () = {
  type NotCoprocessorSigner (line 2119) | pub struct NotCoprocessorSigner {
  constant _ (line 2129) | const _: () = {
  type NotCoprocessorTxSender (line 2199) | pub struct NotCoprocessorTxSender {
  constant _ (line 2209) | const _: () = {
  type NotCustodianSigner (line 2279) | pub struct NotCustodianSigner {
  constant _ (line 2289) | const _: () = {
  type NotCustodianTxSender (line 2359) | pub struct NotCustodianTxSender {
  constant _ (line 2369) | const _: () = {
  type NotGatewayOwner (line 2439) | pub struct NotGatewayOwner {
  constant _ (line 2449) | const _: () = {
  type NotInitializing (line 2519) | pub struct NotInitializing;
  constant _ (line 2526) | const _: () = {
  type NotInitializingFromEmptyProxy (line 2592) | pub struct NotInitializingFromEmptyProxy;
  constant _ (line 2599) | const _: () = {
  type NotKmsSigner (line 2667) | pub struct NotKmsSigner {
  constant _ (line 2677) | const _: () = {
  type NotKmsTxSender (line 2747) | pub struct NotKmsTxSender {
  constant _ (line 2757) | const _: () = {
  type UUPSUnauthorizedCallContext (line 2827) | pub struct UUPSUnauthorizedCallContext;
  constant _ (line 2834) | const _: () = {
  type UUPSUnsupportedProxiableUUID (line 2902) | pub struct UUPSUnsupportedProxiableUUID {
  constant _ (line 2912) | const _: () = {
  type AddCiphertextMaterial (line 2989) | pub struct AddCiphertextMaterial {
  constant _ (line 3007) | const _: () = {
  type AddCiphertextMaterialConsensus (line 3128) | pub struct AddCiphertextMaterialConsensus {
  constant _ (line 3148) | const _: () = {
  type Initialized (line 3272) | pub struct Initialized {
  constant _ (line 3282) | const _: () = {
  type Upgraded (line 3377) | pub struct Upgraded {
  constant _ (line 3387) | const _: () = {
  type constructorCall (line 3477) | pub struct constructorCall {}
  constant _ (line 3478) | const _: () = {
  type UPGRADE_INTERFACE_VERSIONCall (line 3537) | pub struct UPGRADE_INTERFACE_VERSIONCall;
  type UPGRADE_INTERFACE_VERSIONReturn (line 3543) | pub struct UPGRADE_INTERFACE_VERSIONReturn {
  constant _ (line 3553) | const _: () = {
  type addCiphertextMaterialCall (line 3684) | pub struct addCiphertextMaterialCall {
  type addCiphertextMaterialReturn (line 3697) | pub struct addCiphertextMaterialReturn {}
  constant _ (line 3704) | const _: () = {
  type getAddCiphertextMaterialConsensusTxSendersCall (line 3872) | pub struct getAddCiphertextMaterialConsensusTxSendersCall {
  type getAddCiphertextMaterialConsensusTxSendersReturn (line 3881) | pub struct getAddCiphertextMaterialConsensusTxSendersReturn {
  constant _ (line 3891) | const _: () = {
  type getCiphertextMaterialsCall (line 4039) | pub struct getCiphertextMaterialsCall {
  type getCiphertextMaterialsReturn (line 4050) | pub struct getCiphertextMaterialsReturn {
  constant _ (line 4062) | const _: () = {
  type getSnsCiphertextMaterialsCall (line 4219) | pub struct getSnsCiphertextMaterialsCall {
  type getSnsCiphertextMaterialsReturn (line 4230) | pub struct getSnsCiphertextMaterialsReturn {
  constant _ (line 4242) | const _: () = {
  type getVersionCall (line 4399) | pub struct getVersionCall;
  type getVersionReturn (line 4405) | pub struct getVersionReturn {
  constant _ (line 4415) | const _: () = {
  type initializeFromEmptyProxyCall (line 4542) | pub struct initializeFromEmptyProxyCall;
  type initializeFromEmptyProxyReturn (line 4546) | pub struct initializeFromEmptyProxyReturn {}
  constant _ (line 4553) | const _: () = {
  type isCiphertextMaterialAddedCall (line 4683) | pub struct isCiphertextMaterialAddedCall {
  type isCiphertextMaterialAddedReturn (line 4692) | pub struct isCiphertextMaterialAddedReturn {
  constant _ (line 4702) | const _: () = {
  type proxiableUUIDCall (line 4837) | pub struct proxiableUUIDCall;
  type proxiableUUIDReturn (line 4843) | pub struct proxiableUUIDReturn {
  constant _ (line 4853) | const _: () = {
  type reinitializeV3Call (line 4980) | pub struct reinitializeV3Call;
  type reinitializeV3Return (line 4984) | pub struct reinitializeV3Return {}
  constant _ (line 4991) | const _: () = {
  type upgradeToAndCallCall (line 5117) | pub struct upgradeToAndCallCall {
  type upgradeToAndCallReturn (line 5126) | pub struct upgradeToAndCallReturn {}
  constant _ (line 5133) | const _: () = {
  type CiphertextCommitsCalls (line 5275) | pub enum CiphertextCommitsCalls {
    constant SELECTORS (line 5309) | pub const SELECTORS: &'static [[u8; 4usize]] = &[
    constant NAME (line 5325) | const NAME: &'static str = "CiphertextCommitsCalls";
    constant MIN_DATA_LENGTH (line 5326) | const MIN_DATA_LENGTH: usize = 0usize;
    constant COUNT (line 5327) | const COUNT: usize = 11usize;
    method selector (line 5329) | fn selector(&self) -> [u8; 4] {
    method selector_at (line 5367) | fn selector_at(i: usize) -> ::core::option::Option<[u8; 4]> {
    method valid_selector (line 5371) | fn valid_selector(selector: [u8; 4]) -> bool {
    method abi_decode_raw (line 5376) | fn abi_decode_raw(
    method abi_decode_raw_validate (line 5519) | fn abi_decode_raw_validate(
    method abi_encoded_size (line 5661) | fn abi_encoded_size(&self) -> usize {
    method abi_encode_raw (line 5719) | fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
  type CiphertextCommitsErrors (line 5793) | pub enum CiphertextCommitsErrors {
    constant SELECTORS (line 5847) | pub const SELECTORS: &'static [[u8; 4usize]] = &[
    constant NAME (line 5874) | const NAME: &'static str = "CiphertextCommitsErrors";
    constant MIN_DATA_LENGTH (line 5875) | const MIN_DATA_LENGTH: usize = 0usize;
    constant COUNT (line 5876) | const COUNT: usize = 22usize;
    method selector (line 5878) | fn selector(&self) -> [u8; 4] {
    method selector_at (line 5949) | fn selector_at(i: usize) -> ::core::option::Option<[u8; 4]> {
    method valid_selector (line 5953) | fn valid_selector(selector: [u8; 4]) -> bool {
    method abi_decode_raw (line 5958) | fn abi_decode_raw(
    method abi_decode_raw_validate (line 6218) | fn abi_decode_raw_validate(
    method abi_encoded_size (line 6481) | fn abi_encoded_size(&self) -> usize {
    method abi_encode_raw (line 6592) | fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
  type CiphertextCommitsEvents (line 6729) | pub enum CiphertextCommitsEvents {
    constant SELECTORS (line 6747) | pub const SELECTORS: &'static [[u8; 32usize]] = &[
    constant NAME (line 6772) | const NAME: &'static str = "CiphertextCommitsEvents";
    constant COUNT (line 6773) | const COUNT: usize = 4usize;
    method decode_raw_log (line 6774) | fn decode_raw_log(
    method to_log_data (line 6824) | fn to_log_data(&self) -> alloy_sol_types::private::LogData {
    method into_log_data (line 6840) | fn into_log_data(self) -> alloy_sol_types::private::LogData {
  function new (line 6862) | pub const fn new<
  function deploy (line 6877) | pub fn deploy<
  function deploy_builder (line 6893) | pub fn deploy_builder<
  type CiphertextCommitsInstance (line 6911) | pub struct CiphertextCommitsInstance<P, N = alloy_contract::private::Eth...
  function fmt (line 6919) | fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
  function new (line 6933) | pub const fn new(
  function deploy (line 6949) | pub async fn deploy(
  function deploy_builder (line 6962) | pub fn deploy_builder(provider: P) -> alloy_contract::RawCallBuilder<P, ...
  function address (line 6970) | pub const fn address(&self) -> &alloy_sol_types::private::Address {
  function set_address (line 6975) | pub fn set_address(&mut self, address: alloy_sol_types::private::Address) {
  function at (line 6979) | pub fn at(mut self, address: alloy_sol_types::private::Address) -> Self {
  function provider (line 6985) | pub const fn provider(&self) -> &P {
  function with_cloned_provider (line 6992) | pub fn with_cloned_provider(self) -> CiphertextCommitsInstance<P, N> {
  function call_builder (line 7010) | pub fn call_builder<C: alloy_sol_types::SolCall>(
  function UPGRADE_INTERFACE_VERSION (line 7017) | pub fn UPGRADE_INTERFACE_VERSION(
  function addCiphertextMaterial (line 7023) | pub fn addCiphertextMaterial(
  function getAddCiphertextMaterialConsensusTxSenders (line 7040) | pub fn getAddCiphertextMaterialConsensusTxSenders(
  function getCiphertextMaterials (line 7055) | pub fn getCiphertextMaterials(
  function getSnsCiphertextMaterials (line 7068) | pub fn getSnsCiphertextMaterials(
  function getVersion (line 7081) | pub fn getVersion(
  function initializeFromEmptyProxy (line 7087) | pub fn initializeFromEmptyProxy(
  function isCiphertextMaterialAdded (line 7093) | pub fn isCiphertextMaterialAdded(
  function proxiableUUID (line 7104) | pub fn proxiableUUID(
  function reinitializeV3 (line 7110) | pub fn reinitializeV3(
  function upgradeToAndCall (line 7116) | pub fn upgradeToAndCall(
  function event_filter (line 7139) | pub fn event_filter<E: alloy_sol_types::SolEvent>(
  function AddCiphertextMaterial_filter (line 7145) | pub fn AddCiphertextMaterial_filter(
  function AddCiphertextMaterialConsensus_filter (line 7151) | pub fn AddCiphertextMaterialConsensus_filter(
  function Initialized_filter (line 7157) | pub fn Initialized_filter(&self) -> alloy_contract::Event<&P, Initialize...
  function Upgraded_filter (line 7161) | pub fn Upgraded_filter(&self) -> alloy_contract::Event<&P, Upgraded, N> {

FILE: gateway-contracts/rust_bindings/src/context.rs
  function new (line 47) | pub const fn new<
  function deploy (line 59) | pub fn deploy<
  function deploy_builder (line 75) | pub fn deploy_builder<
  type ContextInstance (line 93) | pub struct ContextInstance<P, N = alloy_contract::private::Ethereum> {
  function fmt (line 101) | fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
  function new (line 115) | pub const fn new(
  function deploy (line 131) | pub async fn deploy(
  function deploy_builder (line 144) | pub fn deploy_builder(provider: P) -> alloy_contract::RawCallBuilder<P, ...
  function address (line 152) | pub const fn address(&self) -> &alloy_sol_types::private::Address {
  function set_address (line 157) | pub fn set_address(&mut self, address: alloy_sol_types::private::Address) {
  function at (line 161) | pub fn at(mut self, address: alloy_sol_types::private::Address) -> Self {
  function provider (line 167) | pub const fn provider(&self) -> &P {
  function with_cloned_provider (line 174) | pub fn with_cloned_provider(self) -> ContextInstance<P, N> {
  function call_builder (line 192) | pub fn call_builder<C: alloy_sol_types::SolCall>(
  function event_filter (line 209) | pub fn event_filter<E: alloy_sol_types::SolEvent>(

FILE: gateway-contracts/rust_bindings/src/context_upgradeable.rs
  type InvalidInitialization (line 79) | pub struct InvalidInitialization;
  constant _ (line 86) | const _: () = {
  type NotInitializing (line 152) | pub struct NotInitializing;
  constant _ (line 159) | const _: () = {
  type Initialized (line 230) | pub struct Initialized {
  constant _ (line 240) | const _: () = {
  type ContextUpgradeableErrors (line 325) | pub enum ContextUpgradeableErrors {
    constant SELECTORS (line 339) | pub const SELECTORS: &'static [[u8; 4usize]] = &[
    constant NAME (line 346) | const NAME: &'static str = "ContextUpgradeableErrors";
    constant MIN_DATA_LENGTH (line 347) | const MIN_DATA_LENGTH: usize = 0usize;
    constant COUNT (line 348) | const COUNT: usize = 2usize;
    method selector (line 350) | fn selector(&self) -> [u8; 4] {
    method selector_at (line 361) | fn selector_at(i: usize) -> ::core::option::Option<[u8; 4]> {
    method valid_selector (line 365) | fn valid_selector(selector: [u8; 4]) -> bool {
    method abi_decode_raw (line 370) | fn abi_decode_raw(
    method abi_decode_raw_validate (line 412) | fn abi_decode_raw_validate(
    method abi_encoded_size (line 453) | fn abi_encoded_size(&self) -> usize {
    method abi_encode_raw (line 468) | fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
  type ContextUpgradeableEvents (line 488) | pub enum ContextUpgradeableEvents {
    constant SELECTORS (line 500) | pub const SELECTORS: &'static [[u8; 32usize]] = &[
    constant NAME (line 510) | const NAME: &'static str = "ContextUpgradeableEvents";
    constant COUNT (line 511) | const COUNT: usize = 1usize;
    method decode_raw_log (line 512) | fn decode_raw_log(
    method to_log_data (line 540) | fn to_log_data(&self) -> alloy_sol_types::private::LogData {
    method into_log_data (line 547) | fn into_log_data(self) -> alloy_sol_types::private::LogData {
  function new (line 560) | pub const fn new<
  function deploy (line 575) | pub fn deploy<
  function deploy_builder (line 591) | pub fn deploy_builder<
  type ContextUpgradeableInstance (line 609) | pub struct ContextUpgradeableInstance<P, N = alloy_contract::private::Et...
  function fmt (line 617) | fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
  function new (line 631) | pub const fn new(
  function deploy (line 647) | pub async fn deploy(
  function deploy_builder (line 660) | pub fn deploy_builder(provider: P) -> alloy_contract::RawCallBuilder<P, ...
  function address (line 668) | pub const fn address(&self) -> &alloy_sol_types::private::Address {
  function set_address (line 673) | pub fn set_address(&mut self, address: alloy_sol_types::private::Address) {
  function at (line 677) | pub fn at(mut self, address: alloy_sol_types::private::Address) -> Self {
  function provider (line 683) | pub const fn provider(&self) -> &P {
  function with_cloned_provider (line 690) | pub fn with_cloned_provider(self) -> ContextUpgradeableInstance<P, N> {
  function call_builder (line 708) | pub fn call_builder<C: alloy_sol_types::SolCall>(
  function event_filter (line 725) | pub fn event_filter<E: alloy_sol_types::SolEvent>(
  function Initialized_filter (line 731) | pub fn Initialized_filter(&self) -> alloy_contract::Event<&P, Initialize...

FILE: gateway-contracts/rust_bindings/src/decryption.rs
  type ContractsInfo (line 28) | pub struct ContractsInfo {
  constant _ (line 42) | const _: () = {
  type DelegationAccounts (line 258) | pub struct DelegationAccounts {
  constant _ (line 270) | const _: () = {
  type RequestValidity (line 478) | pub struct RequestValidity {
  constant _ (line 490) | const _: () = {
  function new (line 706) | pub const fn new<
  type IDecryptionInstance (line 727) | pub struct IDecryptionInstance<P, N = alloy_contract::private::Ethereum> {
  function fmt (line 735) | fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
  function new (line 749) | pub const fn new(
  function address (line 761) | pub const fn address(&self) -> &alloy_sol_types::private::Address {
  function set_address (line 766) | pub fn set_address(&mut self, address: alloy_sol_types::private::Address) {
  function at (line 770) | pub fn at(mut self, address: alloy_sol_types::private::Address) -> Self {
  function provider (line 776) | pub const fn provider(&self) -> &P {
  function with_cloned_provider (line 783) | pub fn with_cloned_provider(self) -> IDecryptionInstance<P, N> {
  function call_builder (line 801) | pub fn call_builder<C: alloy_sol_types::SolCall>(
  function event_filter (line 818) | pub fn event_filter<E: alloy_sol_types::SolEvent>(
  type FheType (line 2328) | pub struct FheType(u8);
  constant _ (line 2329) | const _: () = {
  type CtHandleContractPair (line 2469) | pub struct CtHandleContractPair {
  constant _ (line 2481) | const _: () = {
  type SnsCiphertextMaterial (line 2693) | pub struct SnsCiphertextMaterial {
  constant _ (line 2711) | const _: () = {
  type AddressEmptyCode (line 2979) | pub struct AddressEmptyCode {
  constant _ (line 2989) | const _: () = {
  type ContractAddressesMaxLengthExceeded (line 3059) | pub struct ContractAddressesMaxLengthExceeded {
  constant _ (line 3071) | const _: () = {
  type ContractNotInContractAddresses (line 3155) | pub struct ContractNotInContractAddresses {
  constant _ (line 3169) | const _: () = {
  type CoprocessorSignerDoesNotMatchTxSender (line 3253) | pub struct CoprocessorSignerDoesNotMatchTxSender {
  constant _ (line 3265) | const _: () = {
  type CtHandleChainIdDiffersFromContractChainId (line 3349) | pub struct CtHandleChainIdDiffersFromContractChainId {
  constant _ (line 3363) | const _: () = {
  type DecryptionNotRequested (line 3453) | pub struct DecryptionNotRequested {
  constant _ (line 3463) | const _: () = {
  type DelegatorAddressInContractAddresses (line 3535) | pub struct DelegatorAddressInContractAddresses {
  constant _ (line 3549) | const _: () = {
  type DifferentKeyIdsNotAllowed (line 3633) | pub struct DifferentKeyIdsNotAllowed {
  constant _ (line 3645) | const _: () = {
  type ECDSAInvalidSignature (line 3726) | pub struct ECDSAInvalidSignature;
  constant _ (line 3733) | const _: () = {
  type ECDSAInvalidSignatureLength (line 3799) | pub struct ECDSAInvalidSignatureLength {
  constant _ (line 3809) | const _: () = {
  type ECDSAInvalidSignatureS (line 3883) | pub struct ECDSAInvalidSignatureS {
  constant _ (line 3893) | const _: () = {
  type ERC1967InvalidImplementation (line 3963) | pub struct ERC1967InvalidImplementation {
  constant _ (line 3973) | const _: () = {
  type ERC1967NonPayable (line 4045) | pub struct ERC1967NonPayable;
  constant _ (line 4052) | const _: () = {
  type EmptyContractAddresses (line 4118) | pub struct EmptyContractAddresses;
  constant _ (line 4125) | const _: () = {
  type EmptyCtHandleContractPairs (line 4191) | pub struct EmptyCtHandleContractPairs;
  constant _ (line 4198) | const _: () = {
  type EmptyCtHandles (line 4266) | pub struct EmptyCtHandles;
  constant _ (line 4273) | const _: () = {
  type EnforcedPause (line 4339) | pub struct EnforcedPause;
  constant _ (line 4346) | const _: () = {
  type ExpectedPause (line 4412) | pub struct ExpectedPause;
  constant _ (line 4419) | const _: () = {
  type FailedCall (line 4485) | pub struct FailedCall;
  constant _ (line 4492) | const _: () = {
  type HostChainNotRegistered (line 4558) | pub struct HostChainNotRegistered {
  constant _ (line 4568) | const _: () = {
  type InvalidFHEType (line 4640) | pub struct InvalidFHEType {
  constant _ (line 4650) | const _: () = {
  type InvalidInitialization (line 4720) | pub struct InvalidInitialization;
  constant _ (line 4727) | const _: () = {
  type InvalidNullDurationDays (line 4793) | pub struct InvalidNullDurationDays;
  constant _ (line 4800) | const _: () = {
  type InvalidUserSignature (line 4866) | pub struct InvalidUserSignature {
  constant _ (line 4876) | const _: () = {
  type KmsNodeAlreadySigned (line 4946) | pub struct KmsNodeAlreadySigned {
  constant _ (line 4958) | const _: () = {
  type KmsSignerDoesNotMatchTxSender (line 5040) | pub struct KmsSignerDoesNotMatchTxSender {
  constant _ (line 5052) | const _: () = {
  type MaxDecryptionRequestBitSizeExceeded (line 5136) | pub struct MaxDecryptionRequestBitSizeExceeded {
  constant _ (line 5148) | const _: () = {
  type MaxDurationDaysExceeded (line 5232) | pub struct MaxDurationDaysExceeded {
  constant _ (line 5244) | const _: () = {
  type NotCoprocessorSigner (line 5326) | pub struct NotCoprocessorSigner {
  constant _ (line 5336) | const _: () = {
  type NotCoprocessorTxSender (line 5406) | pub struct NotCoprocessorTxSender {
  constant _ (line 5416) | const _: () = {
  type NotCustodianSigner (line 5486) | pub struct NotCustodianSigner {
  constant _ (line 5496) | const _: () = {
  type NotCustodianTxSender (line 5566) | pub struct NotCustodianTxSender {
  constant _ (line 5576) | const _: () = {
  type NotGatewayOwner (line 5646) | pub struct NotGatewayOwner {
  constant _ (line 5656) | const _: () = {
  type NotInitializing (line 5726) | pub struct NotInitializing;
  constant _ (line 5733) | const _: () = {
  type NotInitializingFromEmptyProxy (line 5799) | pub struct NotInitializingFromEmptyProxy;
  constant _ (line 5806) | const _: () = {
  type NotKmsSigner (line 5874) | pub struct NotKmsSigner {
  constant _ (line 5884) | const _: () = {
  type NotKmsTxSender (line 5954) | pub struct NotKmsTxSender {
  constant _ (line 5964) | const _: () = {
  type NotOwnerOrGatewayConfig (line 6034) | pub struct NotOwnerOrGatewayConfig {
  constant _ (line 6044) | const _: () = {
  type NotPauserOrGatewayConfig (line 6116) | pub struct NotPauserOrGatewayConfig {
  constant _ (line 6126) | const _: () = {
  type StartTimestampInFuture (line 6200) | pub struct StartTimestampInFuture {
  constant _ (line 6212) | const _: () = {
  type UUPSUnauthorizedCallContext (line 6294) | pub struct UUPSUnauthorizedCallContext;
  constant _ (line 6301) | const _: () = {
  type UUPSUnsupportedProxiableUUID (line 6369) | pub struct UUPSUnsupportedProxiableUUID {
  constant _ (line 6379) | const _: () = {
  type UnsupportedFHEType (line 6451) | pub struct UnsupportedFHEType {
  constant _ (line 6461) | const _: () = {
  type UserAddressInContractAddresses (line 6529) | pub struct UserAddressInContractAddresses {
  constant _ (line 6543) | const _: () = {
  type UserDecryptionRequestExpired (line 6627) | pub struct UserDecryptionRequestExpired {
  constant _ (line 6639) | const _: () = {
  type EIP712DomainChanged (line 6728) | pub struct EIP712DomainChanged;
  constant _ (line 6735) | const _: () = {
  type Initialized (line 6826) | pub struct Initialized {
  constant _ (line 6836) | const _: () = {
  type Paused (line 6931) | pub struct Paused {
  constant _ (line 6941) | const _: () = {
  type PublicDecryptionRequest (line 7036) | pub struct PublicDecryptionRequest {
  constant _ (line 7052) | const _: () = {
  type PublicDecryptionResponse (line 7165) | pub struct PublicDecryptionResponse {
  constant _ (line 7181) | const _: () = {
  type PublicDecryptionResponseCall (line 7299) | pub struct PublicDecryptionResponseCall {
  constant _ (line 7317) | const _: () = {
  type Unpaused (line 7440) | pub struct Unpaused {
  constant _ (line 7450) | const _: () = {
  type Upgraded (line 7545) | pub struct Upgraded {
  constant _ (line 7555) | const _: () = {
  type UserDecryptionRequest (line 7652) | pub struct UserDecryptionRequest {
  constant _ (line 7672) | const _: () = {
  type UserDecryptionResponse (line 7793) | pub struct UserDecryptionResponse {
  constant _ (line 7811) | const _: () = {
  type UserDecryptionResponseThresholdReached (line 7932) | pub struct UserDecryptionResponseThresholdReached {
  constant _ (line 7942) | const _: () = {
  type constructorCall (line 8036) | pub struct constructorCall {}
  constant _ (line 8037) | const _: () = {
  type UPGRADE_INTERFACE_VERSIONCall (line 8096) | pub struct UPGRADE_INTERFACE_VERSIONCall;
  type UPGRADE_INTERFACE_VERSIONReturn (line 8102) | pub struct UPGRADE_INTERFACE_VERSIONReturn {
  constant _ (line 8112) | const _: () = {
  type delegatedUserDecryptionRequestCall (line 8243) | pub struct delegatedUserDecryptionRequestCall {
  type delegatedUserDecryptionRequestReturn (line 8264) | pub struct delegatedUserDecryptionRequestReturn {}
  constant _ (line 8271) | const _: () = {
  type eip712DomainCall (line 8467) | pub struct eip712DomainCall;
  type eip712DomainReturn (line 8473) | pub struct eip712DomainReturn {
  constant _ (line 8497) | const _: () = {
  type getDecryptionConsensusTxSendersCall (line 8685) | pub struct getDecryptionConsensusTxSendersCall {
  type getDecryptionConsensusTxSendersReturn (line 8694) | pub struct getDecryptionConsensusTxSendersReturn {
  constant _ (line 8704) | const _: () = {
  type getVersionCall (line 8849) | pub struct getVersionCall;
  type getVersionReturn (line 8855) | pub struct getVersionReturn {
  constant _ (line 8865) | const _: () = {
  type initializeFromEmptyProxyCall (line 8992) | pub struct initializeFromEmptyProxyCall;
  type initializeFromEmptyProxyReturn (line 8996) | pub struct initializeFromEmptyProxyReturn {}
  constant _ (line 9003) | const _: () = {
  type isDecryptionDoneCall (line 9133) | pub struct isDecryptionDoneCall {
  type isDecryptionDoneReturn (line 9142) | pub struct isDecryptionDoneReturn {
  constant _ (line 9152) | const _: () = {
  type isDelegatedUserDecryptionReadyCall (line 9289) | pub struct isDelegatedUserDecryptionReadyCall {
  type isDelegatedUserDecryptionReadyReturn (line 9302) | pub struct isDelegatedUserDecryptionReadyReturn {
  constant _ (line 9312) | const _: () = {
  type isPublicDecryptionReadyCall (line 9466) | pub struct isPublicDecryptionReadyCall {
  type isPublicDecryptionReadyReturn (line 9479) | pub struct isPublicDecryptionReadyReturn {
  constant _ (line 9489) | const _: () = {
  type isUserDecryptionReadyCall (line 9645) | pub struct isUserDecryptionReadyCall {
  type isUserDecryptionReadyReturn (line 9658) | pub struct isUserDecryptionReadyReturn {
  constant _ (line 9668) | const _: () = {
  type pauseCall (line 9822) | pub struct pauseCall;
  type pauseReturn (line 9826) | pub struct pauseReturn {}
  constant _ (line 9833) | const _: () = {
  type pausedCall (line 9957) | pub struct pausedCall;
  type pausedReturn (line 9963) | pub struct pausedReturn {
  constant _ (line 9973) | const _: () = {
  type proxiableUUIDCall (line 10100) | pub struct proxiableUUIDCall;
  type proxiableUUIDReturn (line 10106) | pub struct proxiableUUIDReturn {
  constant _ (line 10116) | const _: () = {
  type publicDecryptionRequestCall (line 10243) | pub struct publicDecryptionRequestCall {
  type publicDecryptionRequestReturn (line 10254) | pub struct publicDecryptionRequestReturn {}
  constant _ (line 10261) | const _: () = {
  type publicDecryptionResponseCall (line 10416) | pub struct publicDecryptionResponseCall {
  type publicDecryptionResponseReturn (line 10429) | pub struct publicDecryptionResponseReturn {}
  constant _ (line 10436) | const _: () = {
  type reinitializeV4Call (line 10604) | pub struct reinitializeV4Call;
  type reinitializeV4Return (line 10608) | pub struct reinitializeV4Return {}
  constant _ (line 10615) | const _: () = {
  type unpauseCall (line 10741) | pub struct unpauseCall;
  type unpauseReturn (line 10745) | pub struct unpauseReturn {}
  constant _ (line 10752) | const _: () = {
  type upgradeToAndCallCall (line 10876) | pub struct upgradeToAndCallCall {
  type upgradeToAndCallReturn (line 10885) | pub struct upgradeToAndCallReturn {}
  constant _ (line 10892) | const _: () = {
  type userDecryptionRequestCall (line 11039) | pub struct userDecryptionRequestCall {
  type userDecryptionRequestReturn (line 11060) | pub struct userDecryptionRequestReturn {}
  constant _ (line 11067) | const _: () = {
  type userDecryptionResponseCall (line 11263) | pub struct userDecryptionResponseCall {
  type userDecryptionResponseReturn (line 11276) | pub struct userDecryptionResponseReturn {}
  constant _ (line 11283) | const _: () = {
  type DecryptionCalls (line 11446) | pub enum DecryptionCalls {
    constant SELECTORS (line 11496) | pub const SELECTORS: &'static [[u8; 4usize]] = &[
    constant NAME (line 11521) | const NAME: &'static str = "DecryptionCalls";
    constant MIN_DATA_LENGTH (line 11522) | const MIN_DATA_LENGTH: usize = 0usize;
    constant COUNT (line 11523) | const COUNT: usize = 20usize;
    method selector (line 11525) | fn selector(&self) -> [u8; 4] {
    method selector_at (line 11584) | fn selector_at(i: usize) -> ::core::option::Option<[u8; 4]> {
    method valid_selector (line 11588) | fn valid_selector(selector: [u8; 4]) -> bool {
    method abi_decode_raw (line 11593) | fn abi_decode_raw(
    method abi_decode_raw_validate (line 11821) | fn abi_decode_raw_validate(
    method abi_encoded_size (line 12054) | fn abi_encoded_size(&self) -> usize {
    method abi_encode_raw (line 12151) | fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
  type DecryptionErrors (line 12270) | pub enum DecryptionErrors {
    constant SELECTORS (line 12372) | pub const SELECTORS: &'static [[u8; 4usize]] = &[
    constant NAME (line 12422) | const NAME: &'static str = "DecryptionErrors";
    constant MIN_DATA_LENGTH (line 12423) | const MIN_DATA_LENGTH: usize = 0usize;
    constant COUNT (line 12424) | const COUNT: usize = 45usize;
    method selector (line 12426) | fn selector(&self) -> [u8; 4] {
    method selector_at (line 12566) | fn selector_at(i: usize) -> ::core::option::Option<[u8; 4]> {
    method valid_selector (line 12570) | fn valid_selector(selector: [u8; 4]) -> bool {
    method abi_decode_raw (line 12575) | fn abi_decode_raw(
    method abi_decode_raw_validate (line 13088) | fn abi_decode_raw_validate(
    method abi_encoded_size (line 13604) | fn abi_encoded_size(&self) -> usize {
    method abi_encode_raw (line 13826) | fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
  type DecryptionEvents (line 14101) | pub enum DecryptionEvents {
    constant SELECTORS (line 14133) | pub const SELECTORS: &'static [[u8; 32usize]] = &[
    constant NAME (line 14193) | const NAME: &'static str = "DecryptionEvents";
    constant COUNT (line 14194) | const COUNT: usize = 11usize;
    method decode_raw_log (line 14195) | fn decode_raw_log(
    method to_log_data (line 14298) | fn to_log_data(&self) -> alloy_sol_types::private::LogData {
    method into_log_data (line 14335) | fn into_log_data(self) -> alloy_sol_types::private::LogData {
  function new (line 14378) | pub const fn new<
  function deploy (line 14393) | pub fn deploy<
  function deploy_builder (line 14409) | pub fn deploy_builder<
  type DecryptionInstance (line 14427) | pub struct DecryptionInstance<P, N = alloy_contract::private::Ethereum> {
  function fmt (line 14435) | fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
  function new (line 14449) | pub const fn new(
  function deploy (line 14465) | pub async fn deploy(
  function deploy_builder (line 14478) | pub fn deploy_builder(provider: P) -> alloy_contract::RawCallBuilder<P, ...
  function address (line 14486) | pub const fn address(&self) -> &alloy_sol_types::private::Address {
  function set_address (line 14491) | pub fn set_address(&mut self, address: alloy_sol_types::private::Address) {
  function at (line 14495) | pub fn at(mut self, address: alloy_sol_types::private::Address) -> Self {
  function provider (line 14501) | pub const fn provider(&self) -> &P {
  function with_cloned_provider (line 14508) | pub fn with_cloned_provider(self) -> DecryptionInstance<P, N> {
  function call_builder (line 14526) | pub fn call_builder<C: alloy_sol_types::SolCall>(
  function UPGRADE_INTERFACE_VERSION (line 14533) | pub fn UPGRADE_INTERFACE_VERSION(
  function delegatedUserDecryptionRequest (line 14539) | pub fn delegatedUserDecryptionRequest(
  function eip712Domain (line 14564) | pub fn eip712Domain(
  function getDecryptionConsensusTxSenders (line 14570) | pub fn getDecryptionConsensusTxSenders(
  function getVersion (line 14581) | pub fn getVersion(
  function initializeFromEmptyProxy (line 14587) | pub fn initializeFromEmptyProxy(
  function isDecryptionDone (line 14593) | pub fn isDecryptionDone(
  function isDelegatedUserDecryptionReady (line 14604) | pub fn isDelegatedUserDecryptionReady(
  function isPublicDecryptionReady (line 14619) | pub fn isPublicDecryptionReady(
  function isUserDecryptionReady (line 14634) | pub fn isUserDecryptionReady(
  function pause (line 14649) | pub fn pause(&self) -> alloy_contract::SolCallBuilder<&P, pauseCall, N> {
  function paused (line 14653) | pub fn paused(&self) -> alloy_contract::SolCallBuilder<&P, pausedCall, N> {
  function proxiableUUID (line 14657) | pub fn proxiableUUID(
  function publicDecryptionRequest (line 14663) | pub fn publicDecryptionRequest(
  function publicDecryptionResponse (line 14678) | pub fn publicDecryptionResponse(
  function reinitializeV4 (line 14695) | pub fn reinitializeV4(
  function unpause (line 14701) | pub fn unpause(&self) -> alloy_contract::SolCallBuilder<&P, unpauseCall,...
  function upgradeToAndCall (line 14705) | pub fn upgradeToAndCall(
  function userDecryptionRequest (line 14718) | pub fn userDecryptionRequest(
  function userDecryptionResponse (line 14743) | pub fn userDecryptionResponse(
  function event_filter (line 14770) | pub fn event_filter<E: alloy_sol_types::SolEvent>(
  function EIP712DomainChanged_filter (line 14776) | pub fn EIP712DomainChanged_filter(
  function Initialized_filter (line 14782) | pub fn Initialized_filter(&self) -> alloy_contract::Event<&P, Initialize...
  function Paused_filter (line 14786) | pub fn Paused_filter(&self) -> alloy_contract::Event<&P, Paused, N> {
  function PublicDecryptionRequest_filter (line 14790) | pub fn PublicDecryptionRequest_filter(
  function PublicDecryptionResponse_filter (line 14796) | pub fn PublicDecryptionResponse_filter(
  function PublicDecryptionResponseCall_filter (line 14802) | pub fn PublicDecryptionResponseCall_filter(
  function Unpaused_filter (line 14808) | pub fn Unpaused_filter(&self) -> alloy_contract::Event<&P, Unpaused, N> {
  function Upgraded_filter (line 14812) | pub fn Upgraded_filter(&self) -> alloy_contract::Event<&P, Upgraded, N> {
  function UserDecryptionRequest_filter (line 14816) | pub fn UserDecryptionRequest_filter(
  function UserDecryptionResponse_filter (line 14822) | pub fn UserDecryptionResponse_filter(
  function UserDecryptionResponseThresholdReached_filter (line 14828) | pub fn UserDecryptionResponseThresholdReached_filter(

FILE: gateway-contracts/rust_bindings/src/ecdsa.rs
  type ECDSAInvalidSignature (line 82) | pub struct ECDSAInvalidSignature;
  constant _ (line 89) | const _: () = {
  type ECDSAInvalidSignatureLength (line 155) | pub struct ECDSAInvalidSignatureLength {
  constant _ (line 165) | const _: () = {
  type ECDSAInvalidSignatureS (line 239) | pub struct ECDSAInvalidSignatureS {
  constant _ (line 249) | const _: () = {
  type ECDSAErrors (line 314) | pub enum ECDSAErrors {
    constant SELECTORS (line 330) | pub const SELECTORS: &'static [[u8; 4usize]] = &[
    constant NAME (line 338) | const NAME: &'static str = "ECDSAErrors";
    constant MIN_DATA_LENGTH (line 339) | const MIN_DATA_LENGTH: usize = 0usize;
    constant COUNT (line 340) | const COUNT: usize = 3usize;
    method selector (line 342) | fn selector(&self) -> [u8; 4] {
    method selector_at (line 356) | fn selector_at(i: usize) -> ::core::option::Option<[u8; 4]> {
    method valid_selector (line 360) | fn valid_selector(selector: [u8; 4]) -> bool {
    method abi_decode_raw (line 365) | fn abi_decode_raw(
    method abi_decode_raw_validate (line 416) | fn abi_decode_raw_validate(
    method abi_encoded_size (line 468) | fn abi_encoded_size(&self) -> usize {
    method abi_encode_raw (line 488) | fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
  function new (line 516) | pub const fn new<
  function deploy (line 528) | pub fn deploy<
  function deploy_builder (line 544) | pub fn deploy_builder<
  type ECDSAInstance (line 562) | pub struct ECDSAInstance<P, N = alloy_contract::private::Ethereum> {
  function fmt (line 570) | fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
  function new (line 584) | pub const fn new(
  function deploy (line 600) | pub async fn deploy(provider: P) -> alloy_contract::Result<ECDSAInstance...
  function deploy_builder (line 611) | pub fn deploy_builder(provider: P) -> alloy_contract::RawCallBuilder<P, ...
  function address (line 619) | pub const fn address(&self) -> &alloy_sol_types::private::Address {
  function set_address (line 624) | pub fn set_address(&mut self, address: alloy_sol_types::private::Address) {
  function at (line 628) | pub fn at(mut self, address: alloy_sol_types::private::Address) -> Self {
  function provider (line 634) | pub const fn provider(&self) -> &P {
  function with_cloned_provider (line 641) | pub fn with_cloned_provider(self) -> ECDSAInstance<P, N> {
  function call_builder (line 659) | pub fn call_builder<C: alloy_sol_types::SolCall>(
  function event_filter (line 676) | pub fn event_filter<E: alloy_sol_types::SolEvent>(

FILE: gateway-contracts/rust_bindings/src/eip712_upgradeable.rs
  type InvalidInitialization (line 131) | pub struct InvalidInitialization;
  constant _ (line 138) | const _: () = {
  type NotInitializing (line 204) | pub struct NotInitializing;
  constant _ (line 211) | const _: () = {
  type EIP712DomainChanged (line 282) | pub struct EIP712DomainChanged;
  constant _ (line 289) | const _: () = {
  type Initialized (line 380) | pub struct Initialized {
  constant _ (line 390) | const _: () = {
  type eip712DomainCall (line 480) | pub struct eip712DomainCall;
  type eip712DomainReturn (line 486) | pub struct eip712DomainReturn {
  constant _ (line 510) | const _: () = {
  type EIP712UpgradeableCalls (line 693) | pub enum EIP712UpgradeableCalls {
    constant SELECTORS (line 705) | pub const SELECTORS: &'static [[u8; 4usize]] = &[[132u8, 176u8, 25u8, ...
    constant NAME (line 709) | const NAME: &'static str = "EIP712UpgradeableCalls";
    constant MIN_DATA_LENGTH (line 710) | const MIN_DATA_LENGTH: usize = 0usize;
    constant COUNT (line 711) | const COUNT: usize = 1usize;
    method selector (line 713) | fn selector(&self) -> [u8; 4] {
    method selector_at (line 721) | fn selector_at(i: usize) -> ::core::option::Option<[u8; 4]> {
    method valid_selector (line 725) | fn valid_selector(selector: [u8; 4]) -> bool {
    method abi_decode_raw (line 730) | fn abi_decode_raw(
    method abi_decode_raw_validate (line 761) | fn abi_decode_raw_validate(
    method abi_encoded_size (line 791) | fn abi_encoded_size(&self) -> usize {
    method abi_encode_raw (line 801) | fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
  type EIP712UpgradeableErrors (line 815) | pub enum EIP712UpgradeableErrors {
    constant SELECTORS (line 829) | pub const SELECTORS: &'static [[u8; 4usize]] = &[
    constant NAME (line 836) | const NAME: &'static str = "EIP712UpgradeableErrors";
    constant MIN_DATA_LENGTH (line 837) | const MIN_DATA_LENGTH: usize = 0usize;
    constant COUNT (line 838) | const COUNT: usize = 2usize;
    method selector (line 840) | fn selector(&self) -> [u8; 4] {
    method selector_at (line 851) | fn selector_at(i: usize) -> ::core::option::Option<[u8; 4]> {
    method valid_selector (line 855) | fn valid_selector(selector: [u8; 4]) -> bool {
    method abi_decode_raw (line 860) | fn abi_decode_raw(
    method abi_decode_raw_validate (line 902) | fn abi_decode_raw_validate(
    method abi_encoded_size (line 943) | fn abi_encoded_size(&self) -> usize {
    method abi_encode_raw (line 958) | fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
  type EIP712UpgradeableEvents (line 978) | pub enum EIP712UpgradeableEvents {
    constant SELECTORS (line 992) | pub const SELECTORS: &'static [[u8; 32usize]] = &[
    constant NAME (line 1007) | const NAME: &'static str = "EIP712UpgradeableEvents";
    constant COUNT (line 1008) | const COUNT: usize = 2usize;
    method decode_raw_log (line 1009) | fn decode_raw_log(
    method to_log_data (line 1046) | fn to_log_data(&self) -> alloy_sol_types::private::LogData {
    method into_log_data (line 1056) | fn into_log_data(self) -> alloy_sol_types::private::LogData {
  function new (line 1072) | pub const fn new<
  function deploy (line 1087) | pub fn deploy<
  function deploy_builder (line 1103) | pub fn deploy_builder<
  type EIP712UpgradeableInstance (line 1121) | pub struct EIP712UpgradeableInstance<P, N = alloy_contract::private::Eth...
  function fmt (line 1129) | fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
  function new (line 1143) | pub const fn new(
  function deploy (line 1159) | pub async fn deploy(
  function deploy_builder (line 1172) | pub fn deploy_builder(provider: P) -> alloy_contract::RawCallBuilder<P, ...
  function address (line 1180) | pub const fn address(&self) -> &alloy_sol_types::private::Address {
  function set_address (line 1185) | pub fn set_address(&mut self, address: alloy_sol_types::private::Address) {
  function at (line 1189) | pub fn at(mut self, address: alloy_sol_types::private::Address) -> Self {
  function provider (line 1195) | pub const fn provider(&self) -> &P {
  function with_cloned_provider (line 1202) | pub fn with_cloned_provider(self) -> EIP712UpgradeableInstance<P, N> {
  function call_builder (line 1220) | pub fn call_builder<C: alloy_sol_types::SolCall>(
  function eip712Domain (line 1227) | pub fn eip712Domain(
  function event_filter (line 1243) | pub fn event_filter<E: alloy_sol_types::SolEvent>(
  function EIP712DomainChanged_filter (line 1249) | pub fn EIP712DomainChanged_filter(
  function Initialized_filter (line 1255) | pub fn Initialized_filter(&self) -> alloy_contract::Event<&P, Initialize...

FILE: gateway-contracts/rust_bindings/src/empty_uups_proxy.rs
  type AddressEmptyCode (line 222) | pub struct AddressEmptyCode {
  constant _ (line 232) | const _: () = {
  type ERC1967InvalidImplementation (line 302) | pub struct ERC1967InvalidImplementation {
  constant _ (line 312) | const _: () = {
  type ERC1967NonPayable (line 384) | pub struct ERC1967NonPayable;
  constant _ (line 391) | const _: () = {
  type FailedCall (line 457) | pub struct FailedCall;
  constant _ (line 464) | const _: () = {
  type InvalidInitialization (line 530) | pub struct InvalidInitialization;
  constant _ (line 537) | const _: () = {
  type NotGatewayOwner (line 603) | pub struct NotGatewayOwner {
  constant _ (line 613) | const _: () = {
  type NotInitializing (line 683) | pub struct NotInitializing;
  constant _ (line 690) | const _: () = {
  type UUPSUnauthorizedCallContext (line 756) | pub struct UUPSUnauthorizedCallContext;
  constant _ (line 763) | const _: () = {
  type UUPSUnsupportedProxiableUUID (line 831) | pub struct UUPSUnsupportedProxiableUUID {
  constant _ (line 841) | const _: () = {
  type Initialized (line 918) | pub struct Initialized {
  constant _ (line 928) | const _: () = {
  type Upgraded (line 1023) | pub struct Upgraded {
  constant _ (line 1033) | const _: () = {
  type constructorCall (line 1123) | pub struct constructorCall {}
  constant _ (line 1124) | const _: () = {
  type UPGRADE_INTERFACE_VERSIONCall (line 1183) | pub struct UPGRADE_INTERFACE_VERSIONCall;
  type UPGRADE_INTERFACE_VERSIONReturn (line 1189) | pub struct UPGRADE_INTERFACE_VERSIONReturn {
  constant _ (line 1199) | const _: () = {
  type initializeCall (line 1330) | pub struct initializeCall;
  type initializeReturn (line 1334) | pub struct initializeReturn {}
  constant _ (line 1341) | const _: () = {
  type proxiableUUIDCall (line 1465) | pub struct proxiableUUIDCall;
  type proxiableUUIDReturn (line 1471) | pub struct proxiableUUIDReturn {
  constant _ (line 1481) | const _: () = {
  type upgradeToAndCallCall (line 1608) | pub struct upgradeToAndCallCall {
  type upgradeToAndCallReturn (line 1617) | pub struct upgradeToAndCallReturn {}
  constant _ (line 1624) | const _: () = {
  type EmptyUUPSProxyCalls (line 1766) | pub enum EmptyUUPSProxyCalls {
    constant SELECTORS (line 1784) | pub const SELECTORS: &'static [[u8; 4usize]] = &[
    constant NAME (line 1793) | const NAME: &'static str = "EmptyUUPSProxyCalls";
    constant MIN_DATA_LENGTH (line 1794) | const MIN_DATA_LENGTH: usize = 0usize;
    constant COUNT (line 1795) | const COUNT: usize = 4usize;
    method selector (line 1797) | fn selector(&self) -> [u8; 4] {
    method selector_at (line 1814) | fn selector_at(i: usize) -> ::core::option::Option<[u8; 4]> {
    method valid_selector (line 1818) | fn valid_selector(selector: [u8; 4]) -> bool {
    method abi_decode_raw (line 1823) | fn abi_decode_raw(
    method abi_decode_raw_validate (line 1887) | fn abi_decode_raw_validate(
    method abi_encoded_size (line 1950) | fn abi_encoded_size(&self) -> usize {
    method abi_encode_raw (line 1973) | fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
  type EmptyUUPSProxyErrors (line 2005) | pub enum EmptyUUPSProxyErrors {
    constant SELECTORS (line 2033) | pub const SELECTORS: &'static [[u8; 4usize]] = &[
    constant NAME (line 2047) | const NAME: &'static str = "EmptyUUPSProxyErrors";
    constant MIN_DATA_LENGTH (line 2048) | const MIN_DATA_LENGTH: usize = 0usize;
    constant COUNT (line 2049) | const COUNT: usize = 9usize;
    method selector (line 2051) | fn selector(&self) -> [u8; 4] {
    method selector_at (line 2083) | fn selector_at(i: usize) -> ::core::option::Option<[u8; 4]> {
    method valid_selector (line 2087) | fn valid_selector(selector: [u8; 4]) -> bool {
    method abi_decode_raw (line 2092) | fn abi_decode_raw(
    method abi_decode_raw_validate (line 2209) | fn abi_decode_raw_validate(
    method abi_encoded_size (line 2327) | fn abi_encoded_size(&self) -> usize {
    method abi_encode_raw (line 2375) | fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
  type EmptyUUPSProxyEvents (line 2434) | pub enum EmptyUUPSProxyEvents {
    constant SELECTORS (line 2448) | pub const SELECTORS: &'static [[u8; 32usize]] = &[
    constant NAME (line 2463) | const NAME: &'static str = "EmptyUUPSProxyEvents";
    constant COUNT (line 2464) | const COUNT: usize = 2usize;
    method decode_raw_log (line 2465) | fn decode_raw_log(
    method to_log_data (line 2497) | fn to_log_data(&self) -> alloy_sol_types::private::LogData {
    method into_log_data (line 2507) | fn into_log_data(self) -> alloy_sol_types::private::LogData {
  function new (line 2523) | pub const fn new<
  function deploy (line 2538) | pub fn deploy<
  function deploy_builder (line 2554) | pub fn deploy_builder<
  type EmptyUUPSProxyInstance (line 2572) | pub struct EmptyUUPSProxyInstance<P, N = alloy_contract::private::Ethere...
  function fmt (line 2580) | fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
  function new (line 2594) | pub const fn new(
  function deploy (line 2610) | pub async fn deploy(
  function deploy_builder (line 2623) | pub fn deploy_builder(provider: P) -> alloy_contract::RawCallBuilder<P, ...
  function address (line 2631) | pub const fn address(&self) -> &alloy_sol_types::private::Address {
  function set_address (line 2636) | pub fn set_address(&mut self, address: alloy_sol_types::private::Address) {
  function at (line 2640) | pub fn at(mut self, address: alloy_sol_types::private::Address) -> Self {
  function provider (line 2646) | pub const fn provider(&self) -> &P {
  function with_cloned_provider (line 2653) | pub fn with_cloned_provider(self) -> EmptyUUPSProxyInstance<P, N> {
  function call_builder (line 2671) | pub fn call_builder<C: alloy_sol_types::SolCall>(
  function UPGRADE_INTERFACE_VERSION (line 2678) | pub fn UPGRADE_INTERFACE_VERSION(
  function initialize (line 2684) | pub fn initialize(
  function proxiableUUID (line 2690) | pub fn proxiableUUID(
  function upgradeToAndCall (line 2696) | pub fn upgradeToAndCall(
  function event_filter (line 2719) | pub fn event_filter<E: alloy_sol_types::SolEvent>(
  function Initialized_filter (line 2725) | pub fn Initialized_filter(&self) -> alloy_contract::Event<&P, Initialize...
  function Upgraded_filter (line 2729) | pub fn Upgraded_filter(&self) -> alloy_contract::Event<&P, Upgraded, N> {

FILE: gateway-contracts/rust_bindings/src/empty_uups_proxy_gateway_config.rs
  type AddressEmptyCode (line 338) | pub struct AddressEmptyCode {
  constant _ (line 348) | const _: () = {
  type ERC1967InvalidImplementation (line 418) | pub struct ERC1967InvalidImplementation {
  constant _ (line 428) | const _: () = {
  type ERC1967NonPayable (line 500) | pub struct ERC1967NonPayable;
  constant _ (line 507) | const _: () = {
  type FailedCall (line 573) | pub struct FailedCall;
  constant _ (line 580) | const _: () = {
  type InvalidInitialization (line 646) | pub struct InvalidInitialization;
  constant _ (line 653) | const _: () = {
  type NotInitializing (line 719) | pub struct NotInitializing;
  constant _ (line 726) | const _: () = {
  type OwnableInvalidOwner (line 792) | pub struct OwnableInvalidOwner {
  constant _ (line 802) | const _: () = {
  type OwnableUnauthorizedAccount (line 872) | pub struct OwnableUnauthorizedAccount {
  constant _ (line 882) | const _: () = {
  type UUPSUnauthorizedCallContext (line 954) | pub struct UUPSUnauthorizedCallContext;
  constant _ (line 961) | const _: () = {
  type UUPSUnsupportedProxiableUUID (line 1029) | pub struct UUPSUnsupportedProxiableUUID {
  constant _ (line 1039) | const _: () = {
  type Initialized (line 1116) | pub struct Initialized {
  constant _ (line 1126) | const _: () = {
  type OwnershipTransferStarted (line 1221) | pub struct OwnershipTransferStarted {
  constant _ (line 1233) | const _: () = {
  type OwnershipTransferred (line 1343) | pub struct OwnershipTransferred {
  constant _ (line 1355) | const _: () = {
  type Upgraded (line 1463) | pub struct Upgraded {
  constant _ (line 1473) | const _: () = {
  type constructorCall (line 1563) | pub struct constructorCall {}
  constant _ (line 1564) | const _: () = {
  type UPGRADE_INTERFACE_VERSIONCall (line 1623) | pub struct UPGRADE_INTERFACE_VERSIONCall;
  type UPGRADE_INTERFACE_VERSIONReturn (line 1629) | pub struct UPGRADE_INTERFACE_VERSIONReturn {
  constant _ (line 1639) | const _: () = {
  type acceptOwnershipCall (line 1770) | pub struct acceptOwnershipCall;
  type acceptOwnershipReturn (line 1774) | pub struct acceptOwnershipReturn {}
  constant _ (line 1781) | const _: () = {
  type initializeCall (line 1907) | pub struct initializeCall {
  type initializeReturn (line 1914) | pub struct initializeReturn {}
  constant _ (line 1921) | const _: () = {
  type ownerCall (line 2049) | pub struct ownerCall;
  type ownerReturn (line 2055) | pub struct ownerReturn {
  constant _ (line 2065) | const _: () = {
  type pendingOwnerCall (line 2192) | pub struct pendingOwnerCall;
  type pendingOwnerReturn (line 2198) | pub struct pendingOwnerReturn {
  constant _ (line 2208) | const _: () = {
  type proxiableUUIDCall (line 2335) | pub struct proxiableUUIDCall;
  type proxiableUUIDReturn (line 2341) | pub struct proxiableUUIDReturn {
  constant _ (line 2351) | const _: () = {
  type renounceOwnershipCall (line 2478) | pub struct renounceOwnershipCall;
  type renounceOwnershipReturn (line 2482) | pub struct renounceOwnershipReturn {}
  constant _ (line 2489) | const _: () = {
  type transferOwnershipCall (line 2617) | pub struct transferOwnershipCall {
  type transferOwnershipReturn (line 2624) | pub struct transferOwnershipReturn {}
  constant _ (line 2631) | const _: () = {
  type upgradeToAndCallCall (line 2763) | pub struct upgradeToAndCallCall {
  type upgradeToAndCallReturn (line 2772) | pub struct upgradeToAndCallReturn {}
  constant _ (line 2779) | const _: () = {
  type EmptyUUPSProxyGatewayConfigCalls (line 2921) | pub enum EmptyUUPSProxyGatewayConfigCalls {
    constant SELECTORS (line 2949) | pub const SELECTORS: &'static [[u8; 4usize]] = &[
    constant NAME (line 2963) | const NAME: &'static str = "EmptyUUPSProxyGatewayConfigCalls";
    constant MIN_DATA_LENGTH (line 2964) | const MIN_DATA_LENGTH: usize = 0usize;
    constant COUNT (line 2965) | const COUNT: usize = 9usize;
    method selector (line 2967) | fn selector(&self) -> [u8; 4] {
    method selector_at (line 2997) | fn selector_at(i: usize) -> ::core::option::Option<[u8; 4]> {
    method valid_selector (line 3001) | fn valid_selector(selector: [u8; 4]) -> bool {
    method abi_decode_raw (line 3006) | fn abi_decode_raw(
    method abi_decode_raw_validate (line 3125) | fn abi_decode_raw_validate(
    method abi_encoded_size (line 3245) | fn abi_encoded_size(&self) -> usize {
    method abi_encode_raw (line 3291) | fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
  type EmptyUUPSProxyGatewayConfigErrors (line 3350) | pub enum EmptyUUPSProxyGatewayConfigErrors {
    constant SELECTORS (line 3380) | pub const SELECTORS: &'static [[u8; 4usize]] = &[
    constant NAME (line 3395) | const NAME: &'static str = "EmptyUUPSProxyGatewayConfigErrors";
    constant MIN_DATA_LENGTH (line 3396) | const MIN_DATA_LENGTH: usize = 0usize;
    constant COUNT (line 3397) | const COUNT: usize = 10usize;
    method selector (line 3399) | fn selector(&self) -> [u8; 4] {
    method selector_at (line 3434) | fn selector_at(i: usize) -> ::core::option::Option<[u8; 4]> {
    method valid_selector (line 3438) | fn valid_selector(selector: [u8; 4]) -> bool {
    method abi_decode_raw (line 3443) | fn abi_decode_raw(
    method abi_decode_raw_validate (line 3581) | fn abi_decode_raw_validate(
    method abi_encoded_size (line 3720) | fn abi_encoded_size(&self) -> usize {
    method abi_encode_raw (line 3773) | fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
  type EmptyUUPSProxyGatewayConfigEvents (line 3838) | pub enum EmptyUUPSProxyGatewayConfigEvents {
    constant SELECTORS (line 3856) | pub const SELECTORS: &'static [[u8; 32usize]] = &[
    constant NAME (line 3881) | const NAME: &'static str = "EmptyUUPSProxyGatewayConfigEvents";
    constant COUNT (line 3882) | const COUNT: usize = 4usize;
    method decode_raw_log (line 3883) | fn decode_raw_log(
    method to_log_data (line 3933) | fn to_log_data(&self) -> alloy_sol_types::private::LogData {
    method into_log_data (line 3949) | fn into_log_data(self) -> alloy_sol_types::private::LogData {
  function new (line 3971) | pub const fn new<
  function deploy (line 3986) | pub fn deploy<
  function deploy_builder (line 4002) | pub fn deploy_builder<
  type EmptyUUPSProxyGatewayConfigInstance (line 4020) | pub struct EmptyUUPSProxyGatewayConfigInstance<
  function fmt (line 4031) | fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
  function new (line 4047) | pub const fn new(
  function deploy (line 4063) | pub async fn deploy(
  function deploy_builder (line 4076) | pub fn deploy_builder(provider: P) -> alloy_contract::RawCallBuilder<P, ...
  function address (line 4084) | pub const fn address(&self) -> &alloy_sol_types::private::Address {
  function set_address (line 4089) | pub fn set_address(&mut self, address: alloy_sol_types::private::Address) {
  function at (line 4093) | pub fn at(mut self, address: alloy_sol_types::private::Address) -> Self {
  function provider (line 4099) | pub const fn provider(&self) -> &P {
  function with_cloned_provider (line 4106) | pub fn with_cloned_provider(self) -> EmptyUUPSProxyGatewayConfigInstance...
  function call_builder (line 4124) | pub fn call_builder<C: alloy_sol_types::SolCall>(
  function UPGRADE_INTERFACE_VERSION (line 4131) | pub fn UPGRADE_INTERFACE_VERSION(
  function acceptOwnership (line 4137) | pub fn acceptOwnership(
  function initialize (line 4143) | pub fn initialize(
  function owner (line 4150) | pub fn owner(&self) -> alloy_contract::SolCallBuilder<&P, ownerCall, N> {
  function pendingOwner (line 4154) | pub fn pendingOwner(
  function proxiableUUID (line 4160) | pub fn proxiableUUID(
  function renounceOwnership (line 4166) | pub fn renounceOwnership(
  function transferOwnership (line 4172) | pub fn transferOwnership(
  function upgradeToAndCall (line 4179) | pub fn upgradeToAndCall(
  function event_filter (line 4202) | pub fn event_filter<E: alloy_sol_types::SolEvent>(
  function Initialized_filter (line 4208) | pub fn Initialized_filter(&self) -> alloy_contract::Event<&P, Initialize...
  function OwnershipTransferStarted_filter (line 4212) | pub fn OwnershipTransferStarted_filter(
  function OwnershipTransferred_filter (line 4218) | pub fn OwnershipTransferred_filter(
  function Upgraded_filter (line 4224) | pub fn Upgraded_filter(&self) -> alloy_contract::Event<&P, Upgraded, N> {

FILE: gateway-contracts/rust_bindings/src/erc1967_utils.rs
  type ERC1967InvalidAdmin (line 94) | pub struct ERC1967InvalidAdmin {
  constant _ (line 104) | const _: () = {
  type ERC1967InvalidBeacon (line 174) | pub struct ERC1967InvalidBeacon {
  constant _ (line 184) | const _: () = {
  type ERC1967InvalidImplementation (line 254) | pub struct ERC1967InvalidImplementation {
  constant _ (line 264) | const _: () = {
  type ERC1967NonPayable (line 336) | pub struct ERC1967NonPayable;
  constant _ (line 343) | const _: () = {
  type ERC1967UtilsErrors (line 404) | pub enum ERC1967UtilsErrors {
    constant SELECTORS (line 422) | pub const SELECTORS: &'static [[u8; 4usize]] = &[
    constant NAME (line 431) | const NAME: &'static str = "ERC1967UtilsErrors";
    constant MIN_DATA_LENGTH (line 432) | const MIN_DATA_LENGTH: usize = 0usize;
    constant COUNT (line 433) | const COUNT: usize = 4usize;
    method selector (line 435) | fn selector(&self) -> [u8; 4] {
    method selector_at (line 452) | fn selector_at(i: usize) -> ::core::option::Option<[u8; 4]> {
    method valid_selector (line 456) | fn valid_selector(selector: [u8; 4]) -> bool {
    method abi_decode_raw (line 461) | fn abi_decode_raw(
    method abi_decode_raw_validate (line 525) | fn abi_decode_raw_validate(
    method abi_encoded_size (line 588) | fn abi_encoded_size(&self) -> usize {
    method abi_encode_raw (line 613) | fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
  function new (line 647) | pub const fn new<
  function deploy (line 662) | pub fn deploy<
  function deploy_builder (line 678) | pub fn deploy_builder<
  type ERC1967UtilsInstance (line 696) | pub struct ERC1967UtilsInstance<P, N = alloy_contract::private::Ethereum> {
  function fmt (line 704) | fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
  function new (line 718) | pub const fn new(
  function deploy (line 734) | pub async fn deploy(
  function deploy_builder (line 747) | pub fn deploy_builder(provider: P) -> alloy_contract::RawCallBuilder<P, ...
  function address (line 755) | pub const fn address(&self) -> &alloy_sol_types::private::Address {
  function set_address (line 760) | pub fn set_address(&mut self, address: alloy_sol_types::private::Address) {
  fun

[
  {
    "path": ".commitlintrc.json",
    "chars": 53,
    "preview": "{\n  \"extends\": [\"@commitlint/config-conventional\"]\n}\n"
  },
  {
    "path": ".dockerignore",
    "chars": 4531,
    "preview": "# =============================================================================\n# Root .dockerignore for fhevm repositor"
  },
  {
    "path": ".github/CODEOWNERS",
    "chars": 863,
    "preview": "# Zama codeowners rules\n\n# All pull request should be reviewed by at least one of the members of fhevm-devs\n*    @zama-a"
  },
  {
    "path": ".github/CONTRIBUTING.md",
    "chars": 8017,
    "preview": "# GitHub Actions / Workflows\n\nThis directory contains the CI/CD workflows for the fhevm repository.\n\n## Docker Build Wor"
  },
  {
    "path": ".github/ISSUE_TEMPLATE/config.yml",
    "chars": 160,
    "preview": "blank_issues_enabled: false\ncontact_links:\n  - name: Questions & Support Requests\n    url: https://community.zama.ai\n   "
  },
  {
    "path": ".github/ISSUE_TEMPLATE/documentation-issue.md",
    "chars": 852,
    "preview": "---\nname: Documentation Issue\nabout: Fill any issue related to product documentation\ntitle: 'docs(<category>): short des"
  },
  {
    "path": ".github/ISSUE_TEMPLATE/gateway_contracts_issue.yml",
    "chars": 1022,
    "preview": "name: \"Gateway Contracts Issue\"\ndescription: File any issue related to the gateway-contracts component\ntitle: \"<issue_ty"
  },
  {
    "path": ".github/ISSUE_TEMPLATE/general_issue.yml",
    "chars": 1061,
    "preview": "name: \"General Issue\"\ndescription: File any issue related to any of the components\ntitle: \"<issue_type>(<component_name>"
  },
  {
    "path": ".github/actionlint.yaml",
    "chars": 612,
    "preview": "# Configuration related to self-hosted runner.\nself-hosted-runner:\n  # Labels of self-hosted runner in array of strings."
  },
  {
    "path": ".github/actions/gpu_setup/action.yml",
    "chars": 1457,
    "preview": "name: Setup Cuda\ndescription: Setup Cuda on Hyperstack or GitHub instance\n\ninputs:\n  cuda-version:\n    description: Vers"
  },
  {
    "path": ".github/config/commitlint.config.js",
    "chars": 1113,
    "preview": "const RuleConfigSeverity = require('@commitlint/types').RuleConfigSeverity;\nconst Configuration = {\n  /*\n   * Resolve an"
  },
  {
    "path": ".github/config/ct.yaml",
    "chars": 206,
    "preview": "# Configure ct (chart-testing)\n# See https://github.com/helm/chart-testing\nremote: origin\ntarget-branch: main\nchart-dirs"
  },
  {
    "path": ".github/dependabot.yml",
    "chars": 570,
    "preview": "version: 2\nupdates:\n  - package-ecosystem: \"cargo\"\n    # Look for `Cargo.toml` and `Cargo.lock` in the root directory\n  "
  },
  {
    "path": ".github/hooks/commit-msg",
    "chars": 578,
    "preview": "#!/bin/bash\n\n# Regular expression for Angular commit message convention\nCOMMIT_REGEX='^(feat|fix|docs|style|refactor|per"
  },
  {
    "path": ".github/hooks/install.sh",
    "chars": 625,
    "preview": "#!/bin/bash\n\n# Define the directory containing the custom hook scripts\nHOOKS_DIR=\"$(cd \"$(dirname \"${BASH_SOURCE[0]}\")\" "
  },
  {
    "path": ".github/hooks/pre-push",
    "chars": 422,
    "preview": "#!/bin/bash\n\n# Function to run a command and check its exit status\nrun_command() {\n  local cmd=\"$1\"\n  echo \"Running '$cm"
  },
  {
    "path": ".github/release.yml",
    "chars": 320,
    "preview": "changelog:\n  categories:\n    - title: Breaking Changes\n      labels:\n        - breaking-changes\n    - title: New feature"
  },
  {
    "path": ".github/squid/sandbox-proxy-rules.conf",
    "chars": 566,
    "preview": "# Strict domain allowlist for CI sandbox\n# Only these domains are reachable through the Squid proxy.\n# Based on: https:/"
  },
  {
    "path": ".github/workflows/charts-helm-checks.yml",
    "chars": 2761,
    "preview": "name: charts-helm-checks\n\non:\n  pull_request:\n\npermissions: {}\n\nenv:\n  HELM_VERSION: v3.16.4\n\njobs:\n  check-changes:\n   "
  },
  {
    "path": ".github/workflows/charts-helm-release.yml",
    "chars": 2842,
    "preview": "name: charts-helm-release\n\non:\n  push:\n    branches:\n      - main\n  workflow_dispatch:\n\npermissions: {}\n\nenv:\n  HELM_VER"
  },
  {
    "path": ".github/workflows/check-changes-for-docker-build.yml",
    "chars": 5131,
    "preview": "name: check-changes-for-docker-build\n\non:\n  workflow_call:\n    secrets:\n      GHCR_READ_TOKEN:\n        required: true\n  "
  },
  {
    "path": ".github/workflows/claude-review.yml",
    "chars": 25960,
    "preview": "name: claude-review\n\n# Triggered by @claude mention in PR comments.\n# The prompt is extracted as the text after \"@claude"
  },
  {
    "path": ".github/workflows/codeql.yml",
    "chars": 4287,
    "preview": "# For most projects, this workflow file will not need changing; you simply need\n# to commit it to your repository.\n#\n# Y"
  },
  {
    "path": ".github/workflows/common-pull-request-lint.yml",
    "chars": 1656,
    "preview": "name: common-pull-request\n\non:\n  pull_request:\n\nenv:\n  ACTIONLINT_VERSION: 1.7.10\n\npermissions: {}\n\njobs:\n  lint:\n    na"
  },
  {
    "path": ".github/workflows/common-typos-check.yml",
    "chars": 418,
    "preview": "name: common-typos-check\n\non:\n  pull_request:\n\npermissions: {}\n\njobs:\n  typos-check:\n    name: common-typos-check/typos "
  },
  {
    "path": ".github/workflows/contracts-upgrade-version-check.yml",
    "chars": 4488,
    "preview": "name: contracts-upgrade-version-check\n\npermissions: {}\n\non:\n  pull_request:\n\n# Compare PR bytecode against the last depl"
  },
  {
    "path": ".github/workflows/coprocessor-benchmark-cpu.yml",
    "chars": 9231,
    "preview": "# Run fhevm coprocessor benchmarks on a CPU instance and return parsed results to Slab.\nname: coprocessor-benchmarks-cpu"
  },
  {
    "path": ".github/workflows/coprocessor-benchmark-gpu.yml",
    "chars": 11250,
    "preview": "# Run all fhevm coprocessor benchmarks on a GPU instance on Hyperstack and return parsed results to Slab CI bot.\nname: c"
  },
  {
    "path": ".github/workflows/coprocessor-cargo-clippy.yml",
    "chars": 3092,
    "preview": "name: coprocessor-cargo-clippy\n\non:\n  pull_request:\n\npermissions: {}\n\nconcurrency:\n  group: ${{ github.workflow }}-${{ g"
  },
  {
    "path": ".github/workflows/coprocessor-cargo-fmt.yml",
    "chars": 1683,
    "preview": "name: coprocessor/cargo-fmt\n\non:\n  pull_request:\n\npermissions: {}\n\njobs:\n  check-changes:\n    name: trigger\n    permissi"
  },
  {
    "path": ".github/workflows/coprocessor-cargo-tests.yml",
    "chars": 7065,
    "preview": "name: coprocessor-cargo-test\n\non:\n  pull_request:\n\npermissions: {}\n\nconcurrency:\n  group: ${{ github.workflow }}-${{ git"
  },
  {
    "path": ".github/workflows/coprocessor-dependency-analysis.yml",
    "chars": 2522,
    "preview": "name: coprocessor-dependency-analysis\n\npermissions: {}\n\non:\n  pull_request:\n\nconcurrency:\n  group: fhevm-coprocessor-dep"
  },
  {
    "path": ".github/workflows/coprocessor-docker-build.yml",
    "chars": 22492,
    "preview": "name: coprocessor-docker-build\n\non:\n  release:\n    types:\n      - published\n  workflow_call:\n    inputs:\n      is_workfl"
  },
  {
    "path": ".github/workflows/coprocessor-gpu-tests.yml",
    "chars": 7931,
    "preview": "# Compile and test Coprocessor on a single L40 GPU, on hyperstack\nname: coprocessor-gpu-tests\n\npermissions: {}\n\nenv:\n  C"
  },
  {
    "path": ".github/workflows/coprocessor-stress-test-tool-docker-build.yml",
    "chars": 2668,
    "preview": "name: coprocessor-stress-test-tool-docker-build\n\non:\n  release:\n    types:\n      - published\n  workflow_dispatch:\n\npermi"
  },
  {
    "path": ".github/workflows/gateway-contracts-deployment-tests.yml",
    "chars": 7081,
    "preview": "name: gateway-contracts-deployment-tests\n\npermissions: {}\n\non:\n  pull_request:\n\nconcurrency:\n  group: ${{ github.workflo"
  },
  {
    "path": ".github/workflows/gateway-contracts-docker-build.yml",
    "chars": 3944,
    "preview": "name: gateway-contracts-docker-build\n\non:\n  workflow_call:\n    inputs:\n      is_workflow_call:\n        description: \"Ind"
  },
  {
    "path": ".github/workflows/gateway-contracts-hardhat-tests.yml",
    "chars": 1783,
    "preview": "# Run hardhat tests\nname: gateway-contracts-hardhat-tests\n\non:\n  pull_request:\n\npermissions: {}\n\nconcurrency:\n  group: c"
  },
  {
    "path": ".github/workflows/gateway-contracts-integrity-checks.yml",
    "chars": 2541,
    "preview": "# This workflow verifies that:\n# - The Rust bindings crate version and files are up-to-date\n# - Contract mocks and selec"
  },
  {
    "path": ".github/workflows/gateway-contracts-upgrade-tests.yml",
    "chars": 10041,
    "preview": "name: gateway-contracts-upgrade-tests\n\npermissions: {}\n\non:\n  pull_request:\n\nconcurrency:\n  group: ${{ github.workflow }"
  },
  {
    "path": ".github/workflows/gateway-stress-tool-docker-build.yml",
    "chars": 1429,
    "preview": "name: gateway-stress-tool-docker-build\n\non:\n  workflow_dispatch:\n\npermissions: {}\n\nconcurrency:\n  group: fhevm-gateway-s"
  },
  {
    "path": ".github/workflows/golden-container-images-docker-build-nodejs.yml",
    "chars": 2506,
    "preview": "name: golden-container-images-docker-build-nodejs\n\non:\n  workflow_dispatch:\n    inputs:\n      push_image:\n        descri"
  },
  {
    "path": ".github/workflows/golden-container-images-docker-build-rust.yml",
    "chars": 1932,
    "preview": "name: golden-container-images-docker-build-rust\n\non:\n  workflow_dispatch:\n    inputs:\n      push-image:\n        descript"
  },
  {
    "path": ".github/workflows/host-contracts-docker-build.yml",
    "chars": 3983,
    "preview": "name: host-contracts-docker-build\n\non:\n  workflow_call:\n    inputs:\n      is_workflow_call:\n        description: \"Indica"
  },
  {
    "path": ".github/workflows/host-contracts-docker-deployment-tests.yml",
    "chars": 3591,
    "preview": "name: host-contracts-docker-deployment-tests\n\npermissions: {}\n\non:\n  pull_request:\n\nconcurrency:\n  group: ${{ github.wor"
  },
  {
    "path": ".github/workflows/host-contracts-hardhat-forge-tests.yml",
    "chars": 2087,
    "preview": "name: host-contracts-hardhat-forge-tests\n\non:\n  pull_request:\n\npermissions: {}\n\njobs:\n  check-changes:\n    name: host-co"
  },
  {
    "path": ".github/workflows/host-contracts-integrity-checks.yml",
    "chars": 2311,
    "preview": "# This workflow verifies that:\n# - The Rust bindings crate version and files are up-to-date\n# - Contract mocks and selec"
  },
  {
    "path": ".github/workflows/host-contracts-publish.yml",
    "chars": 2124,
    "preview": "name: host-contracts-publish\n\non:\n  workflow_dispatch:\n    inputs:\n      release:\n        description: \"Set to true for "
  },
  {
    "path": ".github/workflows/host-contracts-slither-analysis.yml",
    "chars": 2455,
    "preview": "name: host-contracts-slither-analysis\n\n# The SARIF output is temporarily disabled.\non:\n  pull_request:\n    branches:\n   "
  },
  {
    "path": ".github/workflows/host-contracts-upgrade-tests.yml",
    "chars": 9914,
    "preview": "name: host-contracts-upgrade-tests\n\npermissions: {}\n\non:\n  pull_request:\n\nconcurrency:\n  group: ${{ github.workflow }}-$"
  },
  {
    "path": ".github/workflows/is-latest-commit.yml",
    "chars": 1223,
    "preview": "name: is-latest-commit\n\non:\n  workflow_call:\n    outputs:\n      is_latest:\n        description: \"Whether the current com"
  },
  {
    "path": ".github/workflows/kms-connector-dependency-analysis.yml",
    "chars": 2496,
    "preview": "name: kms-connector-dependency-analysis\n\npermissions: {}\n\non:\n  pull_request:\n\nconcurrency:\n  group: kms-connector-deps-"
  },
  {
    "path": ".github/workflows/kms-connector-docker-build.yml",
    "chars": 14876,
    "preview": "name: kms-connector-docker-build\n\non:\n  workflow_call:\n    inputs:\n      is_workflow_call:\n        description: \"Indicat"
  },
  {
    "path": ".github/workflows/kms-connector-tests.yml",
    "chars": 5737,
    "preview": "# Workflow running the tests of the KMS Connector components.\nname: kms-connector-tests\n\non:\n  pull_request:\n\nconcurrenc"
  },
  {
    "path": ".github/workflows/library-solidity-publish.yml",
    "chars": 2888,
    "preview": "name: library-solidity-publish\n\non:\n  workflow_dispatch:\n    inputs:\n      release:\n        description: \"Set to true fo"
  },
  {
    "path": ".github/workflows/library-solidity-tests.yml",
    "chars": 2978,
    "preview": "name: library-solidity-tests\n\non:\n  pull_request:\n\npermissions: {}\n\njobs:\n  check-changes:\n    permissions:\n      action"
  },
  {
    "path": ".github/workflows/re-tag-docker-image.yml",
    "chars": 2919,
    "preview": "name: re-tag-docker-image\n\non:\n  workflow_call:\n    inputs:\n      image-name:\n        description: 'The name of the imag"
  },
  {
    "path": ".github/workflows/sdk-rust-sdk-tests.yml",
    "chars": 5954,
    "preview": "# Workflow running the tests of the KMS Connector components.\nname: sdk-rust-sdk-tests\n\non:\n  pull_request:\n\nconcurrency"
  },
  {
    "path": ".github/workflows/test-suite-docker-build.yml",
    "chars": 3913,
    "preview": "name: test-suite-docker-build\n\non:\n  workflow_call:\n    inputs:\n      is_workflow_call:\n        description: \"Indicates "
  },
  {
    "path": ".github/workflows/test-suite-e2e-operators-tests.yml",
    "chars": 7186,
    "preview": "name: test-suite-e2e-operators-tests\n\n# Github does not support more than 10 inputs for workflow_dispatch:\n# https://doc"
  },
  {
    "path": ".github/workflows/test-suite-e2e-tests.yml",
    "chars": 10441,
    "preview": "name: test-suite-e2e-tests\n\non:\n  workflow_dispatch:\n    inputs: &workflow_inputs\n      coprocessor-db-migration-version"
  },
  {
    "path": ".github/workflows/test-suite-orchestrate-e2e-tests.yml",
    "chars": 9430,
    "preview": "name: test-suite-orchestrate-e2e-tests\n\non:\n  pull_request:\n    branches:\n      - main\n      - release/*\n\npermissions: {"
  },
  {
    "path": ".github/workflows/unverified_prs.yml",
    "chars": 1158,
    "preview": "# Close unverified PRs'\nname: unverified_prs\non:\n  schedule:\n    - cron: '30 1 * * *'\n\npermissions: {}\n\n# zizmor: ignore"
  },
  {
    "path": ".gitignore",
    "chars": 1597,
    "preview": "# General ignores\n#-------------------------------------------------------------------------------\n# Operating System fi"
  },
  {
    "path": ".hadolint.yaml",
    "chars": 63,
    "preview": "ignored:\n  - DL3002\n  - DL3007\n  - DL3008\n  - DL3018\n  - DL4006"
  },
  {
    "path": ".linkspector.yml",
    "chars": 158,
    "preview": "dirs:\n  - ./\naliveStatusCodes:\n  - 200\nignorePatterns:\n  - pattern: '^https?://localhost.*$'\n  - pattern: '^https://stac"
  },
  {
    "path": ".mergify.yml",
    "chars": 536,
    "preview": "queue_rules:\n  - name: main\n    batch_size: 3\n    batch_max_wait_time: 1h\n    checks_timeout: 12h\n    merge_method: squa"
  },
  {
    "path": ".npmrc",
    "chars": 347,
    "preview": "# Use shallow install strategy to prevent npm from hoisting all dependencies to the root.\n# This ensures packages like @"
  },
  {
    "path": ".prettierignore",
    "chars": 230,
    "preview": "# directories\n.coverage_artifacts\n.coverage_cache\n.coverage_contracts\nabi\nartifacts\nbuild\ncache\ncoverage\ndist\nrust_bindi"
  },
  {
    "path": ".prettierrc.yml",
    "chars": 599,
    "preview": "bracketSpacing: true\nplugins:\n  - \"@trivago/prettier-plugin-sort-imports\"\n  - \"prettier-plugin-solidity\"\nprintWidth: 120"
  },
  {
    "path": ".slither.config.json",
    "chars": 159,
    "preview": "{\n  \"solc_remaps\": [\"@openzeppelin/=node_modules/@openzeppelin/\"],\n  \"filter_paths\": \"host-contracts/node_modules/|host-"
  },
  {
    "path": "CODE_OF_CONDUCT.md",
    "chars": 5494,
    "preview": "# Contributor Covenant Code of Conduct\n\n## Our pledge\n\nWe as members, contributors, and leaders pledge to make participa"
  },
  {
    "path": "LICENSE",
    "chars": 1545,
    "preview": "BSD 3-Clause Clear License\n\nCopyright © 2025 ZAMA.\nAll rights reserved.\n\nRedistribution and use in source and binary for"
  },
  {
    "path": "README.md",
    "chars": 8686,
    "preview": "<p align=\"center\">\n<picture>\n  <source media=\"(prefers-color-scheme: dark)\" srcset=\"docs/.gitbook/assets/fhevm-header-da"
  },
  {
    "path": "SECURITY.md",
    "chars": 400,
    "preview": "# Security\n\n## Reporting a Vulnerability\n\nIf you find a security related bug in fhevm projects, we kindly ask you for re"
  },
  {
    "path": "charts/anvil-node/Chart.yaml",
    "chars": 130,
    "preview": "name: anvil-node\ndescription: A helm chart to deploy fhevm anvil node\nversion: 0.5.0\napiVersion: v2\nkeywords:\n  - fhevm\n"
  },
  {
    "path": "charts/anvil-node/templates/anvil-service.yaml",
    "chars": 250,
    "preview": "apiVersion: v1\nkind: Service\nmetadata:\n  name: {{ .Release.Name }}-anvil-node\nspec:\n  type: ClusterIP\n  selector:\n    ap"
  },
  {
    "path": "charts/anvil-node/templates/anvil-statefulset.yaml",
    "chars": 2036,
    "preview": "apiVersion: apps/v1\nkind: StatefulSet\nmetadata:\n  name: {{ .Release.Name }}-anvil-node\nspec:\n  serviceName: {{ .Release."
  },
  {
    "path": "charts/anvil-node/values.yaml",
    "chars": 835,
    "preview": "nameOverride:\n\nimage:\n  name: ghcr.io/foundry-rs/foundry\n  tag: stable\n\nnetwork:\n  blockTime: \"0.5\"\n  host: \"0.0.0.0\"\n  "
  },
  {
    "path": "charts/contracts/Chart.yaml",
    "chars": 150,
    "preview": "name: contracts\ndescription: A helm chart to manage fhevm Smart Contracts Deployment\nversion: 0.7.5\napiVersion: v2\nkeywo"
  },
  {
    "path": "charts/contracts/templates/_helpers.tpl",
    "chars": 615,
    "preview": "{{- define \"scVolumeName\" -}}\n{{- default .Release.Name .Values.persistence.volumeClaim.name }}\n{{- end -}}\n\n{{- define "
  },
  {
    "path": "charts/contracts/templates/sc-deploy-config.yaml",
    "chars": 4922,
    "preview": "apiVersion: v1\nkind: ConfigMap\nmetadata:\n  labels:\n    app: fhevm-sc-deploy\n    app.kubernetes.io/name: {{ .Release.Name"
  },
  {
    "path": "charts/contracts/templates/sc-deploy-job.yaml",
    "chars": 4846,
    "preview": "{{- if or .Values.scDeploy.enabled .Values.scUpgrade.enabled -}}\napiVersion: batch/v1\nkind: Job\nmetadata:\n  labels:\n    "
  },
  {
    "path": "charts/contracts/templates/sc-deploy-pvc.yaml",
    "chars": 482,
    "preview": "{{- if .Values.persistence.volumeClaim.create }}\n{{- $volumeName := include \"scVolumeName\" . }}\napiVersion: v1\nkind: Per"
  },
  {
    "path": "charts/contracts/templates/sc-deploy-statefulset.yaml",
    "chars": 3197,
    "preview": "{{- if .Values.scDebug.enabled }}\napiVersion: apps/v1\nkind: StatefulSet\nmetadata:\n  labels:\n    app: fhevm-sc-debug\n    "
  },
  {
    "path": "charts/contracts/values-deploy-protocol-payment.yaml",
    "chars": 2469,
    "preview": "# =============================================================================\n# FHEVM Smart Contracts Configuration\n# "
  },
  {
    "path": "charts/contracts/values-kmsgen.yaml",
    "chars": 5227,
    "preview": "# =============================================================================\n# FHEVM Smart Contracts Configuration\n# "
  },
  {
    "path": "charts/contracts/values-ownership.yaml",
    "chars": 2860,
    "preview": "# =============================================================================\n# FHEVM Smart Contracts Configuration\n# "
  },
  {
    "path": "charts/contracts/values.yaml",
    "chars": 6905,
    "preview": "# =============================================================================\n# FHEVM Smart Contracts Configuration\n# "
  },
  {
    "path": "charts/coprocessor/Chart.yaml",
    "chars": 168,
    "preview": "name: coprocessor\ndescription: A helm chart to distribute and deploy Zama fhevm Co-Processor services\nversion: 0.8.5\napi"
  },
  {
    "path": "charts/coprocessor/templates/_helpers.tpl",
    "chars": 1881,
    "preview": "{{- define \"tfheWorkerName\" -}}\n{{- $tfheWorkerNameDefault := printf \"%s-%s\" .Release.Name \"tfhe-worker\" }}\n{{- default "
  },
  {
    "path": "charts/coprocessor/templates/coprocessor-db-migration.yaml",
    "chars": 1824,
    "preview": "{{- if .Values.dbMigration.enabled }}\napiVersion: batch/v1\nkind: Job\nmetadata:\n  name: {{ .Release.Name }}-db-migration-"
  },
  {
    "path": "charts/coprocessor/templates/coprocessor-gw-listener-deployment.yaml",
    "chars": 2836,
    "preview": "{{- if .Values.gwListener.enabled -}}\napiVersion: apps/v1\nkind: Deployment\nmetadata:\n  labels:\n    app: coprocessor-gw-l"
  },
  {
    "path": "charts/coprocessor/templates/coprocessor-gw-listener-service-monitor.yaml",
    "chars": 441,
    "preview": "{{- if .Values.gwListener.serviceMonitor.enabled -}}\napiVersion: monitoring.coreos.com/v1\nkind: ServiceMonitor\nmetadata:"
  },
  {
    "path": "charts/coprocessor/templates/coprocessor-gw-listener-service.yaml",
    "chars": 577,
    "preview": "{{- if .Values.gwListener.enabled }}\napiVersion: v1\nkind: Service\nmetadata:\n  labels:\n    app: coprocessor-gw-listener\n "
  },
  {
    "path": "charts/coprocessor/templates/coprocessor-host-listener-catchup-only-deployment.yaml",
    "chars": 3537,
    "preview": "{{- if .Values.hostListenerCatchupOnly.enabled -}}\napiVersion: apps/v1\nkind: Deployment\nmetadata:\n  labels:\n    app: cop"
  },
  {
    "path": "charts/coprocessor/templates/coprocessor-host-listener-catchup-only-service-monitor.yaml",
    "chars": 524,
    "preview": "{{- if .Values.hostListenerCatchupOnly.serviceMonitor.enabled -}}\napiVersion: monitoring.coreos.com/v1\nkind: ServiceMoni"
  },
  {
    "path": "charts/coprocessor/templates/coprocessor-host-listener-catchup-only-service.yaml",
    "chars": 685,
    "preview": "{{- if .Values.hostListenerCatchupOnly.enabled }}\napiVersion: v1\nkind: Service\nmetadata:\n  labels:\n    app: coprocessor-"
  },
  {
    "path": "charts/coprocessor/templates/coprocessor-host-listener-deployment.yaml",
    "chars": 3155,
    "preview": "{{- if .Values.hostListener.enabled -}}\napiVersion: apps/v1\nkind: Deployment\nmetadata:\n  labels:\n    app: coprocessor-ho"
  },
  {
    "path": "charts/coprocessor/templates/coprocessor-host-listener-poller-deployment.yaml",
    "chars": 3370,
    "preview": "{{- if .Values.hostListenerPoller.enabled -}}\napiVersion: apps/v1\nkind: Deployment\nmetadata:\n  labels:\n    app: coproces"
  },
  {
    "path": "charts/coprocessor/templates/coprocessor-host-listener-poller-service-monitor.yaml",
    "chars": 492,
    "preview": "{{- if .Values.hostListenerPoller.serviceMonitor.enabled -}}\napiVersion: monitoring.coreos.com/v1\nkind: ServiceMonitor\nm"
  },
  {
    "path": "charts/coprocessor/templates/coprocessor-host-listener-poller-service.yaml",
    "chars": 643,
    "preview": "{{- if .Values.hostListenerPoller.enabled }}\napiVersion: v1\nkind: Service\nmetadata:\n  labels:\n    app: coprocessor-host-"
  },
  {
    "path": "charts/coprocessor/templates/coprocessor-host-listener-service-monitor.yaml",
    "chars": 453,
    "preview": "{{- if .Values.hostListener.serviceMonitor.enabled -}}\napiVersion: monitoring.coreos.com/v1\nkind: ServiceMonitor\nmetadat"
  },
  {
    "path": "charts/coprocessor/templates/coprocessor-host-listener-service.yaml",
    "chars": 593,
    "preview": "{{- if .Values.hostListener.enabled }}\napiVersion: v1\nkind: Service\nmetadata:\n  labels:\n    app: coprocessor-host-listen"
  },
  {
    "path": "charts/coprocessor/templates/coprocessor-init-config.yaml",
    "chars": 1358,
    "preview": "{{- if .Values.config.enabled }}\napiVersion: v1\nkind: ConfigMap\nmetadata:\n  name: {{ .Release.Name }}-init-config\n  name"
  },
  {
    "path": "charts/coprocessor/templates/coprocessor-init-job.yaml",
    "chars": 2778,
    "preview": "{{- if .Values.config.enabled }}\napiVersion: batch/v1\nkind: Job\nmetadata:\n  labels:\n    app: coprocessor-init-job\n    ap"
  },
  {
    "path": "charts/coprocessor/templates/coprocessor-sns-worker-deployment.yaml",
    "chars": 2803,
    "preview": "{{- if .Values.snsWorker.enabled -}}\napiVersion: apps/v1\nkind: Deployment\nmetadata:\n  labels:\n    app: coprocessor-sns-w"
  },
  {
    "path": "charts/coprocessor/templates/coprocessor-sns-worker-hpa.yaml",
    "chars": 831,
    "preview": "{{- if and .Values.snsWorker.hpa.enabled .Values.snsWorker.enabled }}\napiVersion: autoscaling/v2\nkind: HorizontalPodAuto"
  },
  {
    "path": "charts/coprocessor/templates/coprocessor-sns-worker-service-monitor.yaml",
    "chars": 435,
    "preview": "{{- if .Values.snsWorker.serviceMonitor.enabled -}}\napiVersion: monitoring.coreos.com/v1\nkind: ServiceMonitor\nmetadata:\n"
  },
  {
    "path": "charts/coprocessor/templates/coprocessor-sns-worker-service.yaml",
    "chars": 569,
    "preview": "{{- if .Values.snsWorker.enabled }}\napiVersion: v1\nkind: Service\nmetadata:\n  labels:\n    app: coprocessor-sns-worker\n   "
  },
  {
    "path": "charts/coprocessor/templates/coprocessor-tfhe-worker-deployment.yaml",
    "chars": 3623,
    "preview": "{{- if .Values.tfheWorker.enabled -}}\napiVersion: apps/v1\nkind: Deployment\nmetadata:\n  labels:\n    app: coprocessor-tfhe"
  },
  {
    "path": "charts/coprocessor/templates/coprocessor-tfhe-worker-hpa.yaml",
    "chars": 842,
    "preview": "{{- if and .Values.tfheWorker.hpa.enabled .Values.tfheWorker.enabled }}\napiVersion: autoscaling/v2\nkind: HorizontalPodAu"
  },
  {
    "path": "charts/coprocessor/templates/coprocessor-tfhe-worker-service-monitor.yaml",
    "chars": 441,
    "preview": "{{- if .Values.tfheWorker.serviceMonitor.enabled -}}\napiVersion: monitoring.coreos.com/v1\nkind: ServiceMonitor\nmetadata:"
  },
  {
    "path": "charts/coprocessor/templates/coprocessor-tfhe-worker-service.yaml",
    "chars": 576,
    "preview": "{{- if .Values.tfheWorker.enabled }}\napiVersion: v1\nkind: Service\nmetadata:\n  labels:\n    app: coprocessor-tfhe-worker\n "
  },
  {
    "path": "charts/coprocessor/templates/coprocessor-tx-sender-deployment.yaml",
    "chars": 2775,
    "preview": "{{- if .Values.txSender.enabled -}}\napiVersion: apps/v1\nkind: Deployment\nmetadata:\n  labels:\n    app: coprocessor-tx-sen"
  },
  {
    "path": "charts/coprocessor/templates/coprocessor-tx-sender-service-monitor.yaml",
    "chars": 429,
    "preview": "{{- if .Values.txSender.serviceMonitor.enabled -}}\napiVersion: monitoring.coreos.com/v1\nkind: ServiceMonitor\nmetadata:\n "
  },
  {
    "path": "charts/coprocessor/templates/coprocessor-tx-sender-service.yaml",
    "chars": 561,
    "preview": "{{- if .Values.txSender.enabled }}\napiVersion: v1\nkind: Service\nmetadata:\n  labels:\n    app: coprocessor-tx-sender\n    a"
  },
  {
    "path": "charts/coprocessor/templates/coprocessor-zkproof-worker-deployment.yaml",
    "chars": 2941,
    "preview": "{{- if .Values.zkProofWorker.enabled -}}\napiVersion: apps/v1\nkind: Deployment\nmetadata:\n  labels:\n    app: coprocessor-z"
  },
  {
    "path": "charts/coprocessor/templates/coprocessor-zkproof-worker-hpa.yaml",
    "chars": 875,
    "preview": "{{- if and .Values.zkProofWorker.hpa.enabled .Values.zkProofWorker.enabled }}\napiVersion: autoscaling/v2\nkind: Horizonta"
  },
  {
    "path": "charts/coprocessor/templates/coprocessor-zkproof-worker-service-monitor.yaml",
    "chars": 459,
    "preview": "{{- if .Values.zkProofWorker.serviceMonitor.enabled -}}\napiVersion: monitoring.coreos.com/v1\nkind: ServiceMonitor\nmetada"
  },
  {
    "path": "charts/coprocessor/templates/coprocessor-zkproof-worker-service.yaml",
    "chars": 601,
    "preview": "{{- if .Values.zkProofWorker.enabled }}\napiVersion: v1\nkind: Service\nmetadata:\n  labels:\n    app: coprocessor-zkproof-wo"
  },
  {
    "path": "charts/coprocessor/values.yaml",
    "chars": 26614,
    "preview": "# =============================================================================\n# FHEVM Coprocessor Configuration\n# ===="
  },
  {
    "path": "charts/coprocessor-sql-exporter/Chart.yaml",
    "chars": 260,
    "preview": "apiVersion: v2\nname: fhevm-sql-exporter\ndescription: A Helm chart for Kubernetes\ntype: application\nversion: 1.0.0\nappVer"
  },
  {
    "path": "charts/coprocessor-sql-exporter/config/config.yml",
    "chars": 2710,
    "preview": "# This configuration can be tested with https://github.com/justwatchcom/sql_exporter\n# Configuration reference: https://"
  },
  {
    "path": "charts/coprocessor-sql-exporter/templates/configmap.yaml",
    "chars": 148,
    "preview": "apiVersion: v1\nkind: ConfigMap\nmetadata:\n  name: coprocessor-sql-exporter-config\ndata:\n  config: |-\n{{ .Files.Get \"confi"
  },
  {
    "path": "charts/coprocessor-sql-exporter/values.yaml",
    "chars": 880,
    "preview": "prometheus-sql-exporter:\n  replicaCount: 1\n\n  image:\n    repository: ghcr.io/justwatchcom/sql_exporter\n    tag: \"v0.9\"\n\n"
  },
  {
    "path": "charts/kms-connector/Chart.yaml",
    "chars": 179,
    "preview": "name: kms-connector\ndescription: A helm chart to distribute and deploy the Zama KMS Connector services\nversion: 1.4.0\nap"
  },
  {
    "path": "charts/kms-connector/README.md",
    "chars": 9498,
    "preview": "# kms-connector\n\nA helm chart to distribute and deploy the Zama KMS Connector services.\n\n## Chart Details\n\nThis chart de"
  },
  {
    "path": "charts/kms-connector/templates/_helpers.tpl",
    "chars": 830,
    "preview": "{{- define \"kmsConnectorGwListenerName\" -}}\n{{- $kmsConnectorGwListenerNameDefault := printf \"%s-%s\" .Release.Name \"kms-"
  },
  {
    "path": "charts/kms-connector/templates/kms-connector-db-migration.yaml",
    "chars": 2593,
    "preview": "{{- if .Values.kmsConnectorDbMigration.enabled }}\napiVersion: batch/v1\nkind: Job\nmetadata:\n  name: {{ .Release.Name }}-k"
  },
  {
    "path": "charts/kms-connector/templates/kms-connector-gw-listener-deployment.yaml",
    "chars": 4439,
    "preview": "{{- if .Values.kmsConnectorGwListener.enabled -}}\napiVersion: apps/v1\nkind: Deployment\nmetadata:\n  labels:\n    app: kms-"
  },
  {
    "path": "charts/kms-connector/templates/kms-connector-gw-listener-service-monitor.yaml",
    "chars": 496,
    "preview": "{{- if .Values.kmsConnectorGwListener.serviceMonitor.enabled -}}\napiVersion: monitoring.coreos.com/v1\nkind: ServiceMonit"
  },
  {
    "path": "charts/kms-connector/templates/kms-connector-gw-listener-service.yaml",
    "chars": 541,
    "preview": "{{- if .Values.kmsConnectorGwListener.enabled }}\napiVersion: v1\nkind: Service\nmetadata:\n  labels:\n    app: kms-connector"
  },
  {
    "path": "charts/kms-connector/templates/kms-connector-kms-worker-deployment.yaml",
    "chars": 4687,
    "preview": "{{- if .Values.kmsConnectorKmsWorker.enabled -}}\napiVersion: apps/v1\nkind: Deployment\nmetadata:\n  labels:\n    app: kms-c"
  },
  {
    "path": "charts/kms-connector/templates/kms-connector-kms-worker-service-monitor.yaml",
    "chars": 490,
    "preview": "{{- if .Values.kmsConnectorKmsWorker.serviceMonitor.enabled -}}\napiVersion: monitoring.coreos.com/v1\nkind: ServiceMonito"
  },
  {
    "path": "charts/kms-connector/templates/kms-connector-kms-worker-service.yaml",
    "chars": 534,
    "preview": "{{- if .Values.kmsConnectorKmsWorker.enabled }}\napiVersion: v1\nkind: Service\nmetadata:\n  labels:\n    app: kms-connector-"
  },
  {
    "path": "charts/kms-connector/templates/kms-connector-tx-sender-deployment.yaml",
    "chars": 5071,
    "preview": "{{- if .Values.kmsConnectorTxSender.enabled -}}\napiVersion: apps/v1\nkind: Deployment\nmetadata:\n  labels:\n    app: kms-co"
  },
  {
    "path": "charts/kms-connector/templates/kms-connector-tx-sender-service-monitor.yaml",
    "chars": 484,
    "preview": "{{- if .Values.kmsConnectorTxSender.serviceMonitor.enabled -}}\napiVersion: monitoring.coreos.com/v1\nkind: ServiceMonitor"
  },
  {
    "path": "charts/kms-connector/templates/kms-connector-tx-sender-service.yaml",
    "chars": 527,
    "preview": "{{- if .Values.kmsConnectorTxSender.enabled }}\napiVersion: v1\nkind: Service\nmetadata:\n  labels:\n    app: kms-connector-t"
  },
  {
    "path": "charts/kms-connector/values.yaml",
    "chars": 8404,
    "preview": "# =============================================================================\n# KMS Connector Configuration\n# ========"
  },
  {
    "path": "ci/benchmark_parser.py",
    "chars": 16176,
    "preview": "\"\"\"\nbenchmark_parser\n----------------\n\nParse criterion benchmark or keys size results.\n\"\"\"\n\nimport argparse\nimport csv\ni"
  },
  {
    "path": "ci/check-upgrade-versions.ts",
    "chars": 5008,
    "preview": "#!/usr/bin/env bun\n// Checks that upgradeable contracts have proper version bumps when bytecode changes.\n// Usage: bun c"
  },
  {
    "path": "ci/contracts_bindings_update.py",
    "chars": 10752,
    "preview": "#!/usr/bin/env python3\n\nimport os\nimport json\nimport re\nimport shutil\nimport subprocess\nimport sys\nimport tempfile\nfrom "
  },
  {
    "path": "ci/ct.yaml",
    "chars": 206,
    "preview": "# Configure ct (chart-testing)\n# See https://github.com/helm/chart-testing\nremote: origin\ntarget-branch: main\nchart-dirs"
  },
  {
    "path": "ci/local_docs_link_check.py",
    "chars": 6120,
    "preview": "#!/bin/env python\n\"\"\"Check links to local files.\"\"\"\n\nimport json\nimport re\nimport sys\nimport tempfile\nfrom pathlib impor"
  },
  {
    "path": "ci/merge-address-constants.ts",
    "chars": 5417,
    "preview": "#!/usr/bin/env bun\n//\n// Merges Solidity address-constant files from a baseline and a PR so that both\n// sides can compi"
  },
  {
    "path": "ci/slab.toml",
    "chars": 1765,
    "preview": "[backend.hyperstack.single-h100]\nenvironment_name = \"canada\"\nimage_name = \"Ubuntu Server 22.04 LTS R535 CUDA 12.2\"\nflavo"
  },
  {
    "path": "coprocessor/.dockerignore",
    "chars": 16,
    "preview": "**/target\n.git/\n"
  },
  {
    "path": "coprocessor/.gitignore",
    "chars": 328,
    "preview": "# Ignore macOS system files\n.DS_Store\ndocs/.DS_Store\nfhevm-engine/.DS_Store\n\n# Common development files\nnode_modules/\nta"
  },
  {
    "path": "coprocessor/.gitmodules",
    "chars": 129,
    "preview": "[submodule \"contracts/lib/forge-std\"]\n\tpath = coprocessor/contracts/lib/forge-std\n\turl = https://github.com/foundry-rs/f"
  },
  {
    "path": "coprocessor/README.md",
    "chars": 11830,
    "preview": "## Introduction\n**FHEVM Coprocessor** provides the execution service for FHE computations.\n\nIt includes a **Coprocessor*"
  },
  {
    "path": "coprocessor/docs/README.md",
    "chars": 2898,
    "preview": "---\ndescription: >-\n  The FHEVM backend allows users to run their own L1 or coprocessor with FHEVM technology.\n  It enab"
  },
  {
    "path": "coprocessor/docs/SUMMARY.md",
    "chars": 2477,
    "preview": "# Table of contents\n\n- [Welcome to FHEVM](README.md)\n\n## Getting Started\n\n- [Quick start](getting_started/quick_start.md"
  },
  {
    "path": "coprocessor/docs/developer/contribute.md",
    "chars": 485,
    "preview": "# Contributing\n\nThere are two ways to contribute to the Zama FHEVM:\n\n- [Open issues](https://github.com/zama-ai/fhevm-ba"
  },
  {
    "path": "coprocessor/docs/developer/roadmap.md",
    "chars": 10,
    "preview": "# Roadmap\n"
  },
  {
    "path": "coprocessor/docs/fundamentals/fhevm/contracts.md",
    "chars": 3906,
    "preview": "# Diagram - FHEVM contracts on the host chain\n\n![FHEVM Contracts](../../assets/fhEVMContracts.png)\n\n# Contracts fundamen"
  },
  {
    "path": "coprocessor/docs/fundamentals/fhevm/coprocessor/architecture.md",
    "chars": 1669,
    "preview": "# Architecture\n\nThe following diagram shows an FHEVM-coprocessor that is integrated alongside an existing host blockchai"
  },
  {
    "path": "coprocessor/docs/fundamentals/fhevm/coprocessor/fhe_computation.md",
    "chars": 2445,
    "preview": "# FHE Computation\n\nBlock execution in FHEVM-coprocessor is split into two parts:\n\n- Symbolic Execution (onchain)\n- FHE C"
  },
  {
    "path": "coprocessor/docs/fundamentals/fhevm/inputs.md",
    "chars": 4890,
    "preview": "# Inputs\n\nWhen we talk about inputs, we refer to encrypted data users send to an FHEVM-native blockchain or an FHEVM-cop"
  },
  {
    "path": "coprocessor/docs/fundamentals/fhevm/native/architecture.md",
    "chars": 2320,
    "preview": "# Architecture\n\nThe following diagram shows an FHEVM-native blockchain with 4 validators.\n\n```mermaid\ngraph LR;\n    Vali"
  },
  {
    "path": "coprocessor/docs/fundamentals/fhevm/native/fhe_computation.md",
    "chars": 2986,
    "preview": "# FHE Computation\n\nBlock execution in FHEVM-native is split into two parts:\n\n- Symbolic Execution\n- FHE Computation\n\nSym"
  },
  {
    "path": "coprocessor/docs/fundamentals/fhevm/native/genesis.md",
    "chars": 615,
    "preview": "# Genesis\n\n## Contracts\n\nFor an FHEVM-native blockchain to operate and execute FHE computations, certain contracts need "
  },
  {
    "path": "coprocessor/docs/fundamentals/fhevm/native/storage.md",
    "chars": 1969,
    "preview": "# Storage\n\nCiphertexts in FHEVM-native are stored onchain in the storage of a predefined contract that has no code and i"
  },
  {
    "path": "coprocessor/docs/fundamentals/fhevm/symbolic_execution.md",
    "chars": 1751,
    "preview": "# Symbolic Execution\n\nSymbolic execution is a method of constructing a computational graph of FHE operations without act"
  },
  {
    "path": "coprocessor/docs/fundamentals/gateway/asc.md",
    "chars": 46,
    "preview": "# Decryption and reencryption request on TKMS\n"
  },
  {
    "path": "coprocessor/docs/fundamentals/gateway/decryption.md",
    "chars": 1381,
    "preview": "# Decryption\n\nEverything in FHEVM is encrypted, at some point one could need to decrypt some values. Let's give as illus"
  },
  {
    "path": "coprocessor/docs/fundamentals/gateway/proof.md",
    "chars": 716,
    "preview": "# Inclusion Proof\n\nThe execution layer in FHEVM can perform computations on ciphertexts. At some point, it becomes neces"
  },
  {
    "path": "coprocessor/docs/fundamentals/gateway/reencryption.md",
    "chars": 613,
    "preview": "# Reencryption\n\n\nReencryption is performed on the client side by calling the gateway service using the [fhevmjs](https:/"
  },
  {
    "path": "coprocessor/docs/fundamentals/glossary.md",
    "chars": 3213,
    "preview": "# Glossary\n\n- _Coprocessor_: An off-chain component in FHEVM-native that does the actual FHE computation.\n\n- _Executor_:"
  },
  {
    "path": "coprocessor/docs/fundamentals/overview.md",
    "chars": 4734,
    "preview": "# Overview\n\nAt the highest level, the system consists of two subsystems: an _fhEVM-native_ blockchain or an _fhEVM-copro"
  },
  {
    "path": "coprocessor/docs/fundamentals/tkms/architecture.md",
    "chars": 13165,
    "preview": "# Architecture\n\n![Threshold architecture](../../assets/threshold.png)\n![Central architecture](../../assets/threshold.png"
  },
  {
    "path": "coprocessor/docs/fundamentals/tkms/blockchain.md",
    "chars": 1406,
    "preview": "# Blockchain\nThe KMS blochhain is implemented using the Cosmos framework. More specifically with [Comet BFT](https://cos"
  },
  {
    "path": "coprocessor/docs/fundamentals/tkms/centralized.md",
    "chars": 1086,
    "preview": "# Centralized\n\nThe centralized realization is part of the same binary as the KMS Core. That is, it has very low overhead"
  },
  {
    "path": "coprocessor/docs/fundamentals/tkms/threshold.md",
    "chars": 2340,
    "preview": "# Threshold\n\nThe threshold realization is part of the same binary as the KMS Core, but `n` KMS Cores are running indepen"
  },
  {
    "path": "coprocessor/docs/fundamentals/tkms/zama.md",
    "chars": 2051,
    "preview": "# Zama's TKMS\n\nThe Key Management System (TKMS) is a self-contained service for performing sensitive cryptographic opera"
  },
  {
    "path": "coprocessor/docs/getting_started/fhevm/coprocessor/configuration.md",
    "chars": 1645,
    "preview": "# Configuration\n\n## Coprocessor Backend\n\n### Command Line\n\nYou can use the `--help` command line switch on the coprocess"
  },
  {
    "path": "coprocessor/docs/getting_started/fhevm/coprocessor/coprocessor_backend.md",
    "chars": 1322,
    "preview": "# Coprocessor Backend\n\nA Coprocessor backend is needed to run alongside the geth node. The Coprocessor backend executes "
  },
  {
    "path": "coprocessor/docs/getting_started/fhevm/native/configuration.md",
    "chars": 1529,
    "preview": "# Configuration\n\nAt the time of writing, FHEVM-native is still not fully implemented, namely the geth integration is not"
  },
  {
    "path": "coprocessor/docs/getting_started/fhevm/native/executor.md",
    "chars": 801,
    "preview": "# Executor\n\nAn FHEVM-native node consists of the following components:\n * full node/validator node\n * Executor service\n\n"
  },
  {
    "path": "coprocessor/docs/getting_started/fhevm/native/geth.md",
    "chars": 549,
    "preview": "# Integration\n\nThis document is a guide listing detailed steps to integrate `FHEVM-backend` into [go-ethereum](https://g"
  },
  {
    "path": "coprocessor/docs/getting_started/gateway/configuration.md",
    "chars": 3717,
    "preview": "# Configuration\n\nThe gateway acts as a bridge between the execution layer and the Threshold Key Management System (TKMS)"
  },
  {
    "path": "coprocessor/docs/getting_started/quick_start.md",
    "chars": 538,
    "preview": "# Quick start\n\nFor FHEVM-native, to start the setup, you can use our [demo repository](https://github.com/zama-ai/fhevm-"
  },
  {
    "path": "coprocessor/docs/getting_started/tkms/contract.md",
    "chars": 29,
    "preview": "# Application Smart Contract\n"
  },
  {
    "path": "coprocessor/docs/getting_started/tkms/create.md",
    "chars": 2225,
    "preview": "# Request the creation of a new private key\n\nGenerating a new set of keys and crs is necessary when creating a new FHE C"
  },
  {
    "path": "coprocessor/docs/getting_started/tkms/run.md",
    "chars": 12,
    "preview": "# Run a KMS\n"
  },
  {
    "path": "coprocessor/docs/getting_started/tkms/zama.md",
    "chars": 18,
    "preview": "# Use Zama's TKMS\n"
  },
  {
    "path": "coprocessor/docs/guides/benchmark.md",
    "chars": 18,
    "preview": "# Run a benchmark\n"
  },
  {
    "path": "coprocessor/docs/guides/hardware.md",
    "chars": 708,
    "preview": "# Node and gateway hardware\n\n## FHEVM validator\n\nValidators perform all operations on ciphertext, which requires powerfu"
  },
  {
    "path": "coprocessor/docs/references/fhevm_api.md",
    "chars": 27,
    "preview": "# FHEVM API specifications\n"
  },
  {
    "path": "coprocessor/docs/references/gateway_api.md",
    "chars": 19581,
    "preview": "# Gateway API Specifications\n\n## Endpoints\n\n<details>\n  <summary>GET /keyurl ---- Retrieve links for retrieving the publ"
  },
  {
    "path": "coprocessor/fhevm-engine/.cargo/audit.toml",
    "chars": 1239,
    "preview": "# All of the options which can be passed via CLI arguments can also be\n# permanently specified in this file.\n\n[advisorie"
  },
  {
    "path": "coprocessor/fhevm-engine/.cargo/deny.toml",
    "chars": 11159,
    "preview": "# This template contains all of the possible sections and their default values\n\n# Note that all fields that take a lint "
  },
  {
    "path": "coprocessor/fhevm-engine/.gitignore",
    "chars": 48,
    "preview": "target\n.cargo/advisory-db\n.cargo/advisory-db/**\n"
  },
  {
    "path": "coprocessor/fhevm-engine/.sqlx/query-00291bc0b863f2caf4c1f7b3fb9b07096422936f9260c363cc0b4c664c3e75fe.json",
    "chars": 400,
    "preview": "{\n  \"db_name\": \"PostgreSQL\",\n  \"query\": \"UPDATE ciphertext_digest\\n            SET ciphertext128 = $1, ciphertext128_for"
  },
  {
    "path": "coprocessor/fhevm-engine/.sqlx/query-0194202f1e08d10cc50aaa92568bb9bcbb219b722e4570198fd9b75d3adc9a85.json",
    "chars": 388,
    "preview": "{\n  \"db_name\": \"PostgreSQL\",\n  \"query\": \"SELECT pg_notify($1, '')\",\n  \"describe\": {\n    \"columns\": [\n      {\n        \"or"
  },
  {
    "path": "coprocessor/fhevm-engine/.sqlx/query-040ce7f040af75604989d052ab8ee348bd56ac4513659a03d52557e4a188f2f6.json",
    "chars": 511,
    "preview": "{\n  \"db_name\": \"PostgreSQL\",\n  \"query\": \"\\n        INSERT INTO ciphertext_digest (host_chain_id, key_id_gw, handle, ciph"
  },
  {
    "path": "coprocessor/fhevm-engine/.sqlx/query-048212909e0bbe46633e404235d2c5cffb5284903adb757b4fda59b7fbe81d57.json",
    "chars": 1942,
    "preview": "{\n  \"db_name\": \"PostgreSQL\",\n  \"query\": \"SELECT *\\n             FROM verify_proofs\\n             WHERE zk_proof_id = $1 "
  },
  {
    "path": "coprocessor/fhevm-engine/.sqlx/query-06757014537fbb4ab31dcfed5c16d384585a31bac9856aad1be27f3170535731.json",
    "chars": 497,
    "preview": "{\n  \"db_name\": \"PostgreSQL\",\n  \"query\": \"\\n            INSERT INTO keys(key_id, key_id_gw, pks_key, sks_key)\\n          "
  },
  {
    "path": "coprocessor/fhevm-engine/.sqlx/query-07ca385ea31d86b52ec49b021d2fa43287fd3bc162aa1a72a2bee5779357a86a.json",
    "chars": 482,
    "preview": "{\n  \"db_name\": \"PostgreSQL\",\n  \"query\": \"UPDATE ciphertext_digest\\n            SET\\n            txn_limited_retries_coun"
  },
  {
    "path": "coprocessor/fhevm-engine/.sqlx/query-081a15f82a405de28992b48a0bc989e47c62f841f3c642735ce468e8ac144a2d.json",
    "chars": 247,
    "preview": "{\n  \"db_name\": \"PostgreSQL\",\n  \"query\": \"NOTIFY new_host_block\",\n  \"describe\": {\n    \"columns\": [],\n    \"parameters\": {\n"
  }
]

// ... and 1360 more files (download for full content)