@fhevm/sdk 0.0.1 → 1.0.0-alpha.1

package/core/types/utils.ts

@@ -0,0 +1,34 @@
+/**
+ * Utility type that flattens intersection types for better IDE display.
+ */
+export type Prettify<T> = {
+  [K in keyof T]: T[K];
+} & {};
+
+export type ValidationResult<T, E extends Error = Error> =
+  | { readonly ok: true; readonly value: T }
+  | { readonly ok: false; readonly error: E };
+
+export type PartialWithUndefined<T> = {
+  [P in keyof T]?: T[P] | undefined;
+};
+
+declare const symbol: unique symbol;
+export type Branded<T, U> = T & { [symbol]: U };
+
+export interface Branding<BrandT> {
+  __brand: BrandT;
+}
+
+export interface Flavoring<FlavorT> {
+  __flavor?: FlavorT;
+}
+
+export type Flavor<T, FlavorT> = T & Flavoring<FlavorT>;
+
+export type NonEmptyExtract<T, U> =
+  Extract<T, U> extends never ? { error: 'Extract produced never - no matching types found' } : Extract<T, U>;
+
+export type StrictEquals<A, B> = [A] extends [B] ? ([B] extends [A] ? true : false) : false;
+
+export type NonEmptyReadonlyArray<T> = readonly [T, ...T[]];

package/core/types/zkProof-p.ts

@@ -0,0 +1,29 @@
+import type { InputHandle } from './encryptedTypes-p.js';
+import type { EncryptionBits } from './fheType.js';
+import type { Bytes, ChecksummedAddress, Uint64BigInt } from './primitives.js';
+
+////////////////////////////////////////////////////////////////////////////////
+//
+// ZkProof
+//
+////////////////////////////////////////////////////////////////////////////////
+
+export interface ZkProofLike {
+  readonly chainId: bigint | number;
+  readonly aclContractAddress: string;
+  readonly contractAddress: string;
+  readonly userAddress: string;
+  readonly ciphertextWithZkProof: Uint8Array | string;
+  readonly encryptionBits?: readonly number[];
+}
+
+export interface ZkProof {
+  readonly chainId: Uint64BigInt;
+  readonly aclContractAddress: ChecksummedAddress;
+  readonly contractAddress: ChecksummedAddress;
+  readonly userAddress: ChecksummedAddress;
+  readonly ciphertextWithZkProof: Bytes;
+  readonly encryptionBits: readonly EncryptionBits[];
+
+  getInputHandles(): readonly InputHandle[];
+}

package/core/types/zkProofBuilder.ts

@@ -0,0 +1,36 @@
+import type { EncryptionBits } from './fheType.js';
+import type { Fhevm } from './coreFhevmClient.js';
+import type {
+  AddressValueLike,
+  BoolValueLike,
+  TypedValue,
+  Uint128ValueLike,
+  Uint16ValueLike,
+  Uint256ValueLike,
+  Uint32ValueLike,
+  Uint64ValueLike,
+  Uint8ValueLike,
+} from './primitives.js';
+import type { ZkProof } from './zkProof-p.js';
+import type { WithEncrypt } from './coreFhevmRuntime.js';
+import type { FhevmChain } from './fhevmChain.js';
+
+export interface ZkProofBuilder {
+  addBool(value: boolean | number | bigint | BoolValueLike): this;
+  addUint8(value: number | bigint | Uint8ValueLike): this;
+  addUint16(value: number | bigint | Uint16ValueLike): this;
+  addUint32(value: number | bigint | Uint32ValueLike): this;
+  addUint64(value: number | bigint | Uint64ValueLike): this;
+  addUint128(value: number | bigint | Uint128ValueLike): this;
+  addUint256(value: number | bigint | Uint256ValueLike): this;
+  addAddress(value: string | AddressValueLike): this;
+  addTypedValue(typedValue: TypedValue): this;
+  getBits(): EncryptionBits[];
+  build(
+    fhevm: Fhevm<FhevmChain, WithEncrypt>,
+    parameters: {
+      readonly contractAddress: string;
+      readonly userAddress: string;
+    },
+  ): Promise<ZkProof>;
+}

package/core/utils-p/decrypt/assertPermitMatchesKeypair.ts

@@ -0,0 +1,27 @@
+import type { TransportKeypair } from '../../kms/TransportKeypair-p.js';
+import type { SignedDecryptionPermit } from '../../types/signedDecryptionPermit.js';
+import { assertIsTransportKeypair } from '../../kms/TransportKeypair-p.js';
+import { assertIsSignedDecryptionPermit } from '../../kms/SignedDecryptionPermit-p.js';
+
+/**
+ * Asserts that the permit's publicKey matches the keypair's publicKey.
+ *
+ * Both values are validated via `instanceof` before comparison.
+ *
+ * @throws {InvalidTypeError} If either value is not the expected type.
+ * @throws If the public keys do not match.
+ */
+export function assertPermitMatchesKeypair(
+  signedPermit: SignedDecryptionPermit,
+  transportKeypair: TransportKeypair,
+): void {
+  assertIsSignedDecryptionPermit(signedPermit, {});
+  assertIsTransportKeypair(transportKeypair, {});
+
+  if (signedPermit.e2eTransportPublicKey.toLowerCase() !== transportKeypair.publicKey.toLowerCase()) {
+    throw new Error(
+      "The permit's publicKey does not match the E2eTransportKeypair's publicKey. " +
+        'Ensure the permit was signed with the same keypair.',
+    );
+  }
+}

package/core/utils-p/decrypt/verifyKmsDelegatedUserDecryptEip712.ts

@@ -0,0 +1,47 @@
+import type { FhevmRuntime } from '../../types/coreFhevmRuntime.js';
+import type { FhevmChain } from '../../types/fhevmChain.js';
+import type { KmsDelegatedUserDecryptEip712, KmsDelegatedUserDecryptEip712Message } from '../../types/kms.js';
+import type { Bytes65Hex, ChecksummedAddress } from '../../types/primitives.js';
+import { kmsDelegatedUserDecryptEip712Types } from '../../kms/kmsDelegatedUserDecryptEip712Types.js';
+import { ThresholdSignerError, UnknownSignerError } from '../../errors/SignersError.js';
+import { createKmsEip712Domain } from '../../kms/createKmsEip712Domain.js';
+import { recoverSigners } from '../runtime/recoverSigners.js';
+
+export type VerifyKmsDelegatedUserDecryptEip712Parameters = {
+  readonly signer: ChecksummedAddress;
+  readonly message: KmsDelegatedUserDecryptEip712Message;
+  readonly signature: Bytes65Hex;
+};
+
+export async function verifyKmsDelegatedUserDecryptEip712(
+  context: { readonly chain: FhevmChain; readonly runtime: FhevmRuntime },
+  parameters: VerifyKmsDelegatedUserDecryptEip712Parameters,
+): Promise<void> {
+  // A 'DelegatedUserDecryptRequestVerification' KmsEIP712Domain (for signed permit)
+  // uses `chain.id` (NOT fhevm.gateway.id!!)
+  const domain = createKmsEip712Domain({
+    chainId: context.chain.id,
+    verifyingContractAddressDecryption: context.chain.fhevm.gateway.contracts.decryption.address,
+  });
+
+  const recoveredAddresses = await recoverSigners(context, {
+    domain,
+    types: kmsDelegatedUserDecryptEip712Types,
+    primaryType: 'DelegatedUserDecryptRequestVerification' satisfies KmsDelegatedUserDecryptEip712['primaryType'],
+    signatures: [parameters.signature],
+    message: parameters.message,
+  });
+
+  if (recoveredAddresses.length !== 1) {
+    throw new ThresholdSignerError({
+      type: 'kms',
+    });
+  }
+
+  if (recoveredAddresses[0] !== parameters.signer) {
+    throw new UnknownSignerError({
+      unknownAddress: recoveredAddresses[0] as unknown as ChecksummedAddress,
+      type: 'kms',
+    });
+  }
+}

package/core/utils-p/decrypt/verifyKmsUserDecryptEip712.ts

@@ -0,0 +1,47 @@
+import type { FhevmRuntime } from '../../types/coreFhevmRuntime.js';
+import type { FhevmChain } from '../../types/fhevmChain.js';
+import type { KmsUserDecryptEip712, KmsUserDecryptEip712Message } from '../../types/kms.js';
+import type { Bytes65Hex, ChecksummedAddress } from '../../types/primitives.js';
+import { ThresholdSignerError, UnknownSignerError } from '../../errors/SignersError.js';
+import { createKmsEip712Domain } from '../../kms/createKmsEip712Domain.js';
+import { kmsUserDecryptEip712Types } from '../../kms/kmsUserDecryptEip712Types.js';
+import { recoverSigners } from '../runtime/recoverSigners.js';
+
+export type VerifyKmsUserDecryptEip712Parameters = {
+  readonly signer: ChecksummedAddress;
+  readonly message: KmsUserDecryptEip712Message;
+  readonly signature: Bytes65Hex;
+};
+
+export async function verifyKmsUserDecryptEip712(
+  context: { readonly chain: FhevmChain; readonly runtime: FhevmRuntime },
+  parameters: VerifyKmsUserDecryptEip712Parameters,
+): Promise<void> {
+  // A 'UserDecryptRequestVerification' KmsEIP712Domain (for signed permit)
+  // uses `chain.id` (NOT fhevm.gateway.id!!)
+  const domain = createKmsEip712Domain({
+    chainId: context.chain.id,
+    verifyingContractAddressDecryption: context.chain.fhevm.gateway.contracts.decryption.address,
+  });
+
+  const recoveredAddresses = await recoverSigners(context, {
+    domain,
+    types: kmsUserDecryptEip712Types,
+    primaryType: 'UserDecryptRequestVerification' satisfies KmsUserDecryptEip712['primaryType'],
+    signatures: [parameters.signature],
+    message: parameters.message,
+  });
+
+  if (recoveredAddresses.length !== 1) {
+    throw new ThresholdSignerError({
+      type: 'kms',
+    });
+  }
+
+  if (recoveredAddresses[0] !== parameters.signer) {
+    throw new UnknownSignerError({
+      unknownAddress: recoveredAddresses[0] as unknown as ChecksummedAddress,
+      type: 'kms',
+    });
+  }
+}

package/core/utils-p/decrypt/verifyTkmsPublicKey.ts

@@ -0,0 +1,27 @@
+import type { TkmsPrivateKey } from '../../types/tkms-p.js';
+import type { FhevmRuntime, WithDecrypt } from '../../types/coreFhevmRuntime.js';
+import type { BytesHex } from '../../types/primitives.js';
+
+/**
+ * Verifies that a TKMS public key matches the given private key
+ * by re-deriving the public key and comparing.
+ *
+ * @throws If the derived public key does not match `tkmsPublicKeyBytesHex`.
+ */
+export async function verifyTkmsPublicKey(
+  context: { readonly runtime: FhevmRuntime<WithDecrypt> },
+  parameters: {
+    readonly tkmsPrivateKey: TkmsPrivateKey;
+    readonly tkmsPublicKeyBytesHex: BytesHex;
+  },
+): Promise<void> {
+  const { tkmsPrivateKey, tkmsPublicKeyBytesHex } = parameters;
+
+  const expectedTkmsPublicKeyBytesHex = await context.runtime.decrypt.getTkmsPublicKeyHex({
+    tkmsPrivateKey,
+  });
+
+  if (expectedTkmsPublicKeyBytesHex !== tkmsPublicKeyBytesHex) {
+    throw new Error('invalid E2eTransportKeypair');
+  }
+}

package/core/utils-p/runtime/recoverSigners.ts

@@ -0,0 +1,46 @@
+import type { RecoverTypedDataAddressModuleFunction } from '../../modules/ethereum/types.js';
+import type { FhevmRuntime } from '../../types/coreFhevmRuntime.js';
+import type { Bytes65Hex, ChecksummedAddress } from '../../types/primitives.js';
+import { assertIsBytes65HexArray } from '../../base/bytes.js';
+
+type EIP712TypesType = Record<string, ReadonlyArray<{ name: string; type: string }>>;
+
+export type RecoverSignersParameters<T extends EIP712TypesType> = {
+  readonly domain: Parameters<RecoverTypedDataAddressModuleFunction['recoverTypedDataAddress']>[0]['domain'];
+  readonly types: T;
+  readonly primaryType: string & keyof T;
+  readonly signatures: readonly string[];
+  readonly message: Record<string, unknown>;
+};
+
+export type RecoverSignersReturnType = ChecksummedAddress[];
+
+export async function recoverSigners<T extends Record<string, ReadonlyArray<{ name: string; type: string }>>>(
+  context: { readonly runtime: FhevmRuntime },
+  parameters: RecoverSignersParameters<T>,
+): Promise<RecoverSignersReturnType> {
+  const { domain, types, primaryType, signatures, message } = parameters;
+  assertIsBytes65HexArray(signatures, { subject: 'signatures' });
+
+  const fields = types[primaryType];
+  if (fields === undefined) {
+    throw new Error(`Primary type "${primaryType}" not found in types`);
+  }
+
+  const recoveredAddresses = await Promise.all(
+    signatures.map((signature: Bytes65Hex) =>
+      context.runtime.ethereum.recoverTypedDataAddress({
+        signature,
+        // force cast
+        domain,
+        primaryType,
+        types: {
+          [primaryType]: [...fields],
+        },
+        message,
+      }),
+    ),
+  );
+
+  return recoveredAddresses;
+}

package/ethers/clients/createFhevmBaseClient.ts

@@ -0,0 +1,24 @@
+import type { ethers as EthersT } from 'ethers';
+import type { FhevmChain } from '../../core/types/fhevmChain.js';
+import type { FhevmRuntime } from '../../core/types/coreFhevmRuntime.js';
+import type { FhevmOptions } from '../../core/types/coreFhevmClient.js';
+import type { FhevmBaseClient } from '../../core/types/fhevmClient.js';
+import { getEthersRuntime, PRIVATE_ETHERS_TOKEN } from '../internal/ethers-p.js';
+import { createCoreFhevm } from '../../core/runtime/CoreFhevm-p.js';
+import { baseActions } from '../../core/clients/decorators/base.js';
+
+////////////////////////////////////////////////////////////////////////////////
+
+export function createFhevmBaseClient<chain extends FhevmChain, provider extends EthersT.ContractRunner>(parameters: {
+  readonly provider: provider;
+  readonly chain: chain;
+  readonly options?: FhevmOptions | undefined;
+}): FhevmBaseClient<chain, FhevmRuntime, provider> {
+  const c = createCoreFhevm(PRIVATE_ETHERS_TOKEN, {
+    chain: parameters.chain,
+    runtime: getEthersRuntime(),
+    client: parameters.provider,
+    options: parameters.options,
+  });
+  return c.extend(baseActions);
+}

package/ethers/clients/createFhevmClient.ts

@@ -0,0 +1,20 @@
+import type { ethers as EthersT } from 'ethers';
+import type { FhevmChain } from '../../core/types/fhevmChain.js';
+import type { WithAll } from '../../core/types/coreFhevmRuntime.js';
+import type { FhevmOptions } from '../../core/types/coreFhevmClient.js';
+import type { FhevmClient } from '../../core/types/fhevmClient.js';
+import { createFhevmBaseClient } from './createFhevmBaseClient.js';
+import { encryptActions } from '../decorators/encrypt.js';
+import { decryptActions } from '../decorators/decrypt.js';
+
+////////////////////////////////////////////////////////////////////////////////
+
+export function createFhevmClient<chain extends FhevmChain, provider extends EthersT.ContractRunner>(parameters: {
+  readonly provider: provider;
+  readonly chain: chain;
+  readonly options?: FhevmOptions | undefined;
+}): FhevmClient<chain, WithAll, provider> {
+  const c = createFhevmBaseClient(parameters);
+
+  return c.extend(decryptActions).extend(encryptActions);
+}

package/ethers/clients/createFhevmDecryptClient.ts

@@ -0,0 +1,21 @@
+import type { ethers as EthersT } from 'ethers';
+import type { FhevmChain } from '../../core/types/fhevmChain.js';
+import type { WithDecrypt } from '../../core/types/coreFhevmRuntime.js';
+import type { FhevmOptions } from '../../core/types/coreFhevmClient.js';
+import type { FhevmDecryptClient } from '../../core/types/fhevmClient.js';
+import { createFhevmBaseClient } from './createFhevmBaseClient.js';
+import { decryptActions } from '../decorators/decrypt.js';
+
+////////////////////////////////////////////////////////////////////////////////
+
+export function createFhevmDecryptClient<
+  chain extends FhevmChain,
+  provider extends EthersT.ContractRunner,
+>(parameters: {
+  readonly provider: provider;
+  readonly chain: chain;
+  readonly options?: FhevmOptions | undefined;
+}): FhevmDecryptClient<chain, WithDecrypt, provider> {
+  const c = createFhevmBaseClient(parameters);
+  return c.extend(decryptActions);
+}

package/ethers/clients/createFhevmEncryptClient.ts

@@ -0,0 +1,24 @@
+import type { ethers as EthersT } from 'ethers';
+import type { FhevmChain } from '../../core/types/fhevmChain.js';
+import type { WithEncrypt } from '../../core/types/coreFhevmRuntime.js';
+import type { FhevmOptions } from '../../core/types/coreFhevmClient.js';
+import type { FhevmEncryptClient } from '../../core/types/fhevmClient.js';
+import { createFhevmBaseClient } from './createFhevmBaseClient.js';
+import { encryptActions } from '../decorators/encrypt.js';
+
+////////////////////////////////////////////////////////////////////////////////
+
+export function createFhevmEncryptClient<
+  chain extends FhevmChain,
+  provider extends EthersT.ContractRunner,
+>(parameters: {
+  readonly provider: provider;
+  readonly chain: chain;
+  readonly options?: FhevmOptions | undefined;
+}): FhevmEncryptClient<chain, WithEncrypt, provider> {
+  const c = createFhevmBaseClient(parameters);
+
+  return c.extend(encryptActions);
+}
+
+////////////////////////////////////////////////////////////////////////////////

package/ethers/decorators/decrypt.ts

@@ -0,0 +1,12 @@
+import type { FhevmChain } from '../../core/types/fhevmChain.js';
+import type { WithDecrypt } from '../../core/types/coreFhevmRuntime.js';
+import type { FhevmBase, FhevmExtension } from '../../core/types/coreFhevmClient.js';
+import type { DecryptActions } from '../../core/clients/decorators/decrypt.js';
+import { decryptActionsWithModule } from '../../core/clients/decorators/decrypt.js';
+import { decryptModule } from '../../core/modules/decrypt/module/index.js';
+
+////////////////////////////////////////////////////////////////////////////////
+
+export function decryptActions(fhevm: FhevmBase<FhevmChain>): FhevmExtension<DecryptActions, WithDecrypt> {
+  return decryptActionsWithModule(fhevm, decryptModule);
+}

package/ethers/decorators/encrypt.ts

@@ -0,0 +1,12 @@
+import type { FhevmChain } from '../../core/types/fhevmChain.js';
+import type { WithEncrypt } from '../../core/types/coreFhevmRuntime.js';
+import type { FhevmBase, FhevmExtension } from '../../core/types/coreFhevmClient.js';
+import type { EncryptActions } from '../../core/clients/decorators/encrypt.js';
+import { encryptActionsWithModule } from '../../core/clients/decorators/encrypt.js';
+import { encryptModule } from '../../core/modules/encrypt/module/index.js';
+
+////////////////////////////////////////////////////////////////////////////////
+
+export function encryptActions(fhevm: FhevmBase<FhevmChain>): FhevmExtension<EncryptActions, WithEncrypt> {
+  return encryptActionsWithModule(fhevm, encryptModule);
+}

package/ethers/index.ts

@@ -0,0 +1,10 @@
+export { setFhevmRuntimeConfig } from './internal/ethers-p.js';
+
+export { createFhevmBaseClient } from './clients/createFhevmBaseClient.js';
+export { createFhevmClient } from './clients/createFhevmClient.js';
+export { createFhevmDecryptClient } from './clients/createFhevmDecryptClient.js';
+export { createFhevmEncryptClient } from './clients/createFhevmEncryptClient.js';
+
+export { initFhevmRuntime } from './runtime/initFhevmRuntime.js';
+export { initFhevmEncryptRuntime } from './runtime/initFhevmEncryptRuntime.js';
+export { initFhevmDecryptRuntime } from './runtime/initFhevmDecryptRuntime.js';

package/ethers/internal/ethereum.ts

@@ -0,0 +1,165 @@
+import type {
+  DecodeParameters,
+  DecodeReturnType,
+  EncodePackedParameters,
+  EncodePackedReturnType,
+  EncodeParameters,
+  EncodeReturnType,
+  EthereumModuleFactory,
+  GetChainIdReturnType,
+  TrustedClient,
+  ReadContractParameters,
+  RecoverTypedDataAddressParameters,
+  RecoverTypedDataAddressReturnType,
+  SignTypedDataParameters,
+  SignTypedDataReturnType,
+  NativeSigner,
+} from '../../core/modules/ethereum/types.js';
+import type { ethers as EthersT } from 'ethers';
+import type { TypedDataField } from 'ethers';
+import type { BytesHex } from '../../core/types/primitives.js';
+import { asChecksummedAddress } from '../../core/base/address.js';
+import { AbiCoder, solidityPacked, verifyTypedData } from 'ethers';
+import { getEthersContract, getNetwork } from './utils.js';
+
+////////////////////////////////////////////////////////////////////////////////
+// encodePacked
+////////////////////////////////////////////////////////////////////////////////
+
+// eslint-disable-next-line @typescript-eslint/require-await
+export async function recoverTypedDataAddress(
+  parameters: RecoverTypedDataAddressParameters,
+): Promise<RecoverTypedDataAddressReturnType> {
+  const { primaryType, types, domain, message, signature } = parameters;
+
+  // If primaryType is specified, filter types to only include the primary type
+  // This ensures ethers uses the correct primary type for signing
+  let typesToSign: Record<string, TypedDataField[]>;
+
+  if ((primaryType as unknown) !== undefined) {
+    const primaryTypeFields = types[primaryType];
+    if (primaryTypeFields === undefined) {
+      throw new Error(`Primary type "${primaryType}" not found in types`);
+    }
+    typesToSign = { [primaryType]: primaryTypeFields };
+  } else {
+    typesToSign = types;
+  }
+
+  const recoveredAddress = verifyTypedData(domain, typesToSign, message, signature);
+
+  return asChecksummedAddress(recoveredAddress);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// encodePacked
+////////////////////////////////////////////////////////////////////////////////
+
+export function encodePacked(parameters: EncodePackedParameters): EncodePackedReturnType {
+  // Ethers impl
+  return solidityPacked(parameters.types, parameters.values) as BytesHex;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// encode
+////////////////////////////////////////////////////////////////////////////////
+
+export function encode(parameters: EncodeParameters): EncodeReturnType {
+  const abiCoder = AbiCoder.defaultAbiCoder();
+  return abiCoder.encode(parameters.types, parameters.values) as BytesHex;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// decode
+////////////////////////////////////////////////////////////////////////////////
+
+export function decode(parameters: DecodeParameters): DecodeReturnType {
+  const abiCoder = AbiCoder.defaultAbiCoder();
+  return abiCoder.decode(parameters.types, parameters.encodedData);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// readContract
+////////////////////////////////////////////////////////////////////////////////
+
+export async function readContract(
+  hostPublicClient: TrustedClient<EthersT.ContractRunner>,
+  parameters: ReadContractParameters,
+): Promise<unknown> {
+  const contract = getEthersContract<EthersT.Contract>(hostPublicClient, parameters.address, parameters.abi);
+  const result = (await contract.getFunction(parameters.functionName).staticCall(...parameters.args)) as unknown;
+  return result;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// getChainId
+////////////////////////////////////////////////////////////////////////////////
+
+export async function getChainId(
+  hostPublicClient: TrustedClient<EthersT.ContractRunner>,
+): Promise<GetChainIdReturnType> {
+  const n = await getNetwork(hostPublicClient);
+  // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-conversion
+  return BigInt(n.chainId);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// signTypedData
+////////////////////////////////////////////////////////////////////////////////
+
+export async function signTypedData(
+  signer: NativeSigner,
+  parameters: SignTypedDataParameters,
+): Promise<SignTypedDataReturnType> {
+  const { primaryType, types, domain, message } = parameters;
+
+  const ethersSigner = signer as EthersT.Signer;
+  if (typeof ethersSigner.signTypedData !== 'function') {
+    throw new Error('signer does not support signTypedData');
+  }
+
+  // Skipped: Since viem does not check anything, do the same in ethers.
+  // Transfer responsibility to caller
+  // Keep code if needed
+  /*
+  
+      const signerAddress = await ethersSigner.getAddress();
+      if (signerAddress.toLowerCase() !== parameters.account.toLowerCase()) {
+        throw new Error(
+          `Signer address mismatch: expected ${parameters.account} but signer resolved to ${signerAddress}`,
+        );
+      }
+
+  */
+
+  // ethers takes 3 separate args and filters types by primaryType
+  const primaryTypeFields = types[primaryType];
+  if (primaryTypeFields === undefined) {
+    throw new Error(`Primary type "${primaryType}" not found in types`);
+  }
+  const typesToSign: Record<string, TypedDataField[]> = {
+    [primaryType]: [...primaryTypeFields],
+  };
+
+  const signature = await ethersSigner.signTypedData(domain, typesToSign, message);
+
+  return signature as SignTypedDataReturnType;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// ethereumModule
+////////////////////////////////////////////////////////////////////////////////
+
+export const ethereumModule: EthereumModuleFactory = () => {
+  return Object.freeze({
+    ethereum: Object.freeze({
+      decode,
+      encode,
+      encodePacked,
+      recoverTypedDataAddress,
+      signTypedData,
+      getChainId,
+      readContract,
+    }),
+  });
+};