@fhevm/sdk 1.1.0-alpha.6 → 1.1.0-alpha.7

package/core/actions/base/fetchKmsSigncryptedShares.ts

@@ -1,83 +0,0 @@
-/* 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 { fetchKmsSigncryptedShares as fetchKmsSigncryptedShares_ } from '../../kms/fetchKmsSigncryptedShares-p.js';
-import { assertIsEncryptedValueLike, toFhevmHandle } from '../../handle/FhevmHandle.js';
-import { addressToChecksummedAddress, assertIsAddress } from '../../base/address.js';
-
-////////////////////////////////////////////////////////////////////////////////
-
-type FetchKmsSigncryptedSharesParametersBase = {
-  readonly pairs: ReadonlyArray<{
-    readonly encryptedValue: EncryptedValueLike;
-    readonly contractAddress: string;
-  }>;
-};
-
-export type FetchSelfKmsSigncryptedSharesParameters = FetchKmsSigncryptedSharesParametersBase & {
-  readonly signedPermit: SignedSelfDecryptionPermit;
-  readonly options?: RelayerUserDecryptOptions | undefined;
-};
-
-export type FetchDelegatedKmsSigncryptedSharesParameters = FetchKmsSigncryptedSharesParametersBase & {
-  readonly signedPermit: SignedDelegatedDecryptionPermit;
-  readonly options?: RelayerDelegatedUserDecryptOptions | undefined;
-};
-
-export type FetchKmsSigncryptedSharesReturnType = KmsSigncryptedShares;
-
-////////////////////////////////////////////////////////////////////////////////
-// fetchKmsSigncryptedShares
-////////////////////////////////////////////////////////////////////////////////
-
-/**
- * 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 fetchKmsSigncryptedShares(
-  fhevm: Fhevm<FhevmChain>,
-  parameters: FetchSelfKmsSigncryptedSharesParameters,
-): Promise<FetchKmsSigncryptedSharesReturnType>;
-
-export async function fetchKmsSigncryptedShares(
-  fhevm: Fhevm<FhevmChain>,
-  parameters: FetchDelegatedKmsSigncryptedSharesParameters,
-): Promise<FetchKmsSigncryptedSharesReturnType>;
-
-export async function fetchKmsSigncryptedShares(
-  fhevm: Fhevm<FhevmChain>,
-  parameters: FetchSelfKmsSigncryptedSharesParameters | FetchDelegatedKmsSigncryptedSharesParameters,
-): Promise<FetchKmsSigncryptedSharesReturnType> {
-  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 fetchKmsSigncryptedShares_(fhevm, { ...parameters, pairs: sanitizedPairs });
-}

package/core/actions/base/fetchVerifiedInputProof.ts

@@ -1,25 +0,0 @@
-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, parameters.extraData);
-  return fetchVerifiedInputProof_(fhevm, { zkProof: sanitizedZkProof, ...rest });
-}

package/core/actions/base/readKmsSignersContext.ts

@@ -1,20 +0,0 @@
-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, {
-    kmsVerifierAddress: fhevm.chain.fhevm.contracts.kmsVerifier.address as ChecksummedAddress,
-    protocolConfigAddress: fhevm.chain.fhevm.contracts.protocolConfig?.address as ChecksummedAddress | undefined,
-  });
-}
-
-////////////////////////////////////////////////////////////////////////////////

package/core/actions/base/verifyHandlesCoprocessorSignatures.ts

@@ -1,60 +0,0 @@
-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

@@ -1,45 +0,0 @@
-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

@@ -1,32 +0,0 @@
-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

@@ -1,16 +0,0 @@
-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

@@ -1,36 +0,0 @@
-import type { Fhevm, OptionalNativeClient } from '../../types/coreFhevmClient.js';
-import type { FhevmRuntime } from '../../types/coreFhevmRuntime.js';
-import type { FhevmChain } from '../../types/fhevmChain.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,
-    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

@@ -1,16 +0,0 @@
-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,
-  });
-}

package/core/actions/chain/createKmsUserDecryptEip712.ts

@@ -1,34 +0,0 @@
-import type { Fhevm, OptionalNativeClient } from '../../types/coreFhevmClient.js';
-import type { FhevmRuntime } from '../../types/coreFhevmRuntime.js';
-import type { FhevmChain } from '../../types/fhevmChain.js';
-import type { KmsUserDecryptEip712 } from '../../types/kms.js';
-import { createKmsUserDecryptEip712 as createKmsUserDecryptEip712_ } from '../../kms/createKmsUserDecryptEip712.js';
-
-////////////////////////////////////////////////////////////////////////////////
-
-export type CreateKmsUserDecryptEip712Parameters = {
-  readonly publicKey: string | Uint8Array;
-  readonly contractAddresses: readonly string[];
-  readonly startTimestamp: number;
-  readonly durationDays: number;
-  readonly extraData: string;
-};
-
-export type CreateKmsUserDecryptEip712ReturnType = KmsUserDecryptEip712;
-
-export function createKmsUserDecryptEip712(
-  fhevm: Fhevm<FhevmChain, FhevmRuntime, OptionalNativeClient>,
-  parameters: CreateKmsUserDecryptEip712Parameters,
-): CreateKmsUserDecryptEip712ReturnType {
-  return createKmsUserDecryptEip712_({
-    verifyingContractAddressDecryption: fhevm.chain.fhevm.gateway.contracts.decryption.address,
-    chainId: fhevm.chain.id,
-    contractAddresses: parameters.contractAddresses,
-    durationDays: parameters.durationDays,
-    startTimestamp: parameters.startTimestamp,
-    extraData: parameters.extraData,
-    publicKey: parameters.publicKey,
-  });
-}
-
-////////////////////////////////////////////////////////////////////////////////

package/core/actions/chain/verifyKmsDelegatedUserDecryptEip712.ts

@@ -1,16 +0,0 @@
-import type { Fhevm, OptionalNativeClient } from '../../types/coreFhevmClient.js';
-import type { FhevmRuntime } from '../../types/coreFhevmRuntime.js';
-import type { FhevmChain } from '../../types/fhevmChain.js';
-import {
-  verifyKmsDelegatedUserDecryptEip712 as verifyKmsDelegatedUserDecryptEip712_,
-  type VerifyKmsDelegatedUserDecryptEip712Parameters,
-} from '../../utils-p/decrypt/verifyKmsDelegatedUserDecryptEip712.js';
-
-export type { VerifyKmsDelegatedUserDecryptEip712Parameters };
-
-export async function verifyKmsDelegatedUserDecryptEip712(
-  fhevm: Fhevm<FhevmChain, FhevmRuntime, OptionalNativeClient>,
-  parameters: VerifyKmsDelegatedUserDecryptEip712Parameters,
-): Promise<void> {
-  await verifyKmsDelegatedUserDecryptEip712_(fhevm, parameters);
-}

package/core/actions/chain/verifyKmsUserDecryptEip712.ts

@@ -1,16 +0,0 @@
-import type { Fhevm, OptionalNativeClient } from '../../types/coreFhevmClient.js';
-import type { FhevmRuntime } from '../../types/coreFhevmRuntime.js';
-import type { FhevmChain } from '../../types/fhevmChain.js';
-import {
-  verifyKmsUserDecryptEip712 as verifyKmsUserDecryptEIP712_,
-  type VerifyKmsUserDecryptEip712Parameters,
-} from '../../utils-p/decrypt/verifyKmsUserDecryptEip712.js';
-
-export type { VerifyKmsUserDecryptEip712Parameters };
-
-export async function verifyKmsUserDecryptEip712(
-  fhevm: Fhevm<FhevmChain, FhevmRuntime, OptionalNativeClient>,
-  parameters: VerifyKmsUserDecryptEip712Parameters,
-): Promise<void> {
-  await verifyKmsUserDecryptEIP712_(fhevm, parameters);
-}

package/core/actions/decrypt/decryptKmsSigncryptedShares.ts

@@ -1,34 +0,0 @@
-import type { Fhevm } from '../../types/coreFhevmClient.js';
-import type { FhevmChain } from '../../types/fhevmChain.js';
-import type { WithDecrypt } from '../../types/coreFhevmRuntime.js';
-import type { KmsSigncryptedShares } from '../../types/kms.js';
-import type { TransportKeyPair } from '../../kms/TransportKeyPair-p.js';
-import type { TypedValue } from '../../types/primitives.js';
-import { decryptKmsSigncryptedShares as decryptKmsSigncryptedShares_ } from '../../kms/decryptKmsSigncryptedShares-p.js';
-import { clearValueToTypedValue } from '../../handle/ClearValue.js';
-import { asFhevmWithTkmsVersion } from '../../runtime/CoreFhevm-p.js';
-
-////////////////////////////////////////////////////////////////////////////////
-// decryptKmsSigncryptedShares (with privateKey)
-////////////////////////////////////////////////////////////////////////////////
-
-export type DecryptKmsSigncryptedSharesParameters = {
-  readonly kmsSigncryptedShares: KmsSigncryptedShares;
-  readonly transportKeyPair: TransportKeyPair;
-};
-
-export type DecryptKmsSigncryptedSharesReturnType = readonly TypedValue[];
-
-////////////////////////////////////////////////////////////////////////////////
-
-export async function decryptKmsSigncryptedShares(
-  fhevm: Fhevm<FhevmChain, WithDecrypt>,
-  parameters: DecryptKmsSigncryptedSharesParameters,
-): Promise<DecryptKmsSigncryptedSharesReturnType> {
-  const f = asFhevmWithTkmsVersion(fhevm);
-
-  const clearValues = await decryptKmsSigncryptedShares_(f, parameters);
-
-  const originToken = Symbol('decryptKmsSigncryptedShares');
-  return clearValues.map((cv) => clearValueToTypedValue(cv, originToken));
-}