@fhevm/sdk 0.14.5 → 0.14.7-0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (252) hide show
  1. package/_cjs/core/_version.js +1 -1
  2. package/_cjs/core/_version.js.map +1 -1
  3. package/_cjs/core/actions/chain/fetchFheEncryptionKeyBytes.js +2 -1
  4. package/_cjs/core/actions/chain/fetchFheEncryptionKeyBytes.js.map +1 -1
  5. package/_cjs/core/chains/definitions/mainnet.js +3 -0
  6. package/_cjs/core/chains/definitions/mainnet.js.map +1 -1
  7. package/_cjs/core/chains/definitions/sepolia.js +3 -0
  8. package/_cjs/core/chains/definitions/sepolia.js.map +1 -1
  9. package/_cjs/core/clients/decorators/base.js.map +1 -1
  10. package/_cjs/core/clients/decorators/encrypt.js +4 -0
  11. package/_cjs/core/clients/decorators/encrypt.js.map +1 -1
  12. package/_cjs/core/coprocessor/ZkProofBuilder-p.js.map +1 -1
  13. package/_cjs/core/coprocessor/encrypt.js +5 -1
  14. package/_cjs/core/coprocessor/encrypt.js.map +1 -1
  15. package/_cjs/core/errors/FheEncryptionKeyVerificationError.js +14 -0
  16. package/_cjs/core/errors/FheEncryptionKeyVerificationError.js.map +1 -0
  17. package/_cjs/core/errors/FhevmErrorBase.js +0 -1
  18. package/_cjs/core/errors/FhevmErrorBase.js.map +1 -1
  19. package/_cjs/core/errors/RelayerErrorBase.js +0 -1
  20. package/_cjs/core/errors/RelayerErrorBase.js.map +1 -1
  21. package/_cjs/core/host-contracts/HostContractVersion-p.js +2 -0
  22. package/_cjs/core/host-contracts/HostContractVersion-p.js.map +1 -1
  23. package/_cjs/core/host-contracts/abi-fragments/fragments.js +50 -1
  24. package/_cjs/core/host-contracts/abi-fragments/fragments.js.map +1 -1
  25. package/_cjs/core/key/FheEncryptionKeyCache-p.js +50 -56
  26. package/_cjs/core/key/FheEncryptionKeyCache-p.js.map +1 -1
  27. package/_cjs/core/key/copyFheEncryptionKeyBytes-p.js +17 -0
  28. package/_cjs/core/key/copyFheEncryptionKeyBytes-p.js.map +1 -0
  29. package/_cjs/core/key/ensureFheEncryptionKeyDownload.js +134 -0
  30. package/_cjs/core/key/ensureFheEncryptionKeyDownload.js.map +1 -0
  31. package/_cjs/core/key/fetchFheEncryptionKey.js +4 -24
  32. package/_cjs/core/key/fetchFheEncryptionKey.js.map +1 -1
  33. package/_cjs/core/key/fetchFheEncryptionKeyBytes.js +2 -32
  34. package/_cjs/core/key/fetchFheEncryptionKeyBytes.js.map +1 -1
  35. package/_cjs/core/key/verifyFheEncryptionKeyBytes-p.js +245 -0
  36. package/_cjs/core/key/verifyFheEncryptionKeyBytes-p.js.map +1 -0
  37. package/_cjs/core/modules/encrypt/mock.js +7 -90
  38. package/_cjs/core/modules/encrypt/mock.js.map +1 -1
  39. package/_cjs/core/modules/encrypt/module/api-p.js +0 -65
  40. package/_cjs/core/modules/encrypt/module/api-p.js.map +1 -1
  41. package/_cjs/core/modules/encrypt/module/index.js +0 -3
  42. package/_cjs/core/modules/encrypt/module/index.js.map +1 -1
  43. package/_cjs/core/modules/relayer/cleartext/mock.js +1 -0
  44. package/_cjs/core/modules/relayer/cleartext/mock.js.map +1 -1
  45. package/_cjs/core/runtime/CoreFhevm-p.js +88 -11
  46. package/_cjs/core/runtime/CoreFhevm-p.js.map +1 -1
  47. package/_cjs/core/types/index.js.map +1 -1
  48. package/_cjs/ethers/clients/createFhevmDecryptClient.js +4 -1
  49. package/_cjs/ethers/clients/createFhevmDecryptClient.js.map +1 -1
  50. package/_cjs/viem/clients/createFhevmDecryptClient.js +4 -1
  51. package/_cjs/viem/clients/createFhevmDecryptClient.js.map +1 -1
  52. package/_cjs/wasm/tfhe/loadTfheLib.js.map +1 -1
  53. package/_cjs/wasm/tkms/loadKmsLib.js.map +1 -1
  54. package/_esm/core/_version.js +1 -1
  55. package/_esm/core/_version.js.map +1 -1
  56. package/_esm/core/actions/chain/fetchFheEncryptionKeyBytes.js +7 -1
  57. package/_esm/core/actions/chain/fetchFheEncryptionKeyBytes.js.map +1 -1
  58. package/_esm/core/chains/definitions/mainnet.js +3 -0
  59. package/_esm/core/chains/definitions/mainnet.js.map +1 -1
  60. package/_esm/core/chains/definitions/sepolia.js +3 -0
  61. package/_esm/core/chains/definitions/sepolia.js.map +1 -1
  62. package/_esm/core/clients/decorators/base.js.map +1 -1
  63. package/_esm/core/clients/decorators/encrypt-p.js +1 -1
  64. package/_esm/core/clients/decorators/encrypt-p.js.map +1 -1
  65. package/_esm/core/clients/decorators/encrypt.js +6 -0
  66. package/_esm/core/clients/decorators/encrypt.js.map +1 -1
  67. package/_esm/core/coprocessor/ZkProofBuilder-p.js +1 -1
  68. package/_esm/core/coprocessor/ZkProofBuilder-p.js.map +1 -1
  69. package/_esm/core/coprocessor/encrypt.js +5 -1
  70. package/_esm/core/coprocessor/encrypt.js.map +1 -1
  71. package/_esm/core/errors/FheEncryptionKeyVerificationError.js +15 -0
  72. package/_esm/core/errors/FheEncryptionKeyVerificationError.js.map +1 -0
  73. package/_esm/core/errors/FhevmErrorBase.js +0 -1
  74. package/_esm/core/errors/FhevmErrorBase.js.map +1 -1
  75. package/_esm/core/errors/RelayerErrorBase.js +0 -1
  76. package/_esm/core/errors/RelayerErrorBase.js.map +1 -1
  77. package/_esm/core/host-contracts/HostContractVersion-p.js +2 -1
  78. package/_esm/core/host-contracts/HostContractVersion-p.js.map +1 -1
  79. package/_esm/core/host-contracts/abi-fragments/fragments.js +61 -0
  80. package/_esm/core/host-contracts/abi-fragments/fragments.js.map +1 -1
  81. package/_esm/core/key/FheEncryptionKeyCache-p.js +91 -75
  82. package/_esm/core/key/FheEncryptionKeyCache-p.js.map +1 -1
  83. package/_esm/core/key/copyFheEncryptionKeyBytes-p.js +21 -0
  84. package/_esm/core/key/copyFheEncryptionKeyBytes-p.js.map +1 -0
  85. package/_esm/core/key/ensureFheEncryptionKeyDownload.js +213 -0
  86. package/_esm/core/key/ensureFheEncryptionKeyDownload.js.map +1 -0
  87. package/_esm/core/key/fetchFheEncryptionKey.js +6 -26
  88. package/_esm/core/key/fetchFheEncryptionKey.js.map +1 -1
  89. package/_esm/core/key/fetchFheEncryptionKeyBytes.js +4 -41
  90. package/_esm/core/key/fetchFheEncryptionKeyBytes.js.map +1 -1
  91. package/_esm/core/key/verifyFheEncryptionKeyBytes-p.js +345 -0
  92. package/_esm/core/key/verifyFheEncryptionKeyBytes-p.js.map +1 -0
  93. package/_esm/core/modules/encrypt/mock.js +7 -96
  94. package/_esm/core/modules/encrypt/mock.js.map +1 -1
  95. package/_esm/core/modules/encrypt/module/api-p.js +0 -71
  96. package/_esm/core/modules/encrypt/module/api-p.js.map +1 -1
  97. package/_esm/core/modules/encrypt/module/index.js +1 -4
  98. package/_esm/core/modules/encrypt/module/index.js.map +1 -1
  99. package/_esm/core/modules/relayer/cleartext/mock.js +1 -0
  100. package/_esm/core/modules/relayer/cleartext/mock.js.map +1 -1
  101. package/_esm/core/runtime/CoreFhevm-p.js +128 -15
  102. package/_esm/core/runtime/CoreFhevm-p.js.map +1 -1
  103. package/_esm/core/types/index.js.map +1 -1
  104. package/_esm/ethers/clients/createFhevmDecryptClient.js +5 -1
  105. package/_esm/ethers/clients/createFhevmDecryptClient.js.map +1 -1
  106. package/_esm/viem/clients/createFhevmDecryptClient.js +5 -1
  107. package/_esm/viem/clients/createFhevmDecryptClient.js.map +1 -1
  108. package/_types/core/_version.d.ts.map +1 -1
  109. package/_types/core/actions/chain/fetchFheEncryptionKeyBytes.d.ts +5 -0
  110. package/_types/core/actions/chain/fetchFheEncryptionKeyBytes.d.ts.map +1 -1
  111. package/_types/core/chains/definitions/mainnet.d.ts +3 -0
  112. package/_types/core/chains/definitions/mainnet.d.ts.map +1 -1
  113. package/_types/core/chains/definitions/sepolia.d.ts.map +1 -1
  114. package/_types/core/clients/decorators/base.d.ts +4 -1
  115. package/_types/core/clients/decorators/base.d.ts.map +1 -1
  116. package/_types/core/clients/decorators/encrypt.d.ts.map +1 -1
  117. package/_types/core/coprocessor/ZkProofBuilder-p.d.ts +2 -4
  118. package/_types/core/coprocessor/ZkProofBuilder-p.d.ts.map +1 -1
  119. package/_types/core/coprocessor/encrypt.d.ts +2 -8
  120. package/_types/core/coprocessor/encrypt.d.ts.map +1 -1
  121. package/_types/core/errors/FheEncryptionKeyVerificationError.d.ts +16 -0
  122. package/_types/core/errors/FheEncryptionKeyVerificationError.d.ts.map +1 -0
  123. package/_types/core/errors/FhevmErrorBase.d.ts.map +1 -1
  124. package/_types/core/errors/RelayerErrorBase.d.ts.map +1 -1
  125. package/_types/core/errors/TfheError.d.ts +1 -1
  126. package/_types/core/host-contracts/HostContractVersion-p.d.ts +4 -0
  127. package/_types/core/host-contracts/HostContractVersion-p.d.ts.map +1 -1
  128. package/_types/core/host-contracts/abi-fragments/fragments.d.ts +12 -0
  129. package/_types/core/host-contracts/abi-fragments/fragments.d.ts.map +1 -1
  130. package/_types/core/key/FheEncryptionKeyCache-p.d.ts +45 -21
  131. package/_types/core/key/FheEncryptionKeyCache-p.d.ts.map +1 -1
  132. package/_types/core/key/copyFheEncryptionKeyBytes-p.d.ts +9 -0
  133. package/_types/core/key/copyFheEncryptionKeyBytes-p.d.ts.map +1 -0
  134. package/_types/core/key/ensureFheEncryptionKeyDownload.d.ts +73 -0
  135. package/_types/core/key/ensureFheEncryptionKeyDownload.d.ts.map +1 -0
  136. package/_types/core/key/fetchFheEncryptionKey.d.ts +2 -4
  137. package/_types/core/key/fetchFheEncryptionKey.d.ts.map +1 -1
  138. package/_types/core/key/fetchFheEncryptionKeyBytes.d.ts +2 -4
  139. package/_types/core/key/fetchFheEncryptionKeyBytes.d.ts.map +1 -1
  140. package/_types/core/key/verifyFheEncryptionKeyBytes-p.d.ts +61 -0
  141. package/_types/core/key/verifyFheEncryptionKeyBytes-p.d.ts.map +1 -0
  142. package/_types/core/modules/encrypt/mock.d.ts +1 -4
  143. package/_types/core/modules/encrypt/mock.d.ts.map +1 -1
  144. package/_types/core/modules/encrypt/module/api-p.d.ts +1 -4
  145. package/_types/core/modules/encrypt/module/api-p.d.ts.map +1 -1
  146. package/_types/core/modules/encrypt/module/index.d.ts.map +1 -1
  147. package/_types/core/modules/encrypt/types.d.ts +2 -26
  148. package/_types/core/modules/encrypt/types.d.ts.map +1 -1
  149. package/_types/core/modules/relayer/cleartext/mock.d.ts.map +1 -1
  150. package/_types/core/modules/relayer/types.d.ts +9 -1
  151. package/_types/core/modules/relayer/types.d.ts.map +1 -1
  152. package/_types/core/runtime/CoreFhevm-p.d.ts +23 -1
  153. package/_types/core/runtime/CoreFhevm-p.d.ts.map +1 -1
  154. package/_types/core/types/coreFhevmClient.d.ts +31 -4
  155. package/_types/core/types/coreFhevmClient.d.ts.map +1 -1
  156. package/_types/core/types/fhevmChain.d.ts +7 -0
  157. package/_types/core/types/fhevmChain.d.ts.map +1 -1
  158. package/_types/core/types/hostContract.d.ts +1 -0
  159. package/_types/core/types/hostContract.d.ts.map +1 -1
  160. package/_types/core/types/index.d.ts +1 -0
  161. package/_types/core/types/index.d.ts.map +1 -1
  162. package/_types/core/types/zkProofBuilder-p.d.ts +2 -4
  163. package/_types/core/types/zkProofBuilder-p.d.ts.map +1 -1
  164. package/_types/ethers/cleartext/createFhevmCleartextBaseClient.d.ts +1 -1
  165. package/_types/ethers/cleartext/createFhevmCleartextBaseClient.d.ts.map +1 -1
  166. package/_types/ethers/cleartext/createFhevmCleartextClient.d.ts +1 -1
  167. package/_types/ethers/cleartext/createFhevmCleartextClient.d.ts.map +1 -1
  168. package/_types/ethers/cleartext/createFhevmCleartextDecryptClient.d.ts +1 -1
  169. package/_types/ethers/cleartext/createFhevmCleartextDecryptClient.d.ts.map +1 -1
  170. package/_types/ethers/cleartext/createFhevmCleartextEncryptClient.d.ts +1 -1
  171. package/_types/ethers/cleartext/createFhevmCleartextEncryptClient.d.ts.map +1 -1
  172. package/_types/ethers/clients/createFhevmBaseClient.d.ts +1 -1
  173. package/_types/ethers/clients/createFhevmBaseClient.d.ts.map +1 -1
  174. package/_types/ethers/clients/createFhevmClient.d.ts +2 -2
  175. package/_types/ethers/clients/createFhevmClient.d.ts.map +1 -1
  176. package/_types/ethers/clients/createFhevmDecryptClient.d.ts +2 -2
  177. package/_types/ethers/clients/createFhevmDecryptClient.d.ts.map +1 -1
  178. package/_types/ethers/clients/createFhevmEncryptClient.d.ts +2 -2
  179. package/_types/ethers/clients/createFhevmEncryptClient.d.ts.map +1 -1
  180. package/_types/viem/cleartext/createFhevmCleartextBaseClient.d.ts +1 -1
  181. package/_types/viem/cleartext/createFhevmCleartextBaseClient.d.ts.map +1 -1
  182. package/_types/viem/cleartext/createFhevmCleartextClient.d.ts +1 -1
  183. package/_types/viem/cleartext/createFhevmCleartextClient.d.ts.map +1 -1
  184. package/_types/viem/cleartext/createFhevmCleartextDecryptClient.d.ts +1 -1
  185. package/_types/viem/cleartext/createFhevmCleartextDecryptClient.d.ts.map +1 -1
  186. package/_types/viem/cleartext/createFhevmCleartextEncryptClient.d.ts +1 -1
  187. package/_types/viem/cleartext/createFhevmCleartextEncryptClient.d.ts.map +1 -1
  188. package/_types/viem/clients/createFhevmBaseClient.d.ts +1 -1
  189. package/_types/viem/clients/createFhevmBaseClient.d.ts.map +1 -1
  190. package/_types/viem/clients/createFhevmClient.d.ts +2 -2
  191. package/_types/viem/clients/createFhevmClient.d.ts.map +1 -1
  192. package/_types/viem/clients/createFhevmDecryptClient.d.ts +2 -2
  193. package/_types/viem/clients/createFhevmDecryptClient.d.ts.map +1 -1
  194. package/_types/viem/clients/createFhevmEncryptClient.d.ts +2 -2
  195. package/_types/viem/clients/createFhevmEncryptClient.d.ts.map +1 -1
  196. package/core/_version.ts +1 -1
  197. package/core/actions/chain/fetchFheEncryptionKeyBytes.ts +7 -1
  198. package/core/chains/definitions/mainnet.ts +3 -0
  199. package/core/chains/definitions/sepolia.ts +3 -0
  200. package/core/clients/decorators/base.ts +4 -1
  201. package/core/clients/decorators/encrypt-p.ts +1 -1
  202. package/core/clients/decorators/encrypt.ts +6 -0
  203. package/core/coprocessor/ZkProofBuilder-p.ts +3 -5
  204. package/core/coprocessor/encrypt.ts +10 -10
  205. package/core/errors/FheEncryptionKeyVerificationError.ts +27 -0
  206. package/core/errors/FhevmErrorBase.ts +0 -1
  207. package/core/errors/RelayerErrorBase.ts +0 -1
  208. package/core/errors/TfheError.ts +1 -1
  209. package/core/host-contracts/HostContractVersion-p.ts +2 -1
  210. package/core/host-contracts/abi-fragments/fragments.ts +69 -0
  211. package/core/key/FheEncryptionKeyCache-p.ts +92 -91
  212. package/core/key/copyFheEncryptionKeyBytes-p.ts +23 -0
  213. package/core/key/ensureFheEncryptionKeyDownload.ts +293 -0
  214. package/core/key/fetchFheEncryptionKey.ts +8 -35
  215. package/core/key/fetchFheEncryptionKeyBytes.ts +7 -56
  216. package/core/key/verifyFheEncryptionKeyBytes-p.ts +452 -0
  217. package/core/modules/encrypt/mock.ts +4 -149
  218. package/core/modules/encrypt/module/api-p.ts +1 -126
  219. package/core/modules/encrypt/module/index.ts +0 -12
  220. package/core/modules/encrypt/types.ts +2 -57
  221. package/core/modules/relayer/cleartext/mock.ts +1 -0
  222. package/core/modules/relayer/types.ts +9 -1
  223. package/core/runtime/CoreFhevm-p.ts +159 -21
  224. package/core/types/coreFhevmClient.ts +33 -4
  225. package/core/types/fhevmChain.ts +7 -0
  226. package/core/types/hostContract.ts +2 -0
  227. package/core/types/index.ts +1 -0
  228. package/core/types/zkProofBuilder-p.ts +2 -1
  229. package/ethers/cleartext/createFhevmCleartextBaseClient.ts +1 -1
  230. package/ethers/cleartext/createFhevmCleartextClient.ts +1 -1
  231. package/ethers/cleartext/createFhevmCleartextDecryptClient.ts +1 -1
  232. package/ethers/cleartext/createFhevmCleartextEncryptClient.ts +1 -1
  233. package/ethers/clients/createFhevmBaseClient.ts +1 -1
  234. package/ethers/clients/createFhevmClient.ts +2 -2
  235. package/ethers/clients/createFhevmDecryptClient.ts +7 -3
  236. package/ethers/clients/createFhevmEncryptClient.ts +2 -2
  237. package/package.json +1 -1
  238. package/viem/cleartext/createFhevmCleartextBaseClient.ts +1 -1
  239. package/viem/cleartext/createFhevmCleartextClient.ts +1 -1
  240. package/viem/cleartext/createFhevmCleartextDecryptClient.ts +1 -1
  241. package/viem/cleartext/createFhevmCleartextEncryptClient.ts +1 -1
  242. package/viem/clients/createFhevmBaseClient.ts +1 -1
  243. package/viem/clients/createFhevmClient.ts +2 -2
  244. package/viem/clients/createFhevmDecryptClient.ts +7 -3
  245. package/viem/clients/createFhevmEncryptClient.ts +2 -2
  246. package/_cjs/core/key/serializeFheEncryptionKey.js +0 -25
  247. package/_cjs/core/key/serializeFheEncryptionKey.js.map +0 -1
  248. package/_esm/core/key/serializeFheEncryptionKey.js +0 -24
  249. package/_esm/core/key/serializeFheEncryptionKey.js.map +0 -1
  250. package/_types/core/key/serializeFheEncryptionKey.d.ts +0 -6
  251. package/_types/core/key/serializeFheEncryptionKey.d.ts.map +0 -1
  252. package/core/key/serializeFheEncryptionKey.ts +0 -42
