@fhevm/sdk 1.0.0-alpha.1 → 1.0.0-alpha.2

package/core/modules/relayer/cleartext/fetchDelegatedUserDecrypt.ts

@@ -0,0 +1,147 @@
+import type { BytesHex, ChecksummedAddress } from '../../../types/primitives.js';
+import type { FetchUserDecryptResultItem } from '../../../types/relayer.js';
+import type { CleartextEthereumModule } from '../../ethereum/types-ct.js';
+import type {
+  FetchDelegatedUserDecryptParameters,
+  FetchUserDecryptReturnType,
+  RelayerClientWithRuntime,
+} from '../types.js';
+import { remove0x } from '../../../base/string.js';
+import { asUint32BigInt, parseUintBigIntString, randomUniqueUints } from '../../../base/uint.js';
+import { getTrustedClient } from '../../../runtime/CoreFhevm-p.js';
+import { userDecryptResultToKmsSigncryptedShares } from '../utils.js';
+import { getKmsSignersPrivateKeyMap } from './signers.js';
+
+////////////////////////////////////////////////////////////////////////////////
+
+const delegatedUserDecryptAbi = [
+  {
+    type: 'function',
+    name: 'delegatedUserDecrypt',
+    inputs: [
+      {
+        name: 'pairs',
+        type: 'tuple[]',
+        internalType: 'struct HandleContractPair[]',
+        components: [
+          { name: 'handle', type: 'bytes32', internalType: 'bytes32' },
+          {
+            name: 'contractAddress',
+            type: 'address',
+            internalType: 'address',
+          },
+        ],
+      },
+      { name: 'delegator', type: 'address', internalType: 'address' },
+      { name: 'delegate', type: 'address', internalType: 'address' },
+      { name: 'publicKey', type: 'bytes', internalType: 'bytes' },
+      {
+        name: 'contractAddresses',
+        type: 'address[]',
+        internalType: 'address[]',
+      },
+      {
+        name: 'startTimestamp',
+        type: 'uint256',
+        internalType: 'uint256',
+      },
+      {
+        name: 'durationDays',
+        type: 'uint256',
+        internalType: 'uint256',
+      },
+      { name: 'delegateSignature', type: 'bytes', internalType: 'bytes' },
+    ],
+    outputs: [
+      { name: 'payload', type: 'bytes', internalType: 'bytes' },
+      { name: 'signers', type: 'address[]', internalType: 'address[]' },
+      { name: 'threshold', type: 'uint256', internalType: 'uint256' },
+      { name: 'extraData', type: 'bytes', internalType: 'bytes' },
+    ],
+    stateMutability: 'view',
+  },
+] as const;
+
+////////////////////////////////////////////////////////////////////////////////
+
+export async function fetchDelegatedUserDecrypt(
+  relayerClient: RelayerClientWithRuntime,
+  parameters: FetchDelegatedUserDecryptParameters,
+): Promise<FetchUserDecryptReturnType> {
+  const cleartextEthereumModule = relayerClient.runtime.ethereum as CleartextEthereumModule;
+  const { payload } = parameters;
+  const pairs = payload.handleContractPairs;
+  const contractAddresses = payload.kmsDecryptEip712Message.contractAddresses;
+
+  const authCount = contractAddresses.length;
+  for (const { contractAddress: c } of pairs) {
+    let authorized: boolean = false;
+    for (let i = 0; i < authCount; ++i) {
+      if (contractAddresses[i] == c) {
+        authorized = true;
+        break;
+      }
+    }
+    if (!authorized) {
+      throw new Error(`ContractAddressNotAuthorized: ${c} is not in the EIP-712 authorized contractAddresses list.`);
+    }
+  }
+
+  const { kmsDecryptEip712Message, kmsDecryptEip712Signer, kmsDecryptEip712Signature } = payload;
+  const trustedClient = getTrustedClient(relayerClient);
+  const res = (await relayerClient.runtime.ethereum.readContract(trustedClient, {
+    abi: delegatedUserDecryptAbi,
+    address: relayerClient.chain.fhevm.contracts.kmsVerifier.address as ChecksummedAddress,
+    args: [
+      pairs.map((p) => ({
+        handle: p.handle.bytes32Hex,
+        contractAddress: p.contractAddress,
+      })),
+      kmsDecryptEip712Message.delegatorAddress,
+      kmsDecryptEip712Signer,
+      kmsDecryptEip712Message.publicKey,
+      kmsDecryptEip712Message.contractAddresses,
+      _parseUintBigIntString('kmsDecryptEip712Message.startTimestamp', kmsDecryptEip712Message.startTimestamp),
+      _parseUintBigIntString('kmsDecryptEip712Message.durationDays', kmsDecryptEip712Message.durationDays),
+      kmsDecryptEip712Signature,
+    ],
+    functionName: delegatedUserDecryptAbi[0].name,
+  })) as unknown[];
+
+  const commonKmsSigncryptedSharePayload = res[0] as BytesHex;
+  const commonKmsSigncryptedSharePayloadNo0x = remove0x(commonKmsSigncryptedSharePayload);
+  const signersAddress = res[1] as readonly ChecksummedAddress[];
+  const threshold = asUint32BigInt(res[2]);
+  const extraData = res[3] as BytesHex;
+
+  const signers = getKmsSignersPrivateKeyMap(relayerClient);
+
+  const randomSignersAddress = randomUniqueUints(signersAddress.length, Number(threshold)).map(
+    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+    (i) => signersAddress[i]!,
+  );
+
+  const result: FetchUserDecryptResultItem[] = [];
+
+  for (const signerAddress of randomSignersAddress) {
+    const privateKey = signers.get(signerAddress);
+    if (privateKey === undefined) {
+      throw new Error(`Unable to find KMS signer for address ${signerAddress}`);
+    }
+
+    const signature = await cleartextEthereumModule.sign({ hash: commonKmsSigncryptedSharePayload, privateKey });
+    result.push({ signature: remove0x(signature), payload: commonKmsSigncryptedSharePayloadNo0x, extraData });
+  }
+
+  return userDecryptResultToKmsSigncryptedShares(result);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+function _parseUintBigIntString(label: string, value: string): bigint {
+  const bn = parseUintBigIntString(value);
+  if (bn === undefined) {
+    throw new Error(`${label} is not a valid uint string, got ${JSON.stringify(value)}`);
+  }
+  return bn;
+}

package/core/modules/relayer/cleartext/fetchPublicDecrypt.ts

@@ -0,0 +1,67 @@
+import type { Bytes32Hex, Bytes65Hex, BytesHex, ChecksummedAddress } from '../../../types/primitives.js';
+import type { CleartextEthereumModule } from '../../ethereum/types-ct.js';
+import type { FetchPublicDecryptParameters, FetchPublicDecryptReturnType, RelayerClientWithRuntime } from '../types.js';
+import { getTrustedClient } from '../../../runtime/CoreFhevm-p.js';
+import { getKmsSignersPrivateKeyMap } from './signers.js';
+
+////////////////////////////////////////////////////////////////////////////////
+
+const publicDecryptAbi = [
+  {
+    type: 'function',
+    name: 'publicDecrypt',
+    inputs: [{ name: 'handles', type: 'bytes32[]', internalType: 'bytes32[]' }],
+    outputs: [
+      {
+        name: 'abiEncodedCleartexts',
+        type: 'bytes',
+        internalType: 'bytes',
+      },
+      { name: 'digest', type: 'bytes32', internalType: 'bytes32' },
+      { name: 'signers', type: 'address[]', internalType: 'address[]' },
+      { name: 'threshold', type: 'uint256', internalType: 'uint256' },
+      { name: 'extraData', type: 'bytes', internalType: 'bytes' },
+    ],
+    stateMutability: 'view',
+  },
+] as const;
+
+////////////////////////////////////////////////////////////////////////////////
+
+export async function fetchPublicDecrypt(
+  relayerClient: RelayerClientWithRuntime,
+  parameters: FetchPublicDecryptParameters,
+): Promise<FetchPublicDecryptReturnType> {
+  const cleartextEthereumModule = relayerClient.runtime.ethereum as CleartextEthereumModule;
+
+  const trustedClient = getTrustedClient(relayerClient);
+  const res = (await relayerClient.runtime.ethereum.readContract(trustedClient, {
+    abi: publicDecryptAbi,
+    address: relayerClient.chain.fhevm.contracts.kmsVerifier.address as ChecksummedAddress,
+    args: [parameters.payload.orderedHandles.map((h) => h.bytes32Hex)],
+    functionName: publicDecryptAbi[0].name,
+  })) as unknown[];
+
+  const digest = res[1] as Bytes32Hex;
+  const signersAddress = res[2] as readonly ChecksummedAddress[];
+  const signers = getKmsSignersPrivateKeyMap(relayerClient);
+
+  const kmsPublicDecryptEIP712Signatures: Bytes65Hex[] = [];
+
+  for (let i = 0; i < signersAddress.length; ++i) {
+    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+    const privateKey = signers.get(signersAddress[i]!);
+    if (privateKey === undefined) {
+      throw new Error('Unable to find kms signer');
+    }
+
+    const signature = await cleartextEthereumModule.sign({ hash: digest, privateKey });
+    kmsPublicDecryptEIP712Signatures.push(signature);
+  }
+
+  return {
+    orderedAbiEncodedClearValues: res[0] as BytesHex,
+    kmsPublicDecryptEIP712Signatures,
+    extraData: res[4] as BytesHex,
+  };
+}

package/core/modules/relayer/cleartext/fetchUserDecrypt.ts

@@ -0,0 +1,141 @@
+import type { BytesHex, ChecksummedAddress } from '../../../types/primitives.js';
+import type { FetchUserDecryptResultItem } from '../../../types/relayer.js';
+import type { CleartextEthereumModule } from '../../ethereum/types-ct.js';
+import type { FetchUserDecryptParameters, FetchUserDecryptReturnType, RelayerClientWithRuntime } from '../types.js';
+import { remove0x } from '../../../base/string.js';
+import { asUint32BigInt, parseUintBigIntString, randomUniqueUints } from '../../../base/uint.js';
+import { getTrustedClient } from '../../../runtime/CoreFhevm-p.js';
+import { userDecryptResultToKmsSigncryptedShares } from '../utils.js';
+import { getKmsSignersPrivateKeyMap } from './signers.js';
+
+////////////////////////////////////////////////////////////////////////////////
+
+const userDecryptAbi = [
+  {
+    type: 'function',
+    name: 'userDecrypt',
+    inputs: [
+      {
+        name: 'pairs',
+        type: 'tuple[]',
+        internalType: 'struct HandleContractPair[]',
+        components: [
+          { name: 'handle', type: 'bytes32', internalType: 'bytes32' },
+          {
+            name: 'contractAddress',
+            type: 'address',
+            internalType: 'address',
+          },
+        ],
+      },
+      { name: 'userAddress', type: 'address', internalType: 'address' },
+      { name: 'publicKey', type: 'bytes', internalType: 'bytes' },
+      {
+        name: 'contractAddresses',
+        type: 'address[]',
+        internalType: 'address[]',
+      },
+      {
+        name: 'startTimestamp',
+        type: 'uint256',
+        internalType: 'uint256',
+      },
+      {
+        name: 'durationDays',
+        type: 'uint256',
+        internalType: 'uint256',
+      },
+      { name: 'userSignature', type: 'bytes', internalType: 'bytes' },
+    ],
+    outputs: [
+      { name: 'payload', type: 'bytes', internalType: 'bytes' },
+      { name: 'signers', type: 'address[]', internalType: 'address[]' },
+      { name: 'threshold', type: 'uint256', internalType: 'uint256' },
+      { name: 'extraData', type: 'bytes', internalType: 'bytes' },
+    ],
+    stateMutability: 'view',
+  },
+] as const;
+
+////////////////////////////////////////////////////////////////////////////////
+
+export async function fetchUserDecrypt(
+  relayerClient: RelayerClientWithRuntime,
+  parameters: FetchUserDecryptParameters,
+): Promise<FetchUserDecryptReturnType> {
+  const cleartextEthereumModule = relayerClient.runtime.ethereum as CleartextEthereumModule;
+  const { payload } = parameters;
+  const pairs = payload.handleContractPairs;
+  const contractAddresses = payload.kmsDecryptEip712Message.contractAddresses;
+
+  const authCount = contractAddresses.length;
+  for (const { contractAddress: c } of pairs) {
+    let authorized: boolean = false;
+    for (let i = 0; i < authCount; ++i) {
+      if (contractAddresses[i] == c) {
+        authorized = true;
+        break;
+      }
+    }
+    if (!authorized) {
+      throw new Error(`ContractAddressNotAuthorized: ${c} is not in the EIP-712 authorized contractAddresses list.`);
+    }
+  }
+
+  const { kmsDecryptEip712Message, kmsDecryptEip712Signer, kmsDecryptEip712Signature } = payload;
+  const trustedClient = getTrustedClient(relayerClient);
+  const res = (await relayerClient.runtime.ethereum.readContract(trustedClient, {
+    abi: userDecryptAbi,
+    address: relayerClient.chain.fhevm.contracts.kmsVerifier.address as ChecksummedAddress,
+    args: [
+      pairs.map((p) => ({
+        handle: p.handle.bytes32Hex,
+        contractAddress: p.contractAddress,
+      })),
+      kmsDecryptEip712Signer,
+      kmsDecryptEip712Message.publicKey,
+      kmsDecryptEip712Message.contractAddresses,
+      _parseUintBigIntString('kmsDecryptEip712Message.startTimestamp', kmsDecryptEip712Message.startTimestamp),
+      _parseUintBigIntString('kmsDecryptEip712Message.durationDays', kmsDecryptEip712Message.durationDays),
+      kmsDecryptEip712Signature,
+    ],
+    functionName: userDecryptAbi[0].name,
+  })) as unknown[];
+
+  const commonKmsSigncryptedSharePayload = res[0] as BytesHex;
+  const commonKmsSigncryptedSharePayloadNo0x = remove0x(commonKmsSigncryptedSharePayload);
+  const signersAddress = res[1] as readonly ChecksummedAddress[];
+  const threshold = asUint32BigInt(res[2]);
+  const extraData = res[3] as BytesHex;
+
+  const signers = getKmsSignersPrivateKeyMap(relayerClient);
+
+  const randomSignersAddress = randomUniqueUints(signersAddress.length, Number(threshold)).map(
+    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+    (i) => signersAddress[i]!,
+  );
+
+  const result: FetchUserDecryptResultItem[] = [];
+
+  for (const signerAddress of randomSignersAddress) {
+    const privateKey = signers.get(signerAddress);
+    if (privateKey === undefined) {
+      throw new Error(`Unable to find KMS signer for address ${signerAddress}`);
+    }
+
+    const signature = await cleartextEthereumModule.sign({ hash: commonKmsSigncryptedSharePayload, privateKey });
+    result.push({ signature: remove0x(signature), payload: commonKmsSigncryptedSharePayloadNo0x, extraData });
+  }
+
+  return userDecryptResultToKmsSigncryptedShares(result);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+function _parseUintBigIntString(label: string, value: string): bigint {
+  const bn = parseUintBigIntString(value);
+  if (bn === undefined) {
+    throw new Error(`${label} is not a valid uint string, got ${JSON.stringify(value)}`);
+  }
+  return bn;
+}

package/core/modules/relayer/cleartext/mock.ts

@@ -0,0 +1,54 @@
+import type { UintNumber } from '../../../types/primitives.js';
+import type {
+  FetchFheEncryptionKeyBytesParameters,
+  FetchFheEncryptionKeyBytesReturnType,
+  FetchFheEncryptionKeySourceParameters,
+  RelayerClient,
+  RelayerModuleFactory,
+} from '../types.js';
+import { createDeadbeefBytes } from '../../../base/bytes.js';
+import { fetchUserDecrypt } from './fetchUserDecrypt.js';
+import { fetchPublicDecrypt } from './fetchPublicDecrypt.js';
+import { fetchDelegatedUserDecrypt } from './fetchDelegatedUserDecrypt.js';
+import { fetchCoprocessorSignatures } from './fetchCoprocessorSignatures.js';
+
+////////////////////////////////////////////////////////////////////////////////
+// relayerModule
+////////////////////////////////////////////////////////////////////////////////
+
+export const relayerModule: RelayerModuleFactory = () => {
+  return Object.freeze({
+    relayer: Object.freeze({
+      fetchFheEncryptionKeySource: (
+        _relayerClient: RelayerClient,
+        _parameters: FetchFheEncryptionKeySourceParameters,
+      ) => {
+        throw new Error('Not yet implemented');
+      },
+      fetchFheEncryptionKeyBytes: (
+        relayerClient: RelayerClient,
+        _parameters: FetchFheEncryptionKeyBytesParameters,
+      ): Promise<FetchFheEncryptionKeyBytesReturnType> => {
+        return Promise.resolve({
+          publicKeyBytes: {
+            id: 'fhe-public-key-data-id',
+            bytes: createDeadbeefBytes(256),
+          },
+          crsBytes: {
+            bytes: createDeadbeefBytes(256),
+            capacity: 2048 as UintNumber,
+            id: 'crs-data-id',
+          },
+          metadata: {
+            relayerUrl: relayerClient.relayerUrl,
+            chainId: relayerClient.chainId,
+          },
+        });
+      },
+      fetchCoprocessorSignatures,
+      fetchPublicDecrypt,
+      fetchUserDecrypt,
+      fetchDelegatedUserDecrypt,
+    }),
+  });
+};

package/core/modules/relayer/cleartext/signers.ts

@@ -0,0 +1,52 @@
+import type { BytesHex, ChecksummedAddress } from '../../../types/primitives.js';
+import type { CleartextEthereumModule } from '../../ethereum/types-ct.js';
+import type { RelayerClientWithRuntime } from '../types.js';
+
+////////////////////////////////////////////////////////////////////////////////
+
+const FHEVM_TEST_MNEMONIC = 'test test test test test test test future home engine virtual motion';
+const COPROCESSOR_PATH = "0'/2/";
+const KMS_PATH = "0'/3/";
+
+type PrivateKeyMap = Map<ChecksummedAddress, BytesHex>;
+
+const signersPrivateKeyMap: { readonly coprocessor: PrivateKeyMap; readonly kms: PrivateKeyMap } = {
+  coprocessor: new Map<ChecksummedAddress, BytesHex>(),
+  kms: new Map<ChecksummedAddress, BytesHex>(),
+};
+
+////////////////////////////////////////////////////////////////////////////////
+
+export function getCoprocessorSignersPrivateKeyMap(relayerClient: RelayerClientWithRuntime): PrivateKeyMap {
+  if (signersPrivateKeyMap.coprocessor.size === 0) {
+    _fillSignersPrivateKey(relayerClient, COPROCESSOR_PATH, 20, signersPrivateKeyMap.coprocessor);
+  }
+  return signersPrivateKeyMap.coprocessor;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+export function getKmsSignersPrivateKeyMap(relayerClient: RelayerClientWithRuntime): PrivateKeyMap {
+  if (signersPrivateKeyMap.kms.size === 0) {
+    _fillSignersPrivateKey(relayerClient, KMS_PATH, 20, signersPrivateKeyMap.kms);
+  }
+  return signersPrivateKeyMap.kms;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+function _fillSignersPrivateKey(
+  relayerClient: RelayerClientWithRuntime,
+  hdPathSuffix: string,
+  count: number,
+  map: PrivateKeyMap,
+): void {
+  const cleartextEthereumModule = relayerClient.runtime.ethereum as CleartextEthereumModule;
+  for (let i = 0; i < count; ++i) {
+    const account = cleartextEthereumModule.mnemonicToAccount({
+      mnemonic: FHEVM_TEST_MNEMONIC,
+      path: `m/44'/60'/${hdPathSuffix}${i}`,
+    });
+    map.set(account.address, account.privateKey);
+  }
+}

package/core/modules/relayer/module/fetchCoprocessorSignatures.ts

@@ -3,7 +3,7 @@ import type { FetchInputProofResult } from '../../../types/relayer.js';
 import type {
   FetchCoprocessorSignaturesParameters,
   FetchCoprocessorSignaturesReturnType,
-  RelayerClient,
+  RelayerClientWithRuntime,
 } from '../types.js';
 import { bytesToHexNo0x } from '../../../base/bytes.js';
 import { removeSuffix } from '../../../base/string.js';
@@ -15,7 +15,7 @@ import { RelayerAsyncRequest } from './RelayerAsyncRequest.js';
 ////////////////////////////////////////////////////////////////////////////////
 
 export async function fetchCoprocessorSignatures(
-  relayerClient: RelayerClient,
+  relayerClient: RelayerClientWithRuntime,
   parameters: FetchCoprocessorSignaturesParameters,
 ): Promise<FetchCoprocessorSignaturesReturnType> {
   const { options, payload } = parameters;
@@ -24,13 +24,13 @@ export async function fetchCoprocessorSignatures(
     ciphertextWithInputVerification: bytesToHexNo0x(payload.zkProof.ciphertextWithZkProof),
     contractAddress: payload.zkProof.contractAddress,
     contractChainId: uintToHex0x(payload.zkProof.chainId),
-    extraData: payload.extraData,
+    extraData: payload.zkProof.getExtraData(),
     userAddress: payload.zkProof.userAddress,
   };
 
   const request = new RelayerAsyncRequest({
     relayerOperation: 'INPUT_PROOF',
-    url: `${removeSuffix(relayerClient.relayerUrl, '/')}/v2/input-proof`,
+    url: `${removeSuffix(relayerClient.chain.fhevm.relayerUrl, '/')}/v2/input-proof`,
     payload: inputProofPayload,
     options,
   });

package/core/modules/relayer/module/fetchDelegatedUserDecrypt.ts

@@ -3,7 +3,7 @@ import type { FetchDelegatedUserDecryptResult } from '../../../types/relayer.js'
 import type {
   FetchDelegatedUserDecryptParameters,
   FetchDelegatedUserDecryptReturnType,
-  RelayerClient,
+  RelayerClientWithRuntime,
 } from '../types.js';
 import type { KmsSigncryptedShare } from '../../../types/kms-p.js';
 import { remove0x, removeSuffix } from '../../../base/string.js';
@@ -14,7 +14,7 @@ import { RelayerAsyncRequest } from './RelayerAsyncRequest.js';
 //////////////////////////////////////////////////////////////////////////////
 
 export async function fetchDelegatedUserDecrypt(
-  relayerClient: RelayerClient,
+  relayerClient: RelayerClientWithRuntime,
   parameters: FetchDelegatedUserDecryptParameters,
 ): Promise<FetchDelegatedUserDecryptReturnType> {
   const { options, payload } = parameters;
@@ -47,7 +47,7 @@ export async function fetchDelegatedUserDecrypt(
 
   const request = new RelayerAsyncRequest({
     relayerOperation: 'DELEGATED_USER_DECRYPT',
-    url: `${removeSuffix(relayerClient.relayerUrl, '/')}/v2/delegated-user-decrypt`,
+    url: `${removeSuffix(relayerClient.chain.fhevm.relayerUrl, '/')}/v2/delegated-user-decrypt`,
     payload: relayerPayload,
     options,
   });

package/core/modules/relayer/module/fetchPublicDecrypt.ts

@@ -1,7 +1,7 @@
 import type { Bytes65Hex, BytesHex } from '../../../types/primitives.js';
 import type { RelayerFetchPublicDecryptPayload } from '../../../types/relayer-p.js';
 import type { FetchPublicDecryptResult } from '../../../types/relayer.js';
-import type { FetchPublicDecryptParameters, FetchPublicDecryptReturnType, RelayerClient } from '../types.js';
+import type { FetchPublicDecryptParameters, FetchPublicDecryptReturnType, RelayerClientWithRuntime } from '../types.js';
 import { ensure0x, removeSuffix } from '../../../base/string.js';
 import { RelayerAsyncRequest } from './RelayerAsyncRequest.js';
 
@@ -10,7 +10,7 @@ import { RelayerAsyncRequest } from './RelayerAsyncRequest.js';
 //////////////////////////////////////////////////////////////////////////////
 
 export async function fetchPublicDecrypt(
-  relayerClient: RelayerClient,
+  relayerClient: RelayerClientWithRuntime,
   parameters: FetchPublicDecryptParameters,
 ): Promise<FetchPublicDecryptReturnType> {
   const { options, payload } = parameters;
@@ -25,7 +25,7 @@ export async function fetchPublicDecrypt(
 
   const request = new RelayerAsyncRequest({
     relayerOperation: 'PUBLIC_DECRYPT',
-    url: `${removeSuffix(relayerClient.relayerUrl, '/')}/v2/public-decrypt`,
+    url: `${removeSuffix(relayerClient.chain.fhevm.relayerUrl, '/')}/v2/public-decrypt`,
     payload: p,
     options,
   });

package/core/modules/relayer/module/fetchUserDecrypt.ts

@@ -2,7 +2,7 @@ import type { KmsSigncryptedShare } from '../../../types/kms-p.js';
 import type { Bytes65HexNo0x } from '../../../types/primitives.js';
 import type { FetchUserDecryptPayload } from '../../../types/relayer-p.js';
 import type { FetchUserDecryptResult } from '../../../types/relayer.js';
-import type { FetchUserDecryptParameters, FetchUserDecryptReturnType, RelayerClient } from '../types.js';
+import type { FetchUserDecryptParameters, FetchUserDecryptReturnType, RelayerClientWithRuntime } from '../types.js';
 import { remove0x, removeSuffix } from '../../../base/string.js';
 import { RelayerAsyncRequest } from './RelayerAsyncRequest.js';
 
@@ -11,7 +11,7 @@ import { RelayerAsyncRequest } from './RelayerAsyncRequest.js';
 //////////////////////////////////////////////////////////////////////////////
 
 export async function fetchUserDecrypt(
-  relayerClient: RelayerClient,
+  relayerClient: RelayerClientWithRuntime,
   parameters: FetchUserDecryptParameters,
 ): Promise<FetchUserDecryptReturnType> {
   const { options, payload } = parameters;
@@ -45,7 +45,7 @@ export async function fetchUserDecrypt(
 
   const request = new RelayerAsyncRequest({
     relayerOperation: 'USER_DECRYPT',
-    url: `${removeSuffix(relayerClient.relayerUrl, '/')}/v2/user-decrypt`,
+    url: `${removeSuffix(relayerClient.chain.fhevm.relayerUrl, '/')}/v2/user-decrypt`,
     payload: relayerPayload,
     options,
   });

package/core/modules/relayer/types.ts

@@ -12,6 +12,8 @@ import type { Bytes65Hex, BytesHex, ChecksummedAddress } from '../../types/primi
 import type { Prettify } from '../../types/utils.js';
 import type { ZkProof } from '../../types/zkProof-p.js';
 import type { Handle, InputHandle } from '../../types/encryptedTypes-p.js';
+import type { FhevmChain } from '../../types/fhevmChain.js';
+import type { FhevmRuntime } from '../../types/coreFhevmRuntime.js';
 
 ////////////////////////////////////////////////////////////////////////////////
 //
@@ -24,6 +26,13 @@ export type RelayerClient = {
   readonly chainId: number;
 };
 
+export type RelayerClientWithRuntime = {
+  readonly chain: FhevmChain;
+  readonly runtime: FhevmRuntime;
+  readonly client: NonNullable<object>;
+  readonly options: { readonly batchRpcCalls: boolean };
+};
+
 ////////////////////////////////////////////////////////////////////////////////
 // 1.1 fetchFheEncryptionKeySource
 ////////////////////////////////////////////////////////////////////////////////
@@ -65,7 +74,6 @@ export type FetchFheEncryptionKeyBytesModuleFunction = {
 export type FetchCoprocessorSignaturesParameters = {
   readonly payload: {
     readonly zkProof: ZkProof;
-    readonly extraData: BytesHex;
   };
   readonly options?: RelayerInputProofOptions | undefined;
 };
@@ -78,7 +86,7 @@ export type FetchCoprocessorSignaturesReturnType = {
 
 export type FetchCoprocessorSignaturesModuleFunction = {
   fetchCoprocessorSignatures(
-    relayerClient: RelayerClient,
+    relayerClient: RelayerClientWithRuntime,
     parameters: FetchCoprocessorSignaturesParameters,
   ): Promise<FetchCoprocessorSignaturesReturnType>;
 };
@@ -103,7 +111,7 @@ export type FetchPublicDecryptReturnType = {
 
 export type FetchPublicDecryptModuleFunction = {
   fetchPublicDecrypt(
-    relayerClient: RelayerClient,
+    relayerClient: RelayerClientWithRuntime,
     parameters: FetchPublicDecryptParameters,
   ): Promise<FetchPublicDecryptReturnType>;
 };
@@ -129,7 +137,7 @@ export type FetchUserDecryptReturnType = readonly KmsSigncryptedShare[];
 
 export type FetchUserDecryptModuleFunction = {
   fetchUserDecrypt(
-    relayerClient: RelayerClient,
+    relayerClient: RelayerClientWithRuntime,
     parameters: FetchUserDecryptParameters,
   ): Promise<FetchUserDecryptReturnType>;
 };
@@ -155,7 +163,7 @@ export type FetchDelegatedUserDecryptReturnType = readonly KmsSigncryptedShare[]
 
 export type FetchDelegatedUserDecryptModuleFunction = {
   fetchDelegatedUserDecrypt(
-    relayerClient: RelayerClient,
+    relayerClient: RelayerClientWithRuntime,
     parameters: FetchDelegatedUserDecryptParameters,
   ): Promise<FetchDelegatedUserDecryptReturnType>;
 };