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

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));
-}

package/core/kms/kmsExtraData.ts

@@ -1,127 +0,0 @@
-import type { Bytes32Hex, BytesHex, Uint256BigInt, Uint8Number } from '../types/primitives.js';
-import type { ErrorMetadataParams } from '../base/errors/ErrorBase.js';
-import { asUint256BigInt, asUint8Number } from '../base/uint.js';
-import { asBytes32Hex, assertIsBytesHex } from '../base/bytes.js';
-
-export const EXTRA_DATA_V0: Uint8Number = 0x00 as Uint8Number; // 0x00
-export const EXTRA_DATA_V1: Uint8Number = 0x01 as Uint8Number; // 1 version byte + 32-byte big-endian context ID = 33 bytes
-export const EXTRA_DATA_V2: Uint8Number = 0x02 as Uint8Number; // 1 version byte + 32-byte big-endian context ID + 32-byte big-endian epoch ID = 65 bytes
-
-export function fromKmsExtraData(extraData: BytesHex): {
-  version: Uint8Number;
-  kmsContextId: Uint256BigInt;
-  kmsEpochId: Uint256BigInt;
-} {
-  if ((extraData as string) === '0x00' || (extraData as string) === '0x') {
-    return {
-      version: EXTRA_DATA_V0,
-      kmsContextId: 0n as Uint256BigInt,
-      kmsEpochId: 0n as Uint256BigInt,
-    };
-  }
-
-  if (extraData.length <= 4) {
-    throw new Error(`Unsupported extraData length ${extraData.length}: must be more than 4 bytes`);
-  }
-
-  // First byte = version (characters 2-3 after '0x')
-  const version = asUint8Number(Number('0x' + extraData.slice(2, 4)));
-
-  if (version === EXTRA_DATA_V1) {
-    // ExtraData v1 format: 1 version byte + 32-byte big-endian context ID = 33 bytes = 66 hex chars + 2 for '0x' = 68
-    // 0x01aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
-    // ↑   ↑                                                               ↑
-    // 0   4                                                               68
-    // 0         1         2         3         4         5         6
-    // 01234567890123456789012345678901234567890123456789012345678901234567
-
-    if (extraData.length != 68) {
-      throw new Error(`Invalid extraData length for v1: expected 68, got ${extraData.length}`);
-    }
-    // 32-byte contextId starts at byte 1 (hex chars 4..67)
-    const contextIdBytes32Hex: Bytes32Hex = asBytes32Hex(`0x${extraData.slice(4, 68)}`);
-    const kmsContextId = asUint256BigInt(BigInt(contextIdBytes32Hex));
-    return { version, kmsContextId, kmsEpochId: 0n as Uint256BigInt };
-  }
-
-  if (version === EXTRA_DATA_V2) {
-    // ExtraData v2 format: 1 version byte + 32-byte big-endian context ID + 32-byte big-endian epoch ID = 65 bytes = 130 hex chars + 2 for '0x' = 132
-    // 0x01aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb
-    // ↑   ↑                                                               ↑                                                               ↑
-    // 0   4                                                               68                                                              132
-    // 0         1         2         3         4         5         6         7         8         9         0         1         2         3
-    // 012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901
-
-    if (extraData.length != 132) {
-      throw new Error(`Invalid extraData length for v2: expected 132, got ${extraData.length}`);
-    }
-    // 32-byte contextId starts at byte 1 (hex chars 4..67)
-    const contextIdBytes32Hex: Bytes32Hex = asBytes32Hex(`0x${extraData.slice(4, 68)}`);
-    const kmsContextId = asUint256BigInt(BigInt(contextIdBytes32Hex));
-
-    // 32-byte epochId starts at byte 33 (hex chars 68..131)
-    const epochIdBytes32Hex: Bytes32Hex = asBytes32Hex(`0x${extraData.slice(68, 132)}`);
-    const kmsEpochId = asUint256BigInt(BigInt(epochIdBytes32Hex));
-
-    return { version, kmsContextId, kmsEpochId };
-  }
-
-  throw new Error(`Unsupported extraData version ${version}`);
-}
-
-/**
- * Encodes a KMS context into an extraData format.
- * v0: `0x00`
- * v1: `0x01` + 32-byte big-endian context ID.
- * v2: `0x02` + 32-byte big-endian context ID + 32-byte big-endian epoch ID.
- */
-export function toKmsExtraData(args: {
-  readonly version: Uint8Number;
-  readonly kmsContextId: Uint256BigInt;
-  readonly kmsEpochId: Uint256BigInt;
-}): BytesHex {
-  const v = args.version.toString(16).padStart(2, '0');
-
-  switch (args.version) {
-    case EXTRA_DATA_V0: {
-      return `0x${v}` as BytesHex;
-    }
-    case EXTRA_DATA_V1: {
-      if (args.kmsContextId === 0n) {
-        throw new Error('kmsContextId cannot be 0 for v1 extraData');
-      }
-      if (args.kmsEpochId !== 0n) {
-        throw new Error('kmsEpochId must be 0 for v1 extraData');
-      }
-      const contextId = args.kmsContextId.toString(16).padStart(64, '0');
-      return `0x${v}${contextId}` as BytesHex;
-    }
-    case EXTRA_DATA_V2: {
-      if (args.kmsContextId === 0n) {
-        throw new Error('kmsContextId cannot be 0 for v2 extraData');
-      }
-      if (args.kmsEpochId === 0n) {
-        throw new Error('kmsEpochId cannot be 0 for v2 extraData');
-      }
-      const contextId = args.kmsContextId.toString(16).padStart(64, '0');
-      const epochId = args.kmsEpochId.toString(16).padStart(64, '0');
-      return `0x${v}${contextId}${epochId}` as BytesHex;
-    }
-    default:
-      throw new Error(`Unsupported extraData version ${args.version}`);
-  }
-}
-
-export function assertIsKmsExtraData(
-  value: unknown,
-  options: { subject?: string } & ErrorMetadataParams,
-): asserts value is BytesHex {
-  if (value === '0x00' || value === '0x') {
-    return;
-  }
-
-  assertIsBytesHex(value, options);
-
-  // Will valid extraData length too
-  fromKmsExtraData(value);
-}