@@ -1,62 +1,35 @@
1
1
  import type { RelayerKeyUrlOptions } from '../types/relayer.js';
2
2
  import type { WithEncrypt } from '../types/coreFhevmRuntime.js';
3
3
  import type { FhevmChain } from '../types/fhevmChain.js';
4
+ import type { FhevmBase, OptionalNativeClient } from '../types/coreFhevmClient.js';
4
5
  import type { FheEncryptionKeyWasm } from '../types/fheEncryptionKey.js';
5
6
  import type { FhevmClientFrozenContext } from '../types/fhevmClientFrozenContext-p.js';
6
7
  import { deserializeFheEncryptionKey } from './deserializeFheEncryptionKey.js';
7
8
  import { globalFheEncryptionKeyCache } from './FheEncryptionKeyCache-p.js';
9
+ import { ensureFheEncryptionKeyDownload } from './ensureFheEncryptionKeyDownload.js';
8
10
 
9
11
  export async function fetchFheEncryptionKeyWasm(
10
- context: {
11
- readonly chain: FhevmChain;
12
- readonly runtime: WithEncrypt;
13
- },
12
+ context: FhevmBase<FhevmChain, WithEncrypt, OptionalNativeClient>,
14
13
  parameters: {
15
14
  readonly options?: RelayerKeyUrlOptions | undefined;
16
15
  readonly ignoreCache?: boolean | undefined;
17
16
  readonly fhevmContext: FhevmClientFrozenContext;
18
17
  },
19
18
  ): Promise<FheEncryptionKeyWasm> {
20
- const relayerUrl = context.chain.fhevm.relayerUrl;
21
19
  const runtime = context.runtime;
22
- const logger = runtime.config.logger;
23
20
 
24
- // Ensure a bytes fetch is in-flight
25
- globalFheEncryptionKeyCache.ensureBytes({
26
- owner: runtime,
27
- relayerUrl,
28
- fetcher: async () => {
29
- logger?.debug?.(
30
- `Fetching FHE encryption key/CRS bytes from relayer "${relayerUrl}" (chainId=${context.chain.id}).`,
31
- );
32
- try {
33
- const bytes = await runtime.relayer.fetchFheEncryptionKeyBytes(
34
- { relayerUrl, chainId: context.chain.id },
35
- parameters,
36
- );
37
- logger?.debug?.(`Fetched FHE encryption key/CRS bytes from relayer "${relayerUrl}".`);
38
- return bytes;
39
- } catch (e) {
40
- logger?.error?.(`Failed to fetch FHE encryption key/CRS bytes from relayer "${relayerUrl}".`, e);
41
- throw e;
42
- }
43
- },
44
- metadata: { chainId: context.chain.id, relayerUrl },
45
- });
21
+ // Download (or join the download), then check the key for this client
22
+ const { slot, entry } = await ensureFheEncryptionKeyDownload(context, parameters);
46
23
 
47
- // Upgrade bytes → wasm (chains from pending bytes if still in-flight)
24
+ // Upgrade bytes → wasm, on the entry checked (not the slot's current one)
48
25
  globalFheEncryptionKeyCache.ensureWasm({
49
26
  owner: runtime,
50
- relayerUrl,
27
+ slot,
28
+ entry,
51
29
  deserializeFn: (bytes) =>
52
30
  deserializeFheEncryptionKey(context, { keyBytes: bytes, fhevmContext: parameters.fhevmContext }),
53
31
  });
54
32
 
55
- const entry = globalFheEncryptionKeyCache.get(relayerUrl);
56
- if (entry === undefined) {
57
- throw new Error('Failed to fetch global FHE PKE params');
58
- }
59
-
60
33
  await entry.ready;
61
34
 
62
35
  if (entry.resolvedKind !== 'wasm') {
@@ -1,73 +1,24 @@
1
1
  import type { FhevmRuntime } from '../types/coreFhevmRuntime.js';
2
2
  import type { FhevmChain } from '../types/fhevmChain.js';
3
- import type { FheEncryptionKeyBytes, FheEncryptionKeyWasm } from '../types/fheEncryptionKey.js';
3
+ import type { FhevmBase, OptionalNativeClient } from '../types/coreFhevmClient.js';
4
+ import type { FheEncryptionKeyBytes } from '../types/fheEncryptionKey.js';
4
5
  import type { RelayerKeyUrlOptions } from '../types/relayer.js';
5
- import type { FetchFheEncryptionKeyBytesParameters } from '../modules/relayer/types.js';
6
6
  import type { FhevmClientFrozenContext } from '../types/fhevmClientFrozenContext-p.js';
7
- import { globalFheEncryptionKeyCache } from './FheEncryptionKeyCache-p.js';
8
- import { serializeFheEncryptionKeyWasm } from './serializeFheEncryptionKey.js';
9
- import { asFhevmRuntimeWith } from '../runtime/CoreFhevmRuntime-p.js';
7
+ import { ensureFheEncryptionKeyDownload } from './ensureFheEncryptionKeyDownload.js';
10
8
 
11
9
  ////////////////////////////////////////////////////////////////////////////////
12
10
 
13
11
  export async function fetchFheEncryptionKeyBytes(
14
- context: {
15
- readonly chain: FhevmChain;
16
- readonly runtime: FhevmRuntime;
17
- },
12
+ context: FhevmBase<FhevmChain, FhevmRuntime, OptionalNativeClient>,
18
13
  parameters: {
19
14
  readonly fhevmContext: FhevmClientFrozenContext;
20
15
  readonly options?: RelayerKeyUrlOptions | undefined;
21
16
  readonly ignoreCache?: boolean | undefined;
22
17
  },
23
18
  ): Promise<FheEncryptionKeyBytes> {
24
- const relayerUrl = context.chain.fhevm.relayerUrl;
25
- const runtime = context.runtime;
26
-
27
- // Caller-provided options override runtime config defaults (e.g. auth)
28
- const relayerParameters: FetchFheEncryptionKeyBytesParameters = {
29
- ...parameters,
30
- options: { auth: context.runtime.config.auth, ...parameters.options },
31
- };
32
-
33
- // Ensure a fetch is in-flight
34
- globalFheEncryptionKeyCache.ensureBytes({
35
- owner: runtime,
36
- relayerUrl,
37
- fetcher: () =>
38
- runtime.relayer.fetchFheEncryptionKeyBytes({ relayerUrl, chainId: context.chain.id }, relayerParameters),
39
- metadata: { chainId: context.chain.id, relayerUrl },
40
- });
41
-
42
- const bytes = await globalFheEncryptionKeyCache.resolveBytes({
43
- relayerUrl,
44
- serializeFn: _getSerializeFn(context),
45
- });
46
-
47
- if (bytes === undefined) {
48
- throw new Error('Failed to fetch global FHE PKE params bytes');
49
- }
19
+ // Download (or join the download), then check the key for this client:
20
+ // the bytes checked, not the slot's current ones
21
+ const { bytes } = await ensureFheEncryptionKeyDownload(context, parameters);
50
22
 
51
23
  return bytes;
52
24
  }
53
-
54
- /**
55
- * Returns a serialize function that converts wasm params to bytes,
56
- * or `undefined` if the encrypt module is not available on the runtime.
57
- */
58
- function _getSerializeFn(context: {
59
- readonly runtime: FhevmRuntime;
60
- }): ((args: FheEncryptionKeyWasm) => Promise<FheEncryptionKeyBytes>) | undefined {
61
- // Try to get a serialize fn if the encrypt module is available
62
- let serializeFn: ((args: FheEncryptionKeyWasm) => Promise<FheEncryptionKeyBytes>) | undefined;
63
-
64
- try {
65
- // check if the 'encrypt' module is available
66
- const r = asFhevmRuntimeWith(context.runtime, 'encrypt');
67
- serializeFn = (args) => serializeFheEncryptionKeyWasm({ runtime: r }, args);
68
- } catch {
69
- // encrypt module not available
70
- }
71
-
72
- return serializeFn;
73
- }
@@ -0,0 +1,452 @@
1
+ import type { FhevmRuntime } from '../types/coreFhevmRuntime.js';
2
+ import type { FhevmChain } from '../types/fhevmChain.js';
3
+ import type { FhevmBase, OptionalNativeClient, ResolvedFhevmOptions } from '../types/coreFhevmClient.js';
4
+ import type { FheEncryptionKeyBytes } from '../types/fheEncryptionKey.js';
5
+ import type { EthCallResult, TrustedClient } from '../modules/ethereum/types.js';
6
+ import type { BytesHex, ChecksummedAddress } from '../types/primitives.js';
7
+ import { keccak_256, shake256 } from '@noble/hashes/sha3.js';
8
+ import { addressToChecksummedAddress, asAddress } from '../base/address.js';
9
+ import { bytesToHex, bytesToHexNo0x, hexToBytes, unsafeBytesEquals } from '../base/bytes.js';
10
+ import { assertIsUint256 } from '../base/uint.js';
11
+ import { assertIsNonEmptyString } from '../base/string.js';
12
+ import { asCoreClientFhevm } from '../runtime/CoreFhevm-p.js';
13
+ import { assertIsHostContractVersionOf, parseVersion } from '../host-contracts/HostContractVersion-p.js';
14
+ import {
15
+ getActiveCrsIdAbi,
16
+ getActiveKeyIdAbi,
17
+ getCrsMaterialsAbi,
18
+ getKeyMaterialsAbi,
19
+ getVersionAbi,
20
+ } from '../host-contracts/abi-fragments/fragments.js';
21
+ import { ensureError } from '../base/errors/utils.js';
22
+ import { executeWithBatching } from '../base/promise.js';
23
+ import { FhevmConfigError } from '../errors/FhevmConfigError.js';
24
+ import { FheEncryptionKeyVerificationError } from '../errors/FheEncryptionKeyVerificationError.js';
25
+
26
+ ////////////////////////////////////////////////////////////////////////////////
27
+
28
+ type Context = FhevmBase<FhevmChain, FhevmRuntime, OptionalNativeClient>;
29
+
30
+ /** A `KMSGeneration` contract: Ethereum chain id and checksummed address. */
31
+ export type KmsGenerationRef = {
32
+ readonly chainId: number;
33
+ readonly address: ChecksummedAddress;
34
+ };
35
+
36
+ type KmsGenerationSource = KmsGenerationRef & {
37
+ readonly trustedClient: TrustedClient;
38
+ /** The `keyVerification` client: its chain id is checked before any of its results is trusted. */
39
+ readonly checkChainId: boolean;
40
+ };
41
+
42
+ type Digests = {
43
+ readonly publicKey: Uint8Array;
44
+ readonly crs: Uint8Array;
45
+ };
46
+
47
+ // IKMSGeneration.KeyType.Public
48
+ const KEY_TYPE_PUBLIC = 1;
49
+
50
+ // Domain separators the KMS prepends before hashing (SHAKE256, 32 bytes).
51
+ const PUBLIC_KEY_DIGEST_DOMAIN = new TextEncoder().encode('PDAT_KEY');
52
+ const CRS_DIGEST_DOMAIN = new TextEncoder().encode('PDAT_CRS');
53
+
54
+ // Selectors of the materials getters, to replay a failed read as a raw
55
+ // eth_call that tells a revert from a transport error. Derived from the ABI
56
+ // fragments the reads use, so the two cannot drift apart.
57
+ const GET_KEY_MATERIALS_SELECTOR = _selectorOf(getKeyMaterialsAbi);
58
+ const GET_CRS_MATERIALS_SELECTOR = _selectorOf(getCrsMaterialsAbi);
59
+
60
+ // The digests of each key / CRS bytes object, hashed once: clients sharing a
61
+ // downloaded key check it with their own reads, not their own hash.
62
+ const digestsByBytes = new WeakMap<FheEncryptionKeyBytes, Digests>();
63
+
64
+ ////////////////////////////////////////////////////////////////////////////////
65
+ // requiresKeyVerification
66
+ ////////////////////////////////////////////////////////////////////////////////
67
+
68
+ /**
69
+ * `false` only for a relayer module that skips the key check (see
70
+ * `skipsFheEncryptionKeyVerification`): every other key is checked.
71
+ */
72
+ export function requiresKeyVerification(runtime: FhevmRuntime): boolean {
73
+ return runtime.relayer.skipsFheEncryptionKeyVerification !== true;
74
+ }
75
+
76
+ ////////////////////////////////////////////////////////////////////////////////
77
+ // assertKeyVerificationConfig
78
+ ////////////////////////////////////////////////////////////////////////////////
79
+
80
+ /**
81
+ * Checks, without any RPC call, that the client can verify key material
82
+ * (see {@link resolveKmsGeneration}).
83
+ *
84
+ * @throws {FhevmConfigError}
85
+ */
86
+ export function assertKeyVerificationConfig(context: {
87
+ readonly chain: FhevmChain;
88
+ readonly options: ResolvedFhevmOptions;
89
+ }): void {
90
+ resolveKmsGeneration(context);
91
+ }
92
+
93
+ /**
94
+ * The `KMSGeneration` contract the client checks key material against, without
95
+ * any RPC call. It comes from the host chain definition (Ethereum) and/or
96
+ * `options.keyVerification.chain`: one is used as is, two must name the same
97
+ * contract. The address is checksummed, so equal contracts give equal values.
98
+ *
99
+ * @throws {FhevmConfigError} when there is none, when `keyVerification.chain`
100
+ * has none, or when the two disagree.
101
+ */
102
+ export function resolveKmsGeneration(context: {
103
+ readonly chain: FhevmChain;
104
+ readonly options: Pick<ResolvedFhevmOptions, 'keyVerification'>;
105
+ }): KmsGenerationRef {
106
+ const hostKmsGeneration = context.chain.fhevm.contracts.kmsGeneration;
107
+ const host =
108
+ hostKmsGeneration === undefined ? undefined : _kmsGenerationRef(context.chain.id, hostKmsGeneration.address);
109
+
110
+ const keyVerification = context.options.keyVerification;
111
+ let option: KmsGenerationRef | undefined;
112
+ if (keyVerification !== undefined) {
113
+ const kmsGeneration = keyVerification.chain.fhevm.contracts.kmsGeneration;
114
+ if (kmsGeneration === undefined) {
115
+ throw new FhevmConfigError({
116
+ message: `'options.keyVerification.chain' (chain ${keyVerification.chain.id}) has no KMSGeneration contract.`,
117
+ });
118
+ }
119
+ option = _kmsGenerationRef(keyVerification.chain.id, kmsGeneration.address);
120
+ }
121
+
122
+ const ref = host ?? option;
123
+ if (ref === undefined) {
124
+ throw new FhevmConfigError({
125
+ message:
126
+ `Chain ${context.chain.id} has no KMSGeneration contract to verify the FHE public key and CRS against: ` +
127
+ `set 'options.keyVerification' to { chain, client } with an Ethereum chain definition and a client ` +
128
+ `connected to Ethereum.`,
129
+ });
130
+ }
131
+ if (option !== undefined && (option.chainId !== ref.chainId || option.address !== ref.address)) {
132
+ throw new FhevmConfigError({
133
+ message:
134
+ `'options.keyVerification' names KMSGeneration ${option.address} on chain ${option.chainId}, but chain ` +
135
+ `${ref.chainId} has its own, ${ref.address}: remove 'options.keyVerification' or make it match.`,
136
+ });
137
+ }
138
+ return ref;
139
+ }
140
+
141
+ function _kmsGenerationRef(chainId: number, address: string): KmsGenerationRef {
142
+ return { chainId, address: addressToChecksummedAddress(asAddress(address)) };
143
+ }
144
+
145
+ ////////////////////////////////////////////////////////////////////////////////
146
+ // verifyFheEncryptionKeyBytes
147
+ ////////////////////////////////////////////////////////////////////////////////
148
+
149
+ /**
150
+ * Checks the FHE public key and CRS bytes against the active ones recorded in
151
+ * `KMSGeneration` on Ethereum, before they are used or cached:
152
+ *
153
+ * - id: a 32-byte hex id served by the relayer must equal the active id,
154
+ * checked as soon as the active ids are read;
155
+ * - digest: SHAKE256(`"PDAT_KEY"` ‖ public key bytes) must equal the active
156
+ * key's `Public` digest, SHAKE256(`"PDAT_CRS"` ‖ CRS bytes) the active CRS digest.
157
+ *
158
+ * @returns the same bytes, once verified.
159
+ * @throws {FheEncryptionKeyVerificationError} on a digest or id mismatch, when
160
+ * `KMSGeneration` has no active key or CRS (id 0), or when reading the active
161
+ * key or CRS materials reverts (e.g. `KeyNotGenerated`, `CrsNotGenerated`,
162
+ * `CrsAborted`; the read error is the `cause`).
163
+ * @throws {FhevmConfigError} on a misconfigured `keyVerification`.
164
+ * @throws {Error} on a malformed `KMSGeneration` result.
165
+ * @throws the client's own error on a network / RPC failure, unwrapped, as
166
+ * for any other contract read.
167
+ */
168
+ export async function verifyFheEncryptionKeyBytes(
169
+ context: Context,
170
+ bytes: FheEncryptionKeyBytes,
171
+ ): Promise<FheEncryptionKeyBytes> {
172
+ const source = _resolveKmsGenerationSource(context);
173
+ const batchRpcCalls = context.options.batchRpcCalls;
174
+
175
+ const read = (
176
+ abi: readonly [Record<string, unknown> & { readonly name: string }],
177
+ args: readonly unknown[],
178
+ ): Promise<unknown> =>
179
+ context.runtime.ethereum.readContract(source.trustedClient, {
180
+ address: source.address,
181
+ abi,
182
+ args,
183
+ functionName: abi[0].name,
184
+ });
185
+
186
+ // Round 1: chain id (keyVerification client only), version, active ids.
187
+ // The checks are shared: a read failing because of a wrong network or
188
+ // contract waits for them, so that cause is reported, not the read error.
189
+ let chainIdCheck: Promise<void> | undefined;
190
+ const checkChainId = (): Promise<void> => (chainIdCheck ??= _assertChainId(context, source));
191
+ let versionCheck: Promise<void> | undefined;
192
+ const checkVersion = (): Promise<void> =>
193
+ (versionCheck ??= _thenChecked(
194
+ _assertIsKmsGeneration(() => read(getVersionAbi, [])),
195
+ [checkChainId],
196
+ ));
197
+ const readActiveId = (abi: readonly [Record<string, unknown> & { readonly name: string }]): Promise<unknown> =>
198
+ _thenChecked(read(abi, []), [checkChainId, checkVersion]);
199
+
200
+ const [, , unknownKeyId, unknownCrsId] = await executeWithBatching<unknown>(
201
+ [checkChainId, checkVersion, () => readActiveId(getActiveKeyIdAbi), () => readActiveId(getActiveCrsIdAbi)],
202
+ batchRpcCalls,
203
+ );
204
+ assertIsUint256(unknownKeyId, {});
205
+ assertIsUint256(unknownCrsId, {});
206
+ const activeKeyId = BigInt(unknownKeyId);
207
+ const activeCrsId = BigInt(unknownCrsId);
208
+ _assertIsActive('FHE public key', activeKeyId);
209
+ _assertIsActive('CRS', activeCrsId);
210
+ // Before the materials reads: a wrong id needs no further RPC call.
211
+ _assertIdMatch('FHE public key', bytes.publicKeyBytes.id, activeKeyId);
212
+ _assertIdMatch('CRS', bytes.crsBytes.id, activeCrsId);
213
+
214
+ // Round 2: the active key and CRS materials.
215
+ const [keyMaterials, crsMaterials] = await executeWithBatching<unknown>(
216
+ [
217
+ () =>
218
+ _readMaterials(context, source, {
219
+ subject: 'FHE public key',
220
+ activeId: activeKeyId,
221
+ selector: GET_KEY_MATERIALS_SELECTOR,
222
+ readFn: () => read(getKeyMaterialsAbi, [activeKeyId]),
223
+ }),
224
+ () =>
225
+ _readMaterials(context, source, {
226
+ subject: 'CRS',
227
+ activeId: activeCrsId,
228
+ selector: GET_CRS_MATERIALS_SELECTOR,
229
+ readFn: () => read(getCrsMaterialsAbi, [activeCrsId]),
230
+ }),
231
+ ],
232
+ batchRpcCalls,
233
+ );
234
+
235
+ const expectedPublicKeyDigest = _parsePublicKeyDigest(keyMaterials);
236
+ const expectedCrsDigest = _parseCrsDigest(crsMaterials);
237
+
238
+ const digests = _digestsOf(bytes);
239
+ _assertDigestMatch('FHE public key', digests.publicKey, expectedPublicKeyDigest);
240
+ _assertDigestMatch('CRS', digests.crs, expectedCrsDigest);
241
+
242
+ context.runtime.config.logger?.debug?.(
243
+ `Verified FHE public key and CRS against KMSGeneration ${source.address} (keyId=0x${activeKeyId.toString(16)}, crsId=0x${activeCrsId.toString(16)}).`,
244
+ );
245
+
246
+ return bytes;
247
+ }
248
+
249
+ ////////////////////////////////////////////////////////////////////////////////
250
+
251
+ /**
252
+ * The KMSGeneration contract (see {@link resolveKmsGeneration}) and the client
253
+ * to read it with: the `keyVerification` client when set, else the host client
254
+ * (the contract is then on the host chain).
255
+ */
256
+ function _resolveKmsGenerationSource(context: Context): KmsGenerationSource {
257
+ const ref = resolveKmsGeneration(context);
258
+
259
+ const kv = context.options.keyVerification;
260
+ if (kv !== undefined) {
261
+ return { ...ref, trustedClient: kv.trustedClient, checkChainId: true };
262
+ }
263
+ if (context.client === undefined) {
264
+ throw new FhevmConfigError({
265
+ message: 'A host-chain client is required to verify the FHE public key and CRS against KMSGeneration.',
266
+ });
267
+ }
268
+ return { ...ref, trustedClient: asCoreClientFhevm(context).trustedClient, checkChainId: false };
269
+ }
270
+
271
+ /**
272
+ * On failure, runs the checks first: a failing check's error replaces the
273
+ * read error it explains.
274
+ */
275
+ async function _thenChecked<T>(promise: Promise<T>, checks: ReadonlyArray<() => Promise<void>>): Promise<T> {
276
+ try {
277
+ return await promise;
278
+ } catch (e) {
279
+ for (const check of checks) {
280
+ await check();
281
+ }
282
+ throw e;
283
+ }
284
+ }
285
+
286
+ /**
287
+ * Checks the `keyVerification` client's chain id (no-op for the host client).
288
+ *
289
+ * @throws {FhevmConfigError} when it is connected to another chain: a wrong
290
+ * network is a config error, not a key mismatch.
291
+ */
292
+ async function _assertChainId(context: Context, source: KmsGenerationSource): Promise<void> {
293
+ if (!source.checkChainId) {
294
+ return;
295
+ }
296
+ const chainId = await context.runtime.ethereum.getChainId(source.trustedClient);
297
+ if (chainId !== BigInt(source.chainId)) {
298
+ throw new FhevmConfigError({
299
+ message: `'options.keyVerification' client is connected to chain ${chainId}, but its chain definition is chain ${source.chainId}.`,
300
+ });
301
+ }
302
+ }
303
+
304
+ /**
305
+ * Checks that the contract is `KMSGeneration`. The version is read by each
306
+ * verification, on every chain, and never taken from or stored in the host
307
+ * contract version cache: the read runs alongside the chain id check, so a
308
+ * shared value could come from a client on the wrong network and fail every
309
+ * other client. The cost is one call per verification.
310
+ */
311
+ async function _assertIsKmsGeneration(readVersion: () => Promise<unknown>): Promise<void> {
312
+ const res = await readVersion();
313
+ assertIsNonEmptyString(res);
314
+ assertIsHostContractVersionOf(parseVersion(res), 'KMSGeneration');
315
+ }
316
+
317
+ // KMSGeneration returns id 0 when no key / CRS generation has completed.
318
+ function _assertIsActive(subject: string, activeId: bigint): void {
319
+ if (activeId === 0n) {
320
+ throw new FheEncryptionKeyVerificationError({
321
+ message: `No active ${subject} in KMSGeneration (active id is 0): the ${subject} cannot be verified.`,
322
+ });
323
+ }
324
+ }
325
+
326
+ /**
327
+ * KMSGeneration reverts (KeyNotGenerated, CrsNotGenerated, CrsAborted) when the
328
+ * active id has no usable materials: the key material cannot be verified.
329
+ *
330
+ * `readContract` errors do not tell a revert from a network / RPC failure, so
331
+ * a failed read is replayed as a raw `eth_call`, whose result does. Only a
332
+ * revert becomes a verification error; anything else rethrows the read error
333
+ * as is, like any other contract read.
334
+ */
335
+ async function _readMaterials(
336
+ context: Context,
337
+ source: KmsGenerationSource,
338
+ parameters: {
339
+ readonly subject: string;
340
+ readonly activeId: bigint;
341
+ readonly selector: BytesHex;
342
+ readonly readFn: () => Promise<unknown>;
343
+ },
344
+ ): Promise<unknown> {
345
+ const { subject, activeId, selector, readFn } = parameters;
346
+ try {
347
+ return await readFn();
348
+ } catch (e) {
349
+ const encodedId = context.runtime.ethereum.encode({ types: ['uint256'], values: [activeId] });
350
+ let result: EthCallResult;
351
+ try {
352
+ result = await context.runtime.ethereum.call(source.trustedClient, {
353
+ to: source.address,
354
+ data: `${selector}${encodedId.slice(2)}` as BytesHex,
355
+ });
356
+ } catch {
357
+ // Transport error: keep the read error.
358
+ throw e;
359
+ }
360
+ if (result.success) {
361
+ // Not a revert (e.g. a transient failure): keep the read error.
362
+ throw e;
363
+ }
364
+ throw new FheEncryptionKeyVerificationError({
365
+ message: `Cannot read the active ${subject} materials (id ${_formatId(activeId)}) from KMSGeneration, the call reverted (${result.reason}): the ${subject} cannot be verified.`,
366
+ cause: ensureError(e),
367
+ });
368
+ }
369
+ }
370
+
371
+ /**
372
+ * keccak256(`name(type,…)`)[0:4] of a single-function ABI fragment. Elementary
373
+ * input types only (as both getters take a `uint256`): a tuple would need its
374
+ * canonical `(…)` form.
375
+ */
376
+ function _selectorOf(abi: readonly [Record<string, unknown> & { readonly name: string }]): BytesHex {
377
+ const [fragment] = abi;
378
+ const types = (fragment.inputs as ReadonlyArray<{ readonly type: string }>).map((input) => input.type);
379
+ const signature = `${fragment.name}(${types.join(',')})`;
380
+ return bytesToHex(keccak_256(new TextEncoder().encode(signature)).subarray(0, 4));
381
+ }
382
+
383
+ function _formatId(id: bigint): string {
384
+ return `0x${id.toString(16).padStart(64, '0')}`;
385
+ }
386
+
387
+ function _parsePublicKeyDigest(keyMaterials: unknown): Uint8Array {
388
+ if (!Array.isArray(keyMaterials) || keyMaterials.length < 2 || !Array.isArray(keyMaterials[1])) {
389
+ throw new Error('Invalid KMSGeneration.getKeyMaterials result.');
390
+ }
391
+ for (const keyDigest of keyMaterials[1] as unknown[]) {
392
+ // viem decodes tuples as objects, ethers as array-like Results with named keys.
393
+ const { keyType, digest } = keyDigest as { readonly keyType: unknown; readonly digest: unknown };
394
+ if (Number(keyType) === KEY_TYPE_PUBLIC) {
395
+ if (typeof digest !== 'string') {
396
+ throw new Error('Invalid KMSGeneration public key digest.');
397
+ }
398
+ return hexToBytes(digest);
399
+ }
400
+ }
401
+ throw new FheEncryptionKeyVerificationError({
402
+ message: 'The active key in KMSGeneration has no public key digest.',
403
+ });
404
+ }
405
+
406
+ function _parseCrsDigest(crsMaterials: unknown): Uint8Array {
407
+ if (!Array.isArray(crsMaterials) || crsMaterials.length < 2 || typeof crsMaterials[1] !== 'string') {
408
+ throw new Error('Invalid KMSGeneration.getCrsMaterials result.');
409
+ }
410
+ return hexToBytes(crsMaterials[1]);
411
+ }
412
+
413
+ // A label id (e.g. "fhe-public-key-data-id", served by relayers today) is not compared, as the digest check already binds the bytes to the active key; to be made strict with the unified caching scheme.
414
+ function _assertIdMatch(subject: string, relayerId: string, activeId: bigint): void {
415
+ if (!/^0x[0-9a-fA-F]{64}$/.test(relayerId)) {
416
+ return;
417
+ }
418
+ if (BigInt(relayerId) !== activeId) {
419
+ throw new FheEncryptionKeyVerificationError({
420
+ message: `${subject} id mismatch: the relayer served ${relayerId}, but the active id in KMSGeneration is ${_formatId(activeId)}.`,
421
+ });
422
+ }
423
+ }
424
+
425
+ function _assertDigestMatch(subject: string, actual: Uint8Array, expected: Uint8Array): void {
426
+ if (!unsafeBytesEquals(actual, expected)) {
427
+ throw new FheEncryptionKeyVerificationError({
428
+ message: `${subject} digest mismatch: expected ${bytesToHexNo0x(expected)}, got ${bytesToHexNo0x(actual)}.`,
429
+ });
430
+ }
431
+ }
432
+
433
+ /** The key and CRS digests of `bytes`, memoized per bytes object. */
434
+ function _digestsOf(bytes: FheEncryptionKeyBytes): Digests {
435
+ let digests = digestsByBytes.get(bytes);
436
+ if (digests === undefined) {
437
+ digests = {
438
+ publicKey: _digest(PUBLIC_KEY_DIGEST_DOMAIN, bytes.publicKeyBytes.bytes),
439
+ crs: _digest(CRS_DIGEST_DOMAIN, bytes.crsBytes.bytes),
440
+ };
441
+ digestsByBytes.set(bytes, digests);
442
+ }
443
+ return digests;
444
+ }
445
+
446
+ /**
447
+ * SHAKE256(domain ‖ bytes), 32 bytes. One blocking call: ~140ms for the
448
+ * ~4.6MB CRS on desktop (~33ms/MiB with @noble/hashes), once per bytes object.
449
+ */
450
+ function _digest(domain: Uint8Array, bytes: Uint8Array): Uint8Array {
451
+ return shake256.create({ dkLen: 32 }).update(domain).update(bytes).digest();
452
+ }