@fhevm/sdk 0.0.1 → 1.0.0-alpha.1

package/core/actions/base/fetchKmsSignedcryptedShares.ts

@@ -0,0 +1,83 @@
+/* eslint-disable @typescript-eslint/unified-signatures */
+import type { Fhevm } from '../../types/coreFhevmClient.js';
+import type { KmsSigncryptedShares } from '../../types/kms.js';
+import type { FhevmChain } from '../../types/fhevmChain.js';
+import type { RelayerDelegatedUserDecryptOptions, RelayerUserDecryptOptions } from '../../types/relayer.js';
+import type {
+  SignedDelegatedDecryptionPermit,
+  SignedSelfDecryptionPermit,
+} from '../../types/signedDecryptionPermit.js';
+import type { EncryptedValueLike } from '../../types/encryptedTypes.js';
+import { fetchKmsSignedcryptedShares as fetchKmsSignedcryptedShares_ } from '../../kms/fetchKmsSignedcryptedShares-p.js';
+import { assertIsEncryptedValueLike, toFhevmHandle } from '../../handle/FhevmHandle.js';
+import { addressToChecksummedAddress, assertIsAddress } from '../../base/address.js';
+
+////////////////////////////////////////////////////////////////////////////////
+
+type FetchKmsSignedcryptedSharesParametersBase = {
+  readonly pairs: ReadonlyArray<{
+    readonly encryptedValue: EncryptedValueLike;
+    readonly contractAddress: string;
+  }>;
+};
+
+export type FetchSelfKmsSignedcryptedSharesParameters = FetchKmsSignedcryptedSharesParametersBase & {
+  readonly signedPermit: SignedSelfDecryptionPermit;
+  readonly options?: RelayerUserDecryptOptions | undefined;
+};
+
+export type FetchDelegatedKmsSignedcryptedSharesParameters = FetchKmsSignedcryptedSharesParametersBase & {
+  readonly signedPermit: SignedDelegatedDecryptionPermit;
+  readonly options?: RelayerDelegatedUserDecryptOptions | undefined;
+};
+
+export type FetchKmsSignedcryptedSharesReturnType = KmsSigncryptedShares;
+
+////////////////////////////////////////////////////////////////////////////////
+// fetchKmsSignedcryptedShares
+////////////////////////////////////////////////////////////////////////////////
+
+/**
+ * Fetches KMS signcrypted decryption shares from the relayer.
+ *
+ * Performs the following verifications before making the request:
+ * 1. Encrypted values are valid and non-empty.
+ * 2. Contract addresses are present and within the max limit.
+ * 3. All encrypted values belong to the host chain.
+ * 4. Cumulative decryption bit limit (2048 bits) is not exceeded.
+ * 5. Permit has not expired.
+ * 6. ACL on-chain permissions: the encrypted data owner is allowed to decrypt.
+ * 7. EIP-712 signature — skipped (guaranteed valid by {@link SignedDecryptionPermit} construction).
+ * 8. Permit `extraData` matches the current on-chain {@link KmsSignersContext}.
+ *
+ * The returned {@link KmsSigncryptedShares} is fully validated (see
+ * {@link KmsSigncryptedSharesImpl} invariants).
+ */
+export async function fetchKmsSignedcryptedShares(
+  fhevm: Fhevm<FhevmChain>,
+  parameters: FetchSelfKmsSignedcryptedSharesParameters,
+): Promise<FetchKmsSignedcryptedSharesReturnType>;
+
+export async function fetchKmsSignedcryptedShares(
+  fhevm: Fhevm<FhevmChain>,
+  parameters: FetchDelegatedKmsSignedcryptedSharesParameters,
+): Promise<FetchKmsSignedcryptedSharesReturnType>;
+
+export async function fetchKmsSignedcryptedShares(
+  fhevm: Fhevm<FhevmChain>,
+  parameters: FetchSelfKmsSignedcryptedSharesParameters | FetchDelegatedKmsSignedcryptedSharesParameters,
+): Promise<FetchKmsSignedcryptedSharesReturnType> {
+  const { pairs } = parameters;
+
+  // Validate & sanitize `pairs` parameter
+  const sanitizedPairs = pairs.map((p, i) => {
+    assertIsEncryptedValueLike(p.encryptedValue, { subject: `encryptedValue[${i}]` });
+    assertIsAddress(p.contractAddress, {});
+    return {
+      handle: toFhevmHandle(p.encryptedValue),
+      contractAddress: addressToChecksummedAddress(p.contractAddress),
+    };
+  });
+
+  return fetchKmsSignedcryptedShares_(fhevm, { ...parameters, pairs: sanitizedPairs });
+}

package/core/actions/base/fetchVerifiedInputProof.ts

@@ -0,0 +1,25 @@
+import type { RelayerInputProofOptions } from '../../types/relayer.js';
+import type { Fhevm } from '../../types/coreFhevmClient.js';
+import type { FhevmChain } from '../../types/fhevmChain.js';
+import type { VerifiedInputProof } from '../../types/inputProof.js';
+import type { BytesHex } from '../../types/primitives.js';
+import type { ZkProofLike } from '../../types/zkProof-p.js';
+import { fetchVerifiedInputProof as fetchVerifiedInputProof_ } from '../../coprocessor/fetchVerifiedInputProof.js';
+import { toZkProof } from '../../coprocessor/ZkProof-p.js';
+
+export type FetchVerifiedInputProofParameters = {
+  readonly zkProof: ZkProofLike;
+  readonly extraData: BytesHex;
+  readonly options?: RelayerInputProofOptions | undefined;
+};
+
+export type FetchVerifiedInputProofReturnType = VerifiedInputProof;
+
+export async function fetchVerifiedInputProof(
+  fhevm: Fhevm<FhevmChain>,
+  parameters: FetchVerifiedInputProofParameters,
+): Promise<FetchVerifiedInputProofReturnType> {
+  const { zkProof, ...rest } = parameters;
+  const sanitizedZkProof = await toZkProof(zkProof);
+  return fetchVerifiedInputProof_(fhevm, { zkProof: sanitizedZkProof, ...rest });
+}

package/core/actions/base/index.ts

@@ -0,0 +1,69 @@
+export { type ReadKmsSignersContextReturnType, readKmsSignersContext } from './readKmsSignersContext.js';
+
+export { type ReadPublicValueParameters, type ReadPublicValueReturnType, readPublicValue } from './readPublicValue.js';
+
+export type { RelayerPublicDecryptOptions, RelayerPublicDecryptProgressArgs } from '../../types/relayer.js';
+
+export {
+  type ReadPublicValuesParameters,
+  type ReadPublicValuesReturnType,
+  readPublicValues,
+} from './readPublicValues.js';
+
+export {
+  type ReadPublicValuesWithSignaturesParameters,
+  type ReadPublicValuesWithSignaturesReturnType,
+  readPublicValuesWithSignatures,
+} from './readPublicValuesWithSignatures.js';
+
+export {
+  type CanReadPublicValueParameters,
+  type CanReadPublicValueReturnType,
+  canReadPublicValue,
+} from './canReadPublicValue.js';
+
+export {
+  type CanReadPublicValuesParameters,
+  type CanReadPublicValuesReturnType,
+  canReadPublicValues,
+} from './canReadPublicValues.js';
+
+export {
+  type CreateVerifiedInputProofFromRawBytesParameters,
+  type CreateVerifiedInputProofFromRawBytesReturnType,
+  createVerifiedInputProofFromRawBytes,
+} from './createVerifiedInputProofFromRawBytes.js';
+
+export {
+  type ReadCoprocessorSignersContextReturnType,
+  readCoprocessorSignersContext,
+} from './readCoprocessorSignersContext.js';
+
+export {
+  type VerifyInputProofParameters,
+  type VerifyInputProofReturnType,
+  verifyInputProof,
+} from './verifyInputProof.js';
+
+export {
+  type FetchVerifiedInputProofParameters,
+  type FetchVerifiedInputProofReturnType,
+  fetchVerifiedInputProof,
+} from './fetchVerifiedInputProof.js';
+
+export {
+  type VerifyZkProofCoprocessorSignaturesParameters,
+  verifyZkProofCoprocessorSignatures,
+} from './verifyZkProofCoprocessorSignatures.js';
+
+export {
+  type FetchSelfKmsSignedcryptedSharesParameters,
+  type FetchDelegatedKmsSignedcryptedSharesParameters,
+  type FetchKmsSignedcryptedSharesReturnType,
+  fetchKmsSignedcryptedShares,
+} from './fetchKmsSignedcryptedShares.js';
+
+export {
+  type VerifyHandlesCoprocessorSignaturesParameters,
+  verifyHandlesCoprocessorSignatures,
+} from './verifyHandlesCoprocessorSignatures.js';

package/core/actions/base/package.json

@@ -0,0 +1,6 @@
+{
+  "type": "module",
+  "types": "../../../_types/core/actions/base/index.d.ts",
+  "module": "../../../_esm/core/actions/base/index.js",
+  "main": "../../../_cjs/core/actions/base/index.js"
+}

package/core/actions/base/readCoprocessorSignersContext.ts

@@ -0,0 +1,21 @@
+import type { Fhevm } from '../../types/coreFhevmClient.js';
+import type { FhevmChain } from '../../types/fhevmChain.js';
+import type { ChecksummedAddress } from '../../types/primitives.js';
+import type { CoprocessorSignersContext } from '../../types/coprocessorSignersContext.js';
+import { readCoprocessorSignersContext as readCoprocessorSignersContext_ } from '../../host-contracts/readCoprocessorSignersContext-p.js';
+
+////////////////////////////////////////////////////////////////////////////////
+
+export type ReadCoprocessorSignersContextReturnType = CoprocessorSignersContext;
+
+////////////////////////////////////////////////////////////////////////////////
+
+export async function readCoprocessorSignersContext(
+  fhevm: Fhevm<FhevmChain>,
+): Promise<ReadCoprocessorSignersContextReturnType> {
+  return readCoprocessorSignersContext_(fhevm, {
+    address: fhevm.chain.fhevm.contracts.inputVerifier.address as ChecksummedAddress,
+  });
+}
+
+////////////////////////////////////////////////////////////////////////////////

package/core/actions/base/readKmsSignersContext.ts

@@ -0,0 +1,19 @@
+import type { KmsSignersContext } from '../../types/kmsSignersContext.js';
+import type { Fhevm } from '../../types/coreFhevmClient.js';
+import type { FhevmChain } from '../../types/fhevmChain.js';
+import type { ChecksummedAddress } from '../../types/primitives.js';
+import { readKmsSignersContext as readKmsSignersContext_ } from '../../host-contracts/readKmsSignersContext-p.js';
+
+////////////////////////////////////////////////////////////////////////////////
+
+export type ReadKmsSignersContextReturnType = KmsSignersContext;
+
+////////////////////////////////////////////////////////////////////////////////
+
+export async function readKmsSignersContext(fhevm: Fhevm<FhevmChain>): Promise<ReadKmsSignersContextReturnType> {
+  return readKmsSignersContext_(fhevm, {
+    address: fhevm.chain.fhevm.contracts.kmsVerifier.address as ChecksummedAddress,
+  });
+}
+
+////////////////////////////////////////////////////////////////////////////////

package/core/actions/base/readPublicValue.ts

@@ -0,0 +1,31 @@
+import type { RelayerPublicDecryptOptions } from '../../types/relayer.js';
+import type { Fhevm } from '../../types/coreFhevmClient.js';
+import type { FhevmChain } from '../../types/fhevmChain.js';
+import type { EncryptedValueLike } from '../../types/encryptedTypes.js';
+import type { TypedValue } from '../../types/primitives.js';
+import { toFhevmHandle } from '../../handle/FhevmHandle.js';
+import { publicDecrypt as publicDecrypt_ } from '../../kms/publicDecrypt.js';
+import { clearValueToTypedValue } from '../../handle/ClearValue.js';
+
+////////////////////////////////////////////////////////////////////////////////
+
+export type ReadPublicValueParameters = {
+  readonly encryptedValue: EncryptedValueLike;
+  readonly options?: RelayerPublicDecryptOptions | undefined;
+};
+
+export type ReadPublicValueReturnType = TypedValue;
+
+////////////////////////////////////////////////////////////////////////////////
+
+export async function readPublicValue(
+  fhevm: Fhevm<FhevmChain>,
+  parameters: ReadPublicValueParameters,
+): Promise<ReadPublicValueReturnType> {
+  const handle = toFhevmHandle(parameters.encryptedValue);
+
+  const originToken = Symbol('readPublicValues');
+  const res = await publicDecrypt_(fhevm, { ...parameters, handles: [handle], originToken });
+
+  return clearValueToTypedValue(res.orderedClearValues[0], originToken);
+}

package/core/actions/base/readPublicValues.ts

@@ -0,0 +1,31 @@
+import type { RelayerPublicDecryptOptions } from '../../types/relayer.js';
+import type { Fhevm } from '../../types/coreFhevmClient.js';
+import type { FhevmChain } from '../../types/fhevmChain.js';
+import type { EncryptedValueLike } from '../../types/encryptedTypes.js';
+import type { TypedValue } from '../../types/primitives.js';
+import { toFhevmHandle } from '../../handle/FhevmHandle.js';
+import { publicDecrypt as publicDecrypt_ } from '../../kms/publicDecrypt.js';
+import { clearValueToTypedValue } from '../../handle/ClearValue.js';
+
+////////////////////////////////////////////////////////////////////////////////
+
+export type ReadPublicValuesParameters = {
+  readonly encryptedValues: readonly EncryptedValueLike[];
+  readonly options?: RelayerPublicDecryptOptions | undefined;
+};
+
+export type ReadPublicValuesReturnType = TypedValue[];
+
+////////////////////////////////////////////////////////////////////////////////
+
+export async function readPublicValues(
+  fhevm: Fhevm<FhevmChain>,
+  parameters: ReadPublicValuesParameters,
+): Promise<ReadPublicValuesReturnType> {
+  const handles = parameters.encryptedValues.map(toFhevmHandle);
+
+  const originToken = Symbol('readPublicValues');
+  const res = await publicDecrypt_(fhevm, { ...parameters, handles, originToken });
+
+  return res.orderedClearValues.map((cv) => clearValueToTypedValue(cv, originToken));
+}

package/core/actions/base/readPublicValuesWithSignatures.ts

@@ -0,0 +1,53 @@
+import type { RelayerPublicDecryptOptions } from '../../types/relayer.js';
+import type { Fhevm } from '../../types/coreFhevmClient.js';
+import type { FhevmChain } from '../../types/fhevmChain.js';
+import type { EncryptedValueLike } from '../../types/encryptedTypes.js';
+import type { BytesHex, TypedValue } from '../../types/primitives.js';
+import type { HandleBytes32Hex } from '../../types/encryptedTypes-p.js';
+import type { NonEmptyReadonlyArray } from '../../types/utils.js';
+import { toFhevmHandle } from '../../handle/FhevmHandle.js';
+import { publicDecrypt as publicDecrypt_ } from '../../kms/publicDecrypt.js';
+import { clearValueToTypedValue } from '../../handle/ClearValue.js';
+
+////////////////////////////////////////////////////////////////////////////////
+
+export type ReadPublicValuesWithSignaturesParameters = {
+  readonly encryptedValues: readonly EncryptedValueLike[];
+  readonly options?: RelayerPublicDecryptOptions | undefined;
+};
+
+export type ReadPublicValuesWithSignaturesReturnType = {
+  readonly clearValues: NonEmptyReadonlyArray<TypedValue>;
+  readonly checkSignaturesArgs: {
+    readonly handlesList: NonEmptyReadonlyArray<HandleBytes32Hex>;
+    readonly abiEncodedCleartexts: BytesHex;
+    readonly decryptionProof: BytesHex;
+  };
+};
+
+////////////////////////////////////////////////////////////////////////////////
+
+export async function readPublicValuesWithSignatures(
+  fhevm: Fhevm<FhevmChain>,
+  parameters: ReadPublicValuesWithSignaturesParameters,
+): Promise<ReadPublicValuesWithSignaturesReturnType> {
+  const handles = parameters.encryptedValues.map(toFhevmHandle);
+
+  const originToken = Symbol('readPublicValues');
+  const res = await publicDecrypt_(fhevm, { ...parameters, handles, originToken });
+
+  const typedValues = res.orderedClearValues.map((cv) =>
+    clearValueToTypedValue(cv, originToken),
+  ) as unknown as NonEmptyReadonlyArray<TypedValue>;
+
+  return Object.freeze({
+    clearValues: typedValues,
+    checkSignaturesArgs: Object.freeze({
+      handlesList: Object.freeze(
+        handles.map((h) => h.bytes32Hex),
+      ) as unknown as NonEmptyReadonlyArray<HandleBytes32Hex>,
+      abiEncodedCleartexts: res.orderedAbiEncodedClearValues,
+      decryptionProof: res.decryptionProof,
+    }),
+  });
+}

package/core/actions/base/signDecryptionPermit.ts

@@ -0,0 +1,41 @@
+import type {
+  SignDecryptionPermitParameters,
+  SignSelfDecryptionPermitParameters,
+  SignDelegatedDecryptionPermitParameters,
+} from '../../kms/SignedDecryptionPermit-p.js';
+import type { Fhevm } from '../../types/coreFhevmClient.js';
+import type { FhevmChain } from '../../types/fhevmChain.js';
+import type {
+  SignedDecryptionPermit,
+  SignedDelegatedDecryptionPermit,
+  SignedSelfDecryptionPermit,
+} from '../../types/signedDecryptionPermit.js';
+import { signDecryptionPermit as signDecryptionPermit_ } from '../../kms/SignedDecryptionPermit-p.js';
+
+export type {
+  SignDecryptionPermitParameters,
+  SignSelfDecryptionPermitParameters,
+  SignDelegatedDecryptionPermitParameters,
+};
+export type SignDecryptionPermitReturnType = SignedDecryptionPermit;
+
+export async function signDecryptionPermit(
+  fhevm: Fhevm<FhevmChain>,
+  parameters: SignSelfDecryptionPermitParameters,
+): Promise<SignedSelfDecryptionPermit>;
+export async function signDecryptionPermit(
+  fhevm: Fhevm<FhevmChain>,
+  parameters: SignDelegatedDecryptionPermitParameters,
+): Promise<SignedDelegatedDecryptionPermit>;
+export async function signDecryptionPermit(
+  fhevm: Fhevm<FhevmChain>,
+  parameters: SignDecryptionPermitParameters,
+): Promise<SignedDecryptionPermit> {
+  // The public overloads guarantee the correct pairing.
+  // The if/else narrows parameters via delegatorAddress, so TS can match each branch
+  // to the correct overload of signDecryptionPermit_ without any casts.
+  if (parameters.delegatorAddress !== undefined) {
+    return signDecryptionPermit_(fhevm, parameters);
+  }
+  return signDecryptionPermit_(fhevm, parameters);
+}

package/core/actions/base/verifyHandlesCoprocessorSignatures.ts

@@ -0,0 +1,60 @@
+import type { CoprocessorEip712Domain, CoprocessorEip712Message } from '../../types/coprocessor.js';
+import type { CoprocessorSignersContext } from '../../types/coprocessorSignersContext.js';
+import type { Fhevm } from '../../types/coreFhevmClient.js';
+import type { FhevmChain } from '../../types/fhevmChain.js';
+import type { Bytes65Hex, BytesHex, ChecksummedAddress, Uint64BigInt } from '../../types/primitives.js';
+import type { InputHandle } from '../../types/encryptedTypes-p.js';
+import { recoverSigners } from '../../utils-p/runtime/recoverSigners.js';
+import { coprocessorEip712PrimaryType, coprocessorEip712Types } from '../../coprocessor/coprocessorEip712Types.js';
+import { createCoprocessorEip712Domain } from '../../coprocessor/createCoprocessorEip712Domain.js';
+import { assertCoprocessorSignerThreshold } from '../../host-contracts/CoprocessorSignersContext-p.js';
+import { readCoprocessorSignersContext } from './readCoprocessorSignersContext.js';
+
+////////////////////////////////////////////////////////////////////////////////
+
+export type VerifyHandlesCoprocessorSignaturesParameters = {
+  readonly coprocessorSignatures: readonly Bytes65Hex[];
+  readonly inputHandles: readonly InputHandle[];
+  readonly userAddress: ChecksummedAddress;
+  readonly contractAddress: ChecksummedAddress;
+  readonly chainId: Uint64BigInt;
+  readonly extraData: BytesHex;
+};
+
+////////////////////////////////////////////////////////////////////////////////
+// verifyHandlesCoprocessorSignatures
+////////////////////////////////////////////////////////////////////////////////
+
+export async function verifyHandlesCoprocessorSignatures(
+  fhevm: Fhevm<FhevmChain>,
+  parameters: VerifyHandlesCoprocessorSignaturesParameters,
+): Promise<void> {
+  // Use hex strings (not Uint8Array) for EIP-712 message fields.
+  // viem's hashTypedData expects hex strings for bytes32 fields.
+  const message: CoprocessorEip712Message = {
+    ctHandles: parameters.inputHandles.map((h) => h.bytes32Hex),
+    userAddress: parameters.userAddress,
+    contractAddress: parameters.contractAddress,
+    contractChainId: parameters.chainId,
+    extraData: parameters.extraData,
+  };
+
+  const domain: CoprocessorEip712Domain = createCoprocessorEip712Domain({
+    gatewayChainId: fhevm.chain.fhevm.gateway.id,
+    verifyingContractAddressInputVerification: fhevm.chain.fhevm.gateway.contracts.inputVerification.address,
+  });
+
+  // 1. Verify signatures
+  const recoveredAddresses = await recoverSigners(fhevm, {
+    domain,
+    primaryType: coprocessorEip712PrimaryType,
+    types: coprocessorEip712Types,
+    signatures: parameters.coprocessorSignatures,
+    message,
+  });
+
+  const coprocessorSignersContext: CoprocessorSignersContext = await readCoprocessorSignersContext(fhevm);
+
+  // 2. Verify signature threshold is reached
+  assertCoprocessorSignerThreshold(coprocessorSignersContext, recoveredAddresses);
+}

package/core/actions/base/verifyInputProof.ts

@@ -0,0 +1,45 @@
+import type { Fhevm } from '../../types/coreFhevmClient.js';
+import type { FhevmChain } from '../../types/fhevmChain.js';
+import type { InputProof, VerifiedInputProof } from '../../types/inputProof.js';
+import type { ChecksummedAddress } from '../../types/primitives.js';
+import { InputProofError } from '../../errors/InputProofError.js';
+import { verifyHandlesCoprocessorSignatures } from './verifyHandlesCoprocessorSignatures.js';
+
+////////////////////////////////////////////////////////////////////////////////
+
+export type VerifyInputProofParameters = {
+  readonly inputProof: InputProof;
+  readonly signedHandleAccess?: {
+    readonly userAddress: ChecksummedAddress;
+    readonly contractAddress: ChecksummedAddress;
+  };
+};
+
+export type VerifyInputProofReturnType = VerifiedInputProof;
+
+////////////////////////////////////////////////////////////////////////////////
+
+export async function verifyInputProof(
+  fhevm: Fhevm<FhevmChain>,
+  parameters: VerifyInputProofParameters,
+): Promise<VerifyInputProofReturnType> {
+  const signedHandleAccess = parameters.signedHandleAccess ?? parameters.inputProof.signedHandleAccess;
+  if (signedHandleAccess === undefined) {
+    throw new InputProofError({
+      message: 'Missing signedHandleAccess argument.',
+    });
+  }
+
+  const chainId = parameters.inputProof.inputHandles[0].chainId;
+
+  await verifyHandlesCoprocessorSignatures(fhevm, {
+    chainId,
+    coprocessorSignatures: parameters.inputProof.coprocessorSignatures,
+    extraData: parameters.inputProof.extraData,
+    inputHandles: parameters.inputProof.inputHandles,
+    userAddress: signedHandleAccess.userAddress,
+    contractAddress: signedHandleAccess.contractAddress,
+  });
+
+  return parameters.inputProof as VerifiedInputProof;
+}

package/core/actions/base/verifyZkProofCoprocessorSignatures.ts

@@ -0,0 +1,32 @@
+import type { Fhevm } from '../../types/coreFhevmClient.js';
+import type { FhevmChain } from '../../types/fhevmChain.js';
+import type { Bytes65Hex, BytesHex } from '../../types/primitives.js';
+import type { ZkProof } from '../../types/zkProof-p.js';
+import { assertIsZkProof } from '../../coprocessor/ZkProof-p.js';
+import { verifyHandlesCoprocessorSignatures } from './verifyHandlesCoprocessorSignatures.js';
+
+////////////////////////////////////////////////////////////////////////////////
+// verifyZKProofCoprocessorSignatures
+////////////////////////////////////////////////////////////////////////////////
+
+export type VerifyZkProofCoprocessorSignaturesParameters = {
+  readonly zkProof: ZkProof;
+  readonly coprocessorSignatures: readonly Bytes65Hex[];
+  readonly extraData: BytesHex;
+};
+
+export async function verifyZkProofCoprocessorSignatures(
+  fhevm: Fhevm<FhevmChain>,
+  parameters: VerifyZkProofCoprocessorSignaturesParameters,
+): Promise<void> {
+  assertIsZkProof(parameters.zkProof, {});
+
+  return verifyHandlesCoprocessorSignatures(fhevm, {
+    inputHandles: parameters.zkProof.getInputHandles(),
+    userAddress: parameters.zkProof.userAddress,
+    contractAddress: parameters.zkProof.contractAddress,
+    chainId: parameters.zkProof.chainId,
+    extraData: parameters.extraData,
+    coprocessorSignatures: parameters.coprocessorSignatures,
+  });
+}

package/core/actions/chain/createCoprocessorEip712Domain.ts

@@ -0,0 +1,16 @@
+import type { CoprocessorEip712Domain } from '../../types/coprocessor.js';
+import type { Fhevm, OptionalNativeClient } from '../../types/coreFhevmClient.js';
+import type { FhevmRuntime } from '../../types/coreFhevmRuntime.js';
+import type { FhevmChain } from '../../types/fhevmChain.js';
+import { createCoprocessorEip712Domain as createCoprocessorEip712Domain_ } from '../../coprocessor/createCoprocessorEip712Domain.js';
+
+export type CreateCoprocessorEip712DomainReturnType = CoprocessorEip712Domain;
+
+export function createCoprocessorEip712Domain(
+  fhevm: Fhevm<FhevmChain, FhevmRuntime, OptionalNativeClient>,
+): CreateCoprocessorEip712DomainReturnType {
+  return createCoprocessorEip712Domain_({
+    gatewayChainId: fhevm.chain.fhevm.gateway.id,
+    verifyingContractAddressInputVerification: fhevm.chain.fhevm.gateway.contracts.inputVerification.address,
+  });
+}

package/core/actions/chain/createKmsDelegatedUserDecryptEip712.ts

@@ -0,0 +1,37 @@
+import type { Fhevm, OptionalNativeClient } from '../../types/coreFhevmClient.js';
+import type { FhevmRuntime } from '../../types/coreFhevmRuntime.js';
+import type { FhevmChain } from '../../types/fhevmChain.js';
+import type { ChecksummedAddress } from '../../types/primitives.js';
+import type { KmsDelegatedUserDecryptEip712 } from '../../types/kms.js';
+import { createKmsDelegatedUserDecryptEip712 as createKmsDelegatedUserDecryptEip712_ } from '../../kms/createKmsDelegatedUserDecryptEip712.js';
+
+////////////////////////////////////////////////////////////////////////////////
+
+export type CreateKmsDelegatedUserDecryptEip712Parameters = {
+  readonly publicKey: string | Uint8Array;
+  readonly contractAddresses: readonly string[];
+  readonly startTimestamp: number;
+  readonly durationDays: number;
+  readonly extraData: string;
+  readonly delegatorAddress: string;
+};
+
+export type CreateKmsDelegatedUserDecryptEip712ReturnType = KmsDelegatedUserDecryptEip712;
+
+export function createKmsDelegatedUserDecryptEip712(
+  fhevm: Fhevm<FhevmChain, FhevmRuntime, OptionalNativeClient>,
+  parameters: CreateKmsDelegatedUserDecryptEip712Parameters,
+): CreateKmsDelegatedUserDecryptEip712ReturnType {
+  return createKmsDelegatedUserDecryptEip712_({
+    verifyingContractAddressDecryption: fhevm.chain.fhevm.gateway.contracts.decryption.address as ChecksummedAddress,
+    chainId: fhevm.chain.id,
+    contractAddresses: parameters.contractAddresses,
+    durationDays: parameters.durationDays,
+    startTimestamp: parameters.startTimestamp,
+    extraData: parameters.extraData,
+    publicKey: parameters.publicKey,
+    delegatorAddress: parameters.delegatorAddress,
+  });
+}
+
+////////////////////////////////////////////////////////////////////////////////

package/core/actions/chain/createKmsEip712Domain.ts

@@ -0,0 +1,16 @@
+import type { Fhevm, OptionalNativeClient } from '../../types/coreFhevmClient.js';
+import type { FhevmRuntime } from '../../types/coreFhevmRuntime.js';
+import type { FhevmChain } from '../../types/fhevmChain.js';
+import type { KmsEip712Domain } from '../../types/kms.js';
+import { createKmsEip712Domain as createKmsEIP712Domain_ } from '../../kms/createKmsEip712Domain.js';
+
+export type CreateKmsEIP712DomainReturnType = KmsEip712Domain;
+
+export function createKmsEIP712Domain(
+  fhevm: Fhevm<FhevmChain, FhevmRuntime, OptionalNativeClient>,
+): CreateKmsEIP712DomainReturnType {
+  return createKmsEIP712Domain_({
+    chainId: fhevm.chain.fhevm.gateway.id,
+    verifyingContractAddressDecryption: fhevm.chain.fhevm.gateway.contracts.decryption.address,
+  });
+}