@fhevm/sdk 0.14.5 → 0.14.6
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.
- package/_cjs/core/_version.js +1 -1
- package/_cjs/core/actions/chain/fetchFheEncryptionKeyBytes.js +2 -1
- package/_cjs/core/actions/chain/fetchFheEncryptionKeyBytes.js.map +1 -1
- package/_cjs/core/chains/definitions/mainnet.js +3 -0
- package/_cjs/core/chains/definitions/mainnet.js.map +1 -1
- package/_cjs/core/chains/definitions/sepolia.js +3 -0
- package/_cjs/core/chains/definitions/sepolia.js.map +1 -1
- package/_cjs/core/clients/decorators/base.js.map +1 -1
- package/_cjs/core/clients/decorators/encrypt.js +4 -0
- package/_cjs/core/clients/decorators/encrypt.js.map +1 -1
- package/_cjs/core/coprocessor/ZkProofBuilder-p.js.map +1 -1
- package/_cjs/core/coprocessor/encrypt.js +5 -1
- package/_cjs/core/coprocessor/encrypt.js.map +1 -1
- package/_cjs/core/errors/FheEncryptionKeyVerificationError.js +14 -0
- package/_cjs/core/errors/FheEncryptionKeyVerificationError.js.map +1 -0
- package/_cjs/core/errors/FhevmErrorBase.js +0 -1
- package/_cjs/core/errors/FhevmErrorBase.js.map +1 -1
- package/_cjs/core/errors/RelayerErrorBase.js +0 -1
- package/_cjs/core/errors/RelayerErrorBase.js.map +1 -1
- package/_cjs/core/host-contracts/HostContractVersion-p.js +2 -0
- package/_cjs/core/host-contracts/HostContractVersion-p.js.map +1 -1
- package/_cjs/core/host-contracts/abi-fragments/fragments.js +50 -1
- package/_cjs/core/host-contracts/abi-fragments/fragments.js.map +1 -1
- package/_cjs/core/key/FheEncryptionKeyCache-p.js +50 -56
- package/_cjs/core/key/FheEncryptionKeyCache-p.js.map +1 -1
- package/_cjs/core/key/copyFheEncryptionKeyBytes-p.js +17 -0
- package/_cjs/core/key/copyFheEncryptionKeyBytes-p.js.map +1 -0
- package/_cjs/core/key/ensureFheEncryptionKeyDownload.js +134 -0
- package/_cjs/core/key/ensureFheEncryptionKeyDownload.js.map +1 -0
- package/_cjs/core/key/fetchFheEncryptionKey.js +4 -24
- package/_cjs/core/key/fetchFheEncryptionKey.js.map +1 -1
- package/_cjs/core/key/fetchFheEncryptionKeyBytes.js +2 -32
- package/_cjs/core/key/fetchFheEncryptionKeyBytes.js.map +1 -1
- package/_cjs/core/key/verifyFheEncryptionKeyBytes-p.js +245 -0
- package/_cjs/core/key/verifyFheEncryptionKeyBytes-p.js.map +1 -0
- package/_cjs/core/modules/encrypt/mock.js +7 -90
- package/_cjs/core/modules/encrypt/mock.js.map +1 -1
- package/_cjs/core/modules/encrypt/module/api-p.js +0 -65
- package/_cjs/core/modules/encrypt/module/api-p.js.map +1 -1
- package/_cjs/core/modules/encrypt/module/index.js +0 -3
- package/_cjs/core/modules/encrypt/module/index.js.map +1 -1
- package/_cjs/core/modules/relayer/cleartext/mock.js +1 -0
- package/_cjs/core/modules/relayer/cleartext/mock.js.map +1 -1
- package/_cjs/core/runtime/CoreFhevm-p.js +88 -11
- package/_cjs/core/runtime/CoreFhevm-p.js.map +1 -1
- package/_cjs/core/types/index.js.map +1 -1
- package/_cjs/ethers/clients/createFhevmDecryptClient.js +4 -1
- package/_cjs/ethers/clients/createFhevmDecryptClient.js.map +1 -1
- package/_cjs/viem/clients/createFhevmDecryptClient.js +4 -1
- package/_cjs/viem/clients/createFhevmDecryptClient.js.map +1 -1
- package/_cjs/wasm/tfhe/loadTfheLib.js.map +1 -1
- package/_cjs/wasm/tkms/loadKmsLib.js.map +1 -1
- package/_esm/core/_version.js +1 -1
- package/_esm/core/actions/chain/fetchFheEncryptionKeyBytes.js +7 -1
- package/_esm/core/actions/chain/fetchFheEncryptionKeyBytes.js.map +1 -1
- package/_esm/core/chains/definitions/mainnet.js +3 -0
- package/_esm/core/chains/definitions/mainnet.js.map +1 -1
- package/_esm/core/chains/definitions/sepolia.js +3 -0
- package/_esm/core/chains/definitions/sepolia.js.map +1 -1
- package/_esm/core/clients/decorators/base.js.map +1 -1
- package/_esm/core/clients/decorators/encrypt-p.js +1 -1
- package/_esm/core/clients/decorators/encrypt-p.js.map +1 -1
- package/_esm/core/clients/decorators/encrypt.js +6 -0
- package/_esm/core/clients/decorators/encrypt.js.map +1 -1
- package/_esm/core/coprocessor/ZkProofBuilder-p.js +1 -1
- package/_esm/core/coprocessor/ZkProofBuilder-p.js.map +1 -1
- package/_esm/core/coprocessor/encrypt.js +5 -1
- package/_esm/core/coprocessor/encrypt.js.map +1 -1
- package/_esm/core/errors/FheEncryptionKeyVerificationError.js +15 -0
- package/_esm/core/errors/FheEncryptionKeyVerificationError.js.map +1 -0
- package/_esm/core/errors/FhevmErrorBase.js +0 -1
- package/_esm/core/errors/FhevmErrorBase.js.map +1 -1
- package/_esm/core/errors/RelayerErrorBase.js +0 -1
- package/_esm/core/errors/RelayerErrorBase.js.map +1 -1
- package/_esm/core/host-contracts/HostContractVersion-p.js +2 -1
- package/_esm/core/host-contracts/HostContractVersion-p.js.map +1 -1
- package/_esm/core/host-contracts/abi-fragments/fragments.js +61 -0
- package/_esm/core/host-contracts/abi-fragments/fragments.js.map +1 -1
- package/_esm/core/key/FheEncryptionKeyCache-p.js +91 -75
- package/_esm/core/key/FheEncryptionKeyCache-p.js.map +1 -1
- package/_esm/core/key/copyFheEncryptionKeyBytes-p.js +21 -0
- package/_esm/core/key/copyFheEncryptionKeyBytes-p.js.map +1 -0
- package/_esm/core/key/ensureFheEncryptionKeyDownload.js +213 -0
- package/_esm/core/key/ensureFheEncryptionKeyDownload.js.map +1 -0
- package/_esm/core/key/fetchFheEncryptionKey.js +6 -26
- package/_esm/core/key/fetchFheEncryptionKey.js.map +1 -1
- package/_esm/core/key/fetchFheEncryptionKeyBytes.js +4 -41
- package/_esm/core/key/fetchFheEncryptionKeyBytes.js.map +1 -1
- package/_esm/core/key/verifyFheEncryptionKeyBytes-p.js +345 -0
- package/_esm/core/key/verifyFheEncryptionKeyBytes-p.js.map +1 -0
- package/_esm/core/modules/encrypt/mock.js +7 -96
- package/_esm/core/modules/encrypt/mock.js.map +1 -1
- package/_esm/core/modules/encrypt/module/api-p.js +0 -71
- package/_esm/core/modules/encrypt/module/api-p.js.map +1 -1
- package/_esm/core/modules/encrypt/module/index.js +1 -4
- package/_esm/core/modules/encrypt/module/index.js.map +1 -1
- package/_esm/core/modules/relayer/cleartext/mock.js +1 -0
- package/_esm/core/modules/relayer/cleartext/mock.js.map +1 -1
- package/_esm/core/runtime/CoreFhevm-p.js +128 -15
- package/_esm/core/runtime/CoreFhevm-p.js.map +1 -1
- package/_esm/core/types/index.js.map +1 -1
- package/_esm/ethers/clients/createFhevmDecryptClient.js +5 -1
- package/_esm/ethers/clients/createFhevmDecryptClient.js.map +1 -1
- package/_esm/viem/clients/createFhevmDecryptClient.js +5 -1
- package/_esm/viem/clients/createFhevmDecryptClient.js.map +1 -1
- package/_types/core/actions/chain/fetchFheEncryptionKeyBytes.d.ts +5 -0
- package/_types/core/actions/chain/fetchFheEncryptionKeyBytes.d.ts.map +1 -1
- package/_types/core/chains/definitions/mainnet.d.ts +3 -0
- package/_types/core/chains/definitions/mainnet.d.ts.map +1 -1
- package/_types/core/chains/definitions/sepolia.d.ts.map +1 -1
- package/_types/core/clients/decorators/base.d.ts +4 -1
- package/_types/core/clients/decorators/base.d.ts.map +1 -1
- package/_types/core/clients/decorators/encrypt.d.ts.map +1 -1
- package/_types/core/coprocessor/ZkProofBuilder-p.d.ts +2 -4
- package/_types/core/coprocessor/ZkProofBuilder-p.d.ts.map +1 -1
- package/_types/core/coprocessor/encrypt.d.ts +2 -8
- package/_types/core/coprocessor/encrypt.d.ts.map +1 -1
- package/_types/core/errors/FheEncryptionKeyVerificationError.d.ts +16 -0
- package/_types/core/errors/FheEncryptionKeyVerificationError.d.ts.map +1 -0
- package/_types/core/errors/FhevmErrorBase.d.ts.map +1 -1
- package/_types/core/errors/RelayerErrorBase.d.ts.map +1 -1
- package/_types/core/errors/TfheError.d.ts +1 -1
- package/_types/core/host-contracts/HostContractVersion-p.d.ts +4 -0
- package/_types/core/host-contracts/HostContractVersion-p.d.ts.map +1 -1
- package/_types/core/host-contracts/abi-fragments/fragments.d.ts +12 -0
- package/_types/core/host-contracts/abi-fragments/fragments.d.ts.map +1 -1
- package/_types/core/key/FheEncryptionKeyCache-p.d.ts +45 -21
- package/_types/core/key/FheEncryptionKeyCache-p.d.ts.map +1 -1
- package/_types/core/key/copyFheEncryptionKeyBytes-p.d.ts +9 -0
- package/_types/core/key/copyFheEncryptionKeyBytes-p.d.ts.map +1 -0
- package/_types/core/key/ensureFheEncryptionKeyDownload.d.ts +73 -0
- package/_types/core/key/ensureFheEncryptionKeyDownload.d.ts.map +1 -0
- package/_types/core/key/fetchFheEncryptionKey.d.ts +2 -4
- package/_types/core/key/fetchFheEncryptionKey.d.ts.map +1 -1
- package/_types/core/key/fetchFheEncryptionKeyBytes.d.ts +2 -4
- package/_types/core/key/fetchFheEncryptionKeyBytes.d.ts.map +1 -1
- package/_types/core/key/verifyFheEncryptionKeyBytes-p.d.ts +61 -0
- package/_types/core/key/verifyFheEncryptionKeyBytes-p.d.ts.map +1 -0
- package/_types/core/modules/encrypt/mock.d.ts +1 -4
- package/_types/core/modules/encrypt/mock.d.ts.map +1 -1
- package/_types/core/modules/encrypt/module/api-p.d.ts +1 -4
- package/_types/core/modules/encrypt/module/api-p.d.ts.map +1 -1
- package/_types/core/modules/encrypt/module/index.d.ts.map +1 -1
- package/_types/core/modules/encrypt/types.d.ts +2 -26
- package/_types/core/modules/encrypt/types.d.ts.map +1 -1
- package/_types/core/modules/relayer/cleartext/mock.d.ts.map +1 -1
- package/_types/core/modules/relayer/types.d.ts +9 -1
- package/_types/core/modules/relayer/types.d.ts.map +1 -1
- package/_types/core/runtime/CoreFhevm-p.d.ts +23 -1
- package/_types/core/runtime/CoreFhevm-p.d.ts.map +1 -1
- package/_types/core/types/coreFhevmClient.d.ts +31 -4
- package/_types/core/types/coreFhevmClient.d.ts.map +1 -1
- package/_types/core/types/fhevmChain.d.ts +7 -0
- package/_types/core/types/fhevmChain.d.ts.map +1 -1
- package/_types/core/types/hostContract.d.ts +1 -0
- package/_types/core/types/hostContract.d.ts.map +1 -1
- package/_types/core/types/index.d.ts +1 -0
- package/_types/core/types/index.d.ts.map +1 -1
- package/_types/core/types/zkProofBuilder-p.d.ts +2 -4
- package/_types/core/types/zkProofBuilder-p.d.ts.map +1 -1
- package/_types/ethers/cleartext/createFhevmCleartextBaseClient.d.ts +1 -1
- package/_types/ethers/cleartext/createFhevmCleartextBaseClient.d.ts.map +1 -1
- package/_types/ethers/cleartext/createFhevmCleartextClient.d.ts +1 -1
- package/_types/ethers/cleartext/createFhevmCleartextClient.d.ts.map +1 -1
- package/_types/ethers/cleartext/createFhevmCleartextDecryptClient.d.ts +1 -1
- package/_types/ethers/cleartext/createFhevmCleartextDecryptClient.d.ts.map +1 -1
- package/_types/ethers/cleartext/createFhevmCleartextEncryptClient.d.ts +1 -1
- package/_types/ethers/cleartext/createFhevmCleartextEncryptClient.d.ts.map +1 -1
- package/_types/ethers/clients/createFhevmBaseClient.d.ts +1 -1
- package/_types/ethers/clients/createFhevmBaseClient.d.ts.map +1 -1
- package/_types/ethers/clients/createFhevmClient.d.ts +2 -2
- package/_types/ethers/clients/createFhevmClient.d.ts.map +1 -1
- package/_types/ethers/clients/createFhevmDecryptClient.d.ts +2 -2
- package/_types/ethers/clients/createFhevmDecryptClient.d.ts.map +1 -1
- package/_types/ethers/clients/createFhevmEncryptClient.d.ts +2 -2
- package/_types/ethers/clients/createFhevmEncryptClient.d.ts.map +1 -1
- package/_types/viem/cleartext/createFhevmCleartextBaseClient.d.ts +1 -1
- package/_types/viem/cleartext/createFhevmCleartextBaseClient.d.ts.map +1 -1
- package/_types/viem/cleartext/createFhevmCleartextClient.d.ts +1 -1
- package/_types/viem/cleartext/createFhevmCleartextClient.d.ts.map +1 -1
- package/_types/viem/cleartext/createFhevmCleartextDecryptClient.d.ts +1 -1
- package/_types/viem/cleartext/createFhevmCleartextDecryptClient.d.ts.map +1 -1
- package/_types/viem/cleartext/createFhevmCleartextEncryptClient.d.ts +1 -1
- package/_types/viem/cleartext/createFhevmCleartextEncryptClient.d.ts.map +1 -1
- package/_types/viem/clients/createFhevmBaseClient.d.ts +1 -1
- package/_types/viem/clients/createFhevmBaseClient.d.ts.map +1 -1
- package/_types/viem/clients/createFhevmClient.d.ts +2 -2
- package/_types/viem/clients/createFhevmClient.d.ts.map +1 -1
- package/_types/viem/clients/createFhevmDecryptClient.d.ts +2 -2
- package/_types/viem/clients/createFhevmDecryptClient.d.ts.map +1 -1
- package/_types/viem/clients/createFhevmEncryptClient.d.ts +2 -2
- package/_types/viem/clients/createFhevmEncryptClient.d.ts.map +1 -1
- package/core/_version.ts +1 -1
- package/core/actions/chain/fetchFheEncryptionKeyBytes.ts +7 -1
- package/core/chains/definitions/mainnet.ts +3 -0
- package/core/chains/definitions/sepolia.ts +3 -0
- package/core/clients/decorators/base.ts +4 -1
- package/core/clients/decorators/encrypt-p.ts +1 -1
- package/core/clients/decorators/encrypt.ts +6 -0
- package/core/coprocessor/ZkProofBuilder-p.ts +3 -5
- package/core/coprocessor/encrypt.ts +10 -10
- package/core/errors/FheEncryptionKeyVerificationError.ts +27 -0
- package/core/errors/FhevmErrorBase.ts +0 -1
- package/core/errors/RelayerErrorBase.ts +0 -1
- package/core/errors/TfheError.ts +1 -1
- package/core/host-contracts/HostContractVersion-p.ts +2 -1
- package/core/host-contracts/abi-fragments/fragments.ts +69 -0
- package/core/key/FheEncryptionKeyCache-p.ts +92 -91
- package/core/key/copyFheEncryptionKeyBytes-p.ts +23 -0
- package/core/key/ensureFheEncryptionKeyDownload.ts +293 -0
- package/core/key/fetchFheEncryptionKey.ts +8 -35
- package/core/key/fetchFheEncryptionKeyBytes.ts +7 -56
- package/core/key/verifyFheEncryptionKeyBytes-p.ts +452 -0
- package/core/modules/encrypt/mock.ts +4 -149
- package/core/modules/encrypt/module/api-p.ts +1 -126
- package/core/modules/encrypt/module/index.ts +0 -12
- package/core/modules/encrypt/types.ts +2 -57
- package/core/modules/relayer/cleartext/mock.ts +1 -0
- package/core/modules/relayer/types.ts +9 -1
- package/core/runtime/CoreFhevm-p.ts +159 -21
- package/core/types/coreFhevmClient.ts +33 -4
- package/core/types/fhevmChain.ts +7 -0
- package/core/types/hostContract.ts +2 -0
- package/core/types/index.ts +1 -0
- package/core/types/zkProofBuilder-p.ts +2 -1
- package/ethers/cleartext/createFhevmCleartextBaseClient.ts +1 -1
- package/ethers/cleartext/createFhevmCleartextClient.ts +1 -1
- package/ethers/cleartext/createFhevmCleartextDecryptClient.ts +1 -1
- package/ethers/cleartext/createFhevmCleartextEncryptClient.ts +1 -1
- package/ethers/clients/createFhevmBaseClient.ts +1 -1
- package/ethers/clients/createFhevmClient.ts +2 -2
- package/ethers/clients/createFhevmDecryptClient.ts +7 -3
- package/ethers/clients/createFhevmEncryptClient.ts +2 -2
- package/package.json +1 -1
- package/viem/cleartext/createFhevmCleartextBaseClient.ts +1 -1
- package/viem/cleartext/createFhevmCleartextClient.ts +1 -1
- package/viem/cleartext/createFhevmCleartextDecryptClient.ts +1 -1
- package/viem/cleartext/createFhevmCleartextEncryptClient.ts +1 -1
- package/viem/clients/createFhevmBaseClient.ts +1 -1
- package/viem/clients/createFhevmClient.ts +2 -2
- package/viem/clients/createFhevmDecryptClient.ts +7 -3
- package/viem/clients/createFhevmEncryptClient.ts +2 -2
- package/_cjs/core/key/serializeFheEncryptionKey.js +0 -25
- package/_cjs/core/key/serializeFheEncryptionKey.js.map +0 -1
- package/_esm/core/key/serializeFheEncryptionKey.js +0 -24
- package/_esm/core/key/serializeFheEncryptionKey.js.map +0 -1
- package/_types/core/key/serializeFheEncryptionKey.d.ts +0 -6
- package/_types/core/key/serializeFheEncryptionKey.d.ts.map +0 -1
- 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
|
-
//
|
|
25
|
-
|
|
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
|
|
24
|
+
// Upgrade bytes → wasm, on the entry checked (not the slot's current one)
|
|
48
25
|
globalFheEncryptionKeyCache.ensureWasm({
|
|
49
26
|
owner: runtime,
|
|
50
|
-
|
|
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 {
|
|
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 {
|
|
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
|
-
|
|
25
|
-
|
|
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
|
+
}
|