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

package/_types/viem/internal/runtime.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runtime.d.ts","sourceRoot":"","sources":["../../../viem/internal/runtime.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,sCAAsC,CAAC;AAYzE,wBAAgB,cAAc,IAAI,YAAY,CAe7C"}

package/_types/viem/internal/viem-p.d.ts

@@ -1,20 +1,8 @@
 import type { PublicClient } from 'viem';
 import type { TrustedClient } from '../../core/modules/ethereum/types.js';
-import type { FhevmRuntime, FhevmRuntimeConfig } from '../../core/types/coreFhevmRuntime.js';
+import type { FhevmRuntime } from '../../core/types/coreFhevmRuntime.js';
 import type { CreateFhevmRuntimeParameters } from '../../core/runtime/CoreFhevmRuntime-p.js';
 export declare const PRIVATE_VIEM_TOKEN: unique symbol;
-/**
- * Sets the global {@link FhevmRuntimeConfig} used by the viem adapter.
- *
- * Must be called before any runtime or client is created.
- * May be called multiple times with identical parameters (idempotent).
- * Throws if called again with different parameters.
- *
- * @param config - The runtime configuration.
- * @throws If a different config has already been set.
- */
-export declare function setFhevmRuntimeConfig(config: FhevmRuntimeConfig): void;
-export declare function getViemRuntime(): FhevmRuntime;
 /**
  * Seals a viem `PublicClient` into an opaque {@link TrustedClient}.
  *

package/_types/viem/internal/viem-p.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"viem-p.d.ts","sourceRoot":"","sources":["../../../viem/internal/viem-p.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,MAAM,CAAC;AACzC,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,sCAAsC,CAAC;AAC1E,OAAO,KAAK,EAAE,YAAY,EAAE,kBAAkB,EAAE,MAAM,sCAAsC,CAAC;AAC7F,OAAO,KAAK,EAAE,4BAA4B,EAAE,MAAM,0CAA0C,CAAC;AAU7F,eAAO,MAAM,kBAAkB,eAAuB,CAAC;AASvD;;;;;;;;;GASG;AACH,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,kBAAkB,GAAG,IAAI,CAgBtE;AAID,wBAAgB,cAAc,IAAI,YAAY,CAc7C;AAID;;;;;;;;;GASG;AACH,wBAAgB,+BAA+B,CAAC,MAAM,SAAS,YAAY,EACzE,YAAY,EAAE,MAAM,GACnB,aAAa,CAAC,MAAM,CAAC,CAEvB;AAED;;;;;;;GAOG;AACH,wBAAgB,+BAA+B,CAAC,MAAM,SAAS,YAAY,EACzE,aAAa,EAAE,aAAa,CAAC,MAAM,CAAC,GACnC,MAAM,CAER;AAID,wBAAgB,kBAAkB,CAAC,UAAU,EAAE,4BAA4B,GAAG,YAAY,CAEzF"}
+{"version":3,"file":"viem-p.d.ts","sourceRoot":"","sources":["../../../viem/internal/viem-p.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,MAAM,CAAC;AACzC,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,sCAAsC,CAAC;AAC1E,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,sCAAsC,CAAC;AACzE,OAAO,KAAK,EAAE,4BAA4B,EAAE,MAAM,0CAA0C,CAAC;AAQ7F,eAAO,MAAM,kBAAkB,eAAuB,CAAC;AAIvD;;;;;;;;;GASG;AACH,wBAAgB,+BAA+B,CAAC,MAAM,SAAS,YAAY,EACzE,YAAY,EAAE,MAAM,GACnB,aAAa,CAAC,MAAM,CAAC,CAEvB;AAED;;;;;;;GAOG;AACH,wBAAgB,+BAA+B,CAAC,MAAM,SAAS,YAAY,EACzE,aAAa,EAAE,aAAa,CAAC,MAAM,CAAC,GACnC,MAAM,CAER;AAID,wBAAgB,kBAAkB,CAAC,UAAU,EAAE,4BAA4B,GAAG,YAAY,CAEzF"}

package/_types/viem/runtime/initFhevmDecryptRuntime.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"initFhevmDecryptRuntime.d.ts","sourceRoot":"","sources":["../../../viem/runtime/initFhevmDecryptRuntime.ts"],"names":[],"mappings":"AAKA,wBAAgB,uBAAuB,IAAI,OAAO,CAAC,IAAI,CAAC,CAEvD"}
+{"version":3,"file":"initFhevmDecryptRuntime.d.ts","sourceRoot":"","sources":["../../../viem/runtime/initFhevmDecryptRuntime.ts"],"names":[],"mappings":"AAMA,wBAAgB,uBAAuB,IAAI,OAAO,CAAC,IAAI,CAAC,CAEvD"}

package/_types/viem/runtime/initFhevmEncryptRuntime.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"initFhevmEncryptRuntime.d.ts","sourceRoot":"","sources":["../../../viem/runtime/initFhevmEncryptRuntime.ts"],"names":[],"mappings":"AAKA,wBAAgB,uBAAuB,IAAI,OAAO,CAAC,IAAI,CAAC,CAEvD"}
+{"version":3,"file":"initFhevmEncryptRuntime.d.ts","sourceRoot":"","sources":["../../../viem/runtime/initFhevmEncryptRuntime.ts"],"names":[],"mappings":"AAMA,wBAAgB,uBAAuB,IAAI,OAAO,CAAC,IAAI,CAAC,CAEvD"}

package/_types/viem/runtime/initFhevmRuntime.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"initFhevmRuntime.d.ts","sourceRoot":"","sources":["../../../viem/runtime/initFhevmRuntime.ts"],"names":[],"mappings":"AAKA,wBAAgB,gBAAgB,IAAI,OAAO,CAAC,IAAI,CAAC,CAEhD"}
+{"version":3,"file":"initFhevmRuntime.d.ts","sourceRoot":"","sources":["../../../viem/runtime/initFhevmRuntime.ts"],"names":[],"mappings":"AAMA,wBAAgB,gBAAgB,IAAI,OAAO,CAAC,IAAI,CAAC,CAEhD"}

package/core/_version.ts

@@ -1,3 +1,3 @@
 // This file is auto-generated
-export const version: string = '1.0.0-alpha.1';
+export const version: string = '1.0.0-alpha.3';
 export const sdkName: string = '@fhevm/sdk';

package/core/actions/base/fetchVerifiedInputProof.ts

@@ -20,6 +20,6 @@ export async function fetchVerifiedInputProof(
   parameters: FetchVerifiedInputProofParameters,
 ): Promise<FetchVerifiedInputProofReturnType> {
   const { zkProof, ...rest } = parameters;
-  const sanitizedZkProof = await toZkProof(zkProof);
+  const sanitizedZkProof = await toZkProof(zkProof, parameters.extraData);
   return fetchVerifiedInputProof_(fhevm, { zkProof: sanitizedZkProof, ...rest });
 }

package/core/actions/base/signDecryptionPermit.ts

@@ -23,10 +23,12 @@ 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,

package/core/actions/chain/index.ts

@@ -1,6 +1,6 @@
 export {
-  type VerifyKmsDelegatedUserDecryptEIP712Parameters,
-  verifyKmsDelegatedUserDecryptEip712 as verifyKmsDelegatedUserDecryptEIP712,
+  type VerifyKmsDelegatedUserDecryptEip712Parameters,
+  verifyKmsDelegatedUserDecryptEip712,
 } from './verifyKmsDelegatedUserDecryptEip712.js';
 
 export { type CreateKmsEIP712DomainReturnType, createKmsEIP712Domain } from './createKmsEip712Domain.js';
@@ -12,15 +12,15 @@ export {
 } from './fetchFheEncryptionKeyBytes.js';
 
 export {
-  type ParseTransportKeypairParameters as ParseE2eTransportKeypairParameters,
-  type ParseTransportKeypairReturnType as ParseE2eTransportKeypairReturnType,
-  parseTransportKeypair as parseE2eTransportKeypair,
+  type ParseTransportKeypairParameters,
+  type ParseTransportKeypairReturnType,
+  parseTransportKeypair,
 } from './parseTransportKeypair.js';
 
 export {
-  type SerializeTransportKeypairParameters as SerializeE2eTransportKeypairParameters,
-  type SerializeTransportKeypairReturnType as SerializeE2eTransportKeypairReturnType,
-  serializeTransportKeypair as serializeE2eTransportKeypair,
+  type SerializeTransportKeypairParameters,
+  type SerializeTransportKeypairReturnType,
+  serializeTransportKeypair,
 } from './serializeTransportKeypair.js';
 
 export {
@@ -45,9 +45,9 @@ export {
 } from '../base/signDecryptionPermit.js';
 
 export {
-  type CreateKmsUserDecryptEip712Parameters as CreateKmsUserDecryptEIP712Parameters,
-  type CreateKmsUserDecryptEip712ReturnType as CreateKmsUserDecryptEIP712ReturnType,
-  createKmsUserDecryptEip712 as createKmsUserDecryptEIP712,
+  type CreateKmsUserDecryptEip712Parameters,
+  type CreateKmsUserDecryptEip712ReturnType,
+  createKmsUserDecryptEip712,
 } from './createKmsUserDecryptEip712.js';
 
 export {

package/core/actions/chain/parseSignedDecryptionPermit.ts

@@ -2,13 +2,18 @@ import type { Fhevm } from '../../types/coreFhevmClient.js';
 import type { FhevmChain } from '../../types/fhevmChain.js';
 import type { SignedDecryptionPermit } from '../../types/signedDecryptionPermit.js';
 import type { TransportKeypair } from '../../kms/TransportKeypair-p.js';
+import type { KmsDecryptEip712Like } from '../../types/kms.js';
 import { parseSignedDecryptionPermit as parseSignedDecryptionPermit_ } from '../../kms/SignedDecryptionPermit-p.js';
 
 ////////////////////////////////////////////////////////////////////////////////
 
 export type ParseSignedDecryptionPermitParameters = {
-  /** The serialized permit — a JSON string or a previously parsed object. */
-  readonly serialized: string | Record<string, unknown>;
+  /** The serialized permit — a previously parsed permit object. */
+  readonly serializedPermit: {
+    readonly eip712: KmsDecryptEip712Like;
+    readonly signature: string;
+    readonly signerAddress: string;
+  };
   /** The transport keypair that was used when signing the permit. */
   readonly transportKeypair: TransportKeypair;
 };
@@ -27,9 +32,7 @@ export async function parseSignedDecryptionPermit(
   fhevm: Fhevm<FhevmChain>,
   parameters: ParseSignedDecryptionPermitParameters,
 ): Promise<ParseSignedDecryptionPermitReturnType> {
-  const { serialized, transportKeypair } = parameters;
+  const { serializedPermit, transportKeypair } = parameters;
 
-  const parsed = typeof serialized === 'string' ? (JSON.parse(serialized) as unknown) : serialized;
-
-  return parseSignedDecryptionPermit_(fhevm, transportKeypair, parsed);
+  return parseSignedDecryptionPermit_(fhevm, transportKeypair, serializedPermit);
 }

package/core/actions/chain/parseTransportKeypair.ts

@@ -6,8 +6,8 @@ import { toTransportKeypair, type TransportKeypair } from '../../kms/TransportKe
 ////////////////////////////////////////////////////////////////////////////////
 
 export type ParseTransportKeypairParameters = {
-  /** The serialized keypair — output of `serializeE2eTransportKeypair` or a previously parsed object. */
-  readonly serialized: string | Record<string, unknown>;
+  readonly publicKey: string;
+  readonly privateKey: string;
 };
 
 export type ParseTransportKeypairReturnType = TransportKeypair;
@@ -16,9 +16,5 @@ export async function parseTransportKeypair(
   fhevm: Fhevm<FhevmChain, FhevmRuntime, OptionalNativeClient>,
   parameters: ParseTransportKeypairParameters,
 ): Promise<ParseTransportKeypairReturnType> {
-  const parsed =
-    typeof parameters.serialized === 'string' ? (JSON.parse(parameters.serialized) as unknown) : parameters.serialized;
-  return toTransportKeypair(fhevm, parsed);
+  return toTransportKeypair(fhevm, parameters);
 }
-
-////////////////////////////////////////////////////////////////////////////////

package/core/actions/chain/serializeTransportKeypair.ts

@@ -24,5 +24,3 @@ export function serializeTransportKeypair(
 ): SerializeTransportKeypairReturnType {
   return serializeTransportKeypair_(parameters.transportKeypair);
 }
-
-////////////////////////////////////////////////////////////////////////////////

package/core/actions/chain/verifyKmsDelegatedUserDecryptEip712.ts

@@ -6,7 +6,7 @@ import {
   type VerifyKmsDelegatedUserDecryptEip712Parameters,
 } from '../../utils-p/decrypt/verifyKmsDelegatedUserDecryptEip712.js';
 
-export type { VerifyKmsDelegatedUserDecryptEip712Parameters as VerifyKmsDelegatedUserDecryptEIP712Parameters };
+export type { VerifyKmsDelegatedUserDecryptEip712Parameters };
 
 export async function verifyKmsDelegatedUserDecryptEip712(
   fhevm: Fhevm<FhevmChain, FhevmRuntime, OptionalNativeClient>,

package/core/actions/decrypt/decryptValue.ts

@@ -1,12 +1,8 @@
-/* eslint-disable @typescript-eslint/unified-signatures */
 import type { Fhevm } from '../../types/coreFhevmClient.js';
 import type { TypedValue } from '../../types/primitives.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 { SignedDecryptionPermit } from '../../types/signedDecryptionPermit.js';
 import type { WithDecrypt } from '../../types/coreFhevmRuntime.js';
 import type { TransportKeypair } from '../../kms/TransportKeypair-p.js';
 import type { EncryptedValueLike } from '../../types/encryptedTypes.js';
@@ -16,20 +12,12 @@ import { toFhevmHandle } from '../../handle/FhevmHandle.js';
 
 ////////////////////////////////////////////////////////////////////////////////
 
-type DecryptValueParametersBase = {
+export type DecryptValueParameters = {
   readonly encryptedValue: EncryptedValueLike;
   readonly contractAddress: string;
   readonly transportKeypair: TransportKeypair;
-};
-
-export type DecryptSelfValueParameters = DecryptValueParametersBase & {
-  readonly signedPermit: SignedSelfDecryptionPermit;
-  readonly options?: RelayerUserDecryptOptions | undefined;
-};
-
-export type DecryptDelegatedValueParameters = DecryptValueParametersBase & {
-  readonly signedPermit: SignedDelegatedDecryptionPermit;
-  readonly options?: RelayerDelegatedUserDecryptOptions | undefined;
+  readonly signedPermit: SignedDecryptionPermit;
+  readonly options?: RelayerUserDecryptOptions | RelayerDelegatedUserDecryptOptions | undefined;
 };
 
 export type DecryptValueReturnType = TypedValue;
@@ -38,17 +26,7 @@ export type DecryptValueReturnType = TypedValue;
 
 export async function decryptValue(
   fhevm: Fhevm<FhevmChain, WithDecrypt>,
-  parameters: DecryptSelfValueParameters,
-): Promise<DecryptValueReturnType>;
-
-export async function decryptValue(
-  fhevm: Fhevm<FhevmChain, WithDecrypt>,
-  parameters: DecryptDelegatedValueParameters,
-): Promise<DecryptValueReturnType>;
-
-export async function decryptValue(
-  fhevm: Fhevm<FhevmChain, WithDecrypt>,
-  parameters: DecryptSelfValueParameters | DecryptDelegatedValueParameters,
+  parameters: DecryptValueParameters,
 ): Promise<DecryptValueReturnType> {
   const { encryptedValue, contractAddress, ...rest } = parameters;
 
@@ -62,7 +40,10 @@ export async function decryptValue(
     },
   ];
 
-  const typedValues = await decryptValuesFromPairs_(fhevm, { ...rest, pairs: sanitizedPairs });
+  const typedValues = await decryptValuesFromPairs_(fhevm, {
+    ...rest,
+    pairs: sanitizedPairs,
+  } as Parameters<typeof decryptValuesFromPairs_>[1]);
 
   // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
   return typedValues[0]!;

package/core/actions/decrypt/decryptValues.ts

@@ -1,12 +1,8 @@
-/* eslint-disable @typescript-eslint/unified-signatures */
 import type { Fhevm } from '../../types/coreFhevmClient.js';
 import type { TypedValue } from '../../types/primitives.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 { SignedDecryptionPermit } from '../../types/signedDecryptionPermit.js';
 import type { WithDecrypt } from '../../types/coreFhevmRuntime.js';
 import type { TransportKeypair } from '../../kms/TransportKeypair-p.js';
 import type { EncryptedValueLike } from '../../types/encryptedTypes.js';
@@ -16,20 +12,12 @@ import { toFhevmHandle } from '../../handle/FhevmHandle.js';
 
 ////////////////////////////////////////////////////////////////////////////////
 
-type DecryptValuesParametersBase = {
+export type DecryptValuesParameters = {
   readonly encryptedValues: readonly EncryptedValueLike[];
   readonly contractAddress: string;
   readonly transportKeypair: TransportKeypair;
-};
-
-export type DecryptSelfValuesParameters = DecryptValuesParametersBase & {
-  readonly signedPermit: SignedSelfDecryptionPermit;
-  readonly options?: RelayerUserDecryptOptions | undefined;
-};
-
-export type DecryptDelegatedValuesParameters = DecryptValuesParametersBase & {
-  readonly signedPermit: SignedDelegatedDecryptionPermit;
-  readonly options?: RelayerDelegatedUserDecryptOptions | undefined;
+  readonly signedPermit: SignedDecryptionPermit;
+  readonly options?: RelayerUserDecryptOptions | RelayerDelegatedUserDecryptOptions | undefined;
 };
 
 export type DecryptValuesReturnType = readonly TypedValue[];
@@ -38,17 +26,7 @@ export type DecryptValuesReturnType = readonly TypedValue[];
 
 export async function decryptValues(
   fhevm: Fhevm<FhevmChain, WithDecrypt>,
-  parameters: DecryptSelfValuesParameters,
-): Promise<DecryptValuesReturnType>;
-
-export async function decryptValues(
-  fhevm: Fhevm<FhevmChain, WithDecrypt>,
-  parameters: DecryptDelegatedValuesParameters,
-): Promise<DecryptValuesReturnType>;
-
-export async function decryptValues(
-  fhevm: Fhevm<FhevmChain, WithDecrypt>,
-  parameters: DecryptSelfValuesParameters | DecryptDelegatedValuesParameters,
+  parameters: DecryptValuesParameters,
 ): Promise<DecryptValuesReturnType> {
   const { encryptedValues, contractAddress, ...rest } = parameters;
 
@@ -62,5 +40,8 @@ export async function decryptValues(
     };
   });
 
-  return decryptValuesFromPairs_(fhevm, { ...rest, pairs: sanitizedPairs });
+  return decryptValuesFromPairs_(fhevm, {
+    ...rest,
+    pairs: sanitizedPairs,
+  } as Parameters<typeof decryptValuesFromPairs_>[1]);
 }

package/core/actions/decrypt/decryptValuesFromPairs.ts

@@ -1,12 +1,8 @@
-/* eslint-disable @typescript-eslint/unified-signatures */
 import type { Fhevm } from '../../types/coreFhevmClient.js';
 import type { TypedValue } from '../../types/primitives.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 { SignedDecryptionPermit } from '../../types/signedDecryptionPermit.js';
 import type { WithDecrypt } from '../../types/coreFhevmRuntime.js';
 import type { TransportKeypair } from '../../kms/TransportKeypair-p.js';
 import type { EncryptedValueLike } from '../../types/encryptedTypes.js';
@@ -16,22 +12,14 @@ import { toFhevmHandle } from '../../handle/FhevmHandle.js';
 
 ////////////////////////////////////////////////////////////////////////////////
 
-type DecryptValuesFromPairsParametersBase = {
+export type DecryptValuesFromPairsParameters = {
   readonly pairs: ReadonlyArray<{
     readonly encryptedValue: EncryptedValueLike;
     readonly contractAddress: string;
   }>;
   readonly transportKeypair: TransportKeypair;
-};
-
-export type DecryptSelfValuesFromPairsParameters = DecryptValuesFromPairsParametersBase & {
-  readonly signedPermit: SignedSelfDecryptionPermit;
-  readonly options?: RelayerUserDecryptOptions | undefined;
-};
-
-export type DecryptDelegatedValuesFromPairsParameters = DecryptValuesFromPairsParametersBase & {
-  readonly signedPermit: SignedDelegatedDecryptionPermit;
-  readonly options?: RelayerDelegatedUserDecryptOptions | undefined;
+  readonly signedPermit: SignedDecryptionPermit;
+  readonly options?: RelayerUserDecryptOptions | RelayerDelegatedUserDecryptOptions | undefined;
 };
 
 export type DecryptValuesFromPairsReturnType = readonly TypedValue[];
@@ -40,17 +28,7 @@ export type DecryptValuesFromPairsReturnType = readonly TypedValue[];
 
 export async function decryptValuesFromPairs(
   fhevm: Fhevm<FhevmChain, WithDecrypt>,
-  parameters: DecryptSelfValuesFromPairsParameters,
-): Promise<DecryptValuesFromPairsReturnType>;
-
-export async function decryptValuesFromPairs(
-  fhevm: Fhevm<FhevmChain, WithDecrypt>,
-  parameters: DecryptDelegatedValuesFromPairsParameters,
-): Promise<DecryptValuesFromPairsReturnType>;
-
-export async function decryptValuesFromPairs(
-  fhevm: Fhevm<FhevmChain, WithDecrypt>,
-  parameters: DecryptSelfValuesFromPairsParameters | DecryptDelegatedValuesFromPairsParameters,
+  parameters: DecryptValuesFromPairsParameters,
 ): Promise<DecryptValuesFromPairsReturnType> {
   const { pairs, ...rest } = parameters;
 
@@ -62,5 +40,8 @@ export async function decryptValuesFromPairs(
     };
   });
 
-  return decryptValuesFromPairs_(fhevm, { ...rest, pairs: sanitizedPairs });
+  return decryptValuesFromPairs_(fhevm, {
+    ...rest,
+    pairs: sanitizedPairs,
+  } as Parameters<typeof decryptValuesFromPairs_>[1]);
 }

package/core/actions/decrypt/index.ts

@@ -10,25 +10,14 @@ export {
 } from './generateTransportKeypair.js';
 
 export {
-  type DecryptSelfValuesFromPairsParameters,
-  type DecryptDelegatedValuesFromPairsParameters,
+  type DecryptValuesFromPairsParameters,
   type DecryptValuesFromPairsReturnType,
   decryptValuesFromPairs,
 } from './decryptValuesFromPairs.js';
 
-export {
-  type DecryptSelfValueParameters,
-  type DecryptDelegatedValueParameters,
-  type DecryptValueReturnType,
-  decryptValue,
-} from './decryptValue.js';
+export { type DecryptValueParameters, type DecryptValueReturnType, decryptValue } from './decryptValue.js';
 
-export {
-  type DecryptSelfValuesParameters,
-  type DecryptDelegatedValuesParameters,
-  type DecryptValuesReturnType,
-  decryptValues,
-} from './decryptValues.js';
+export { type DecryptValuesParameters, type DecryptValuesReturnType, decryptValues } from './decryptValues.js';
 
 export {
   type DecryptKmsSignedcryptedSharesParameters,

package/core/actions/host/getUserDecryptionDelegationExpirationDate.ts

@@ -1,32 +1,36 @@
 import type { Fhevm } from '../../types/coreFhevmClient.js';
-import type { ChecksummedAddress, Uint64BigInt } from '../../types/primitives.js';
-import { isUint64 } from '../../base/uint.js';
-import { getUserDecryptionDelegationExpirationDateAbi } from '../../host-contracts/abi-fragments/fragments.js';
-import { getTrustedClient } from '../../runtime/CoreFhevm-p.js';
+import type { Uint64BigInt } from '../../types/primitives.js';
+import { addressToChecksummedAddress, assertIsAddress } from '../../base/address.js';
+import { getUserDecryptionDelegationExpirationDate as getUserDecryptionDelegationExpirationDate_ } from '../../host-contracts/getUserDecryptionDelegationExpirationDate.js';
+
+////////////////////////////////////////////////////////////////////////////////
 
 export type GetUserDecryptionDelegationExpirationDateParameters = {
-  readonly address: ChecksummedAddress;
+  readonly address: string;
+  readonly delegator: string;
+  readonly delegate: string;
+  readonly contractAddress: string;
 };
 
 export type GetUserDecryptionDelegationExpirationDateReturnType = Uint64BigInt;
 
+////////////////////////////////////////////////////////////////////////////////
+
 export async function getUserDecryptionDelegationExpirationDate(
   fhevm: Fhevm,
   parameters: GetUserDecryptionDelegationExpirationDateParameters,
 ): Promise<GetUserDecryptionDelegationExpirationDateReturnType> {
-  const trustedClient = getTrustedClient(fhevm);
-  const address = parameters.address;
+  const { address, delegate, delegator, contractAddress } = parameters;
 
-  const res = await fhevm.runtime.ethereum.readContract(trustedClient, {
-    address: address,
-    abi: getUserDecryptionDelegationExpirationDateAbi,
-    args: [],
-    functionName: getUserDecryptionDelegationExpirationDateAbi[0].name,
-  });
+  assertIsAddress(address, {});
+  assertIsAddress(delegate, {});
+  assertIsAddress(delegator, {});
+  assertIsAddress(contractAddress, {});
 
-  if (!isUint64(res)) {
-    throw new Error(`Invalid expiration date.`);
-  }
-
-  return BigInt(res) as Uint64BigInt;
+  return getUserDecryptionDelegationExpirationDate_(fhevm, {
+    address: addressToChecksummedAddress(address),
+    delegate: addressToChecksummedAddress(delegate),
+    delegator: addressToChecksummedAddress(delegator),
+    contractAddress: addressToChecksummedAddress(contractAddress),
+  });
 }

package/core/base/bytes.ts

@@ -2058,3 +2058,11 @@ export function bytesHexSlice(bytesHex: BytesHex, position: Uint8Number, length:
   }
   return `0x${bytesHex.slice(index, index + 2 * length)}` as BytesHex;
 }
+
+export function createDeadbeefBytes(numBytes: number): Uint8Array {
+  const length = numBytes > 0 ? Math.ceil(numBytes / 4) * 4 : 0;
+  const buf = new ArrayBuffer(length);
+  const isLE = new Uint8Array(new Uint16Array([1]).buffer)[0] === 1;
+  new Uint32Array(buf).fill(isLE ? 0xefbeadde : 0xdeadbeef);
+  return new Uint8Array(buf).subarray(0, numBytes);
+}

package/core/base/sign.ts

@@ -0,0 +1,75 @@
+import type { Address, Bytes65Hex, BytesHex, ChecksummedAddress } from '../types/primitives.js';
+import { secp256k1 } from '@noble/curves/secp256k1';
+import { keccak_256 } from '@noble/hashes/sha3.js';
+import { addressToChecksummedAddress } from './address.js';
+import { bytesToHex } from './bytes.js';
+
+export function sign({ hash, privateKey }: { readonly hash: BytesHex; readonly privateKey: BytesHex }): Bytes65Hex {
+  const sig = secp256k1.sign(hash.slice(2), privateKey.slice(2), {
+    lowS: true,
+    extraEntropy: true,
+  });
+
+  if (sig.recovery !== 0 && sig.recovery !== 1) {
+    throw new Error('Unexpected signature recovery value');
+  }
+
+  const signatureHex = `0x${sig.toCompactHex()}${sig.recovery === 0 ? '1b' : '1c'}` as BytesHex;
+
+  if (signatureHex.length !== 2 + 130) {
+    throw new Error('Unexpected signature length');
+  }
+
+  return signatureHex as Bytes65Hex;
+}
+
+/**
+ * Recover the secp256k1 public key (uncompressed, 65 bytes prefixed by 0x04)
+ * that produced `signature` over `hash`. Inverse of `sign(...)`.
+ *
+ * Simplified vs viem's `recoverPublicKey`: only accepts the canonical hex
+ * forms emitted by `sign(...)` — `hash` is `BytesHex`, `signature` is the
+ * 65-byte (r || s || v) `Bytes65Hex` with v in `{0x1b, 0x1c}` (legacy 27/28)
+ * or `{0x00, 0x01}` (raw yParity).
+ */
+function _recoverPublicKey(parameters: { readonly hash: BytesHex; readonly signature: Bytes65Hex }): Uint8Array {
+  const { hash, signature } = parameters;
+
+  if (signature.length !== 2 + 130) {
+    throw new Error('Unexpected signature length');
+  }
+
+  const compactHex = signature.slice(2, 130); // r || s, 64 bytes (128 hex chars)
+  const v = parseInt(signature.slice(130), 16); // 1 byte (2 hex chars)
+
+  // v is one of {0, 1, 27, 28} — anything else is malformed.
+  const recoveryBit = v === 0 || v === 1 ? v : v === 27 ? 0 : v === 28 ? 1 : -1;
+  if (recoveryBit !== 0 && recoveryBit !== 1) {
+    throw new Error(`Invalid v value: ${v}`);
+  }
+
+  const sig = secp256k1.Signature.fromCompact(compactHex).addRecoveryBit(recoveryBit);
+
+  // toRawBytes(false) → uncompressed encoding: 0x04 || X (32) || Y (32) = 65 bytes.
+  return sig.recoverPublicKey(hash.slice(2)).toRawBytes(false);
+}
+
+function _keccak256(bytes: Uint8Array): Uint8Array {
+  return keccak_256(bytes);
+}
+
+function _publicKeyToAddress(publicKey: Uint8Array): ChecksummedAddress {
+  if (publicKey.length !== 65) {
+    throw new Error('Expected uncompressed public key (65 bytes)');
+  }
+  // Drop the 0x04 prefix tag, keccak256 over X||Y, take the last 20 bytes.
+  const last20 = _keccak256(publicKey.subarray(1)).subarray(-20);
+  return addressToChecksummedAddress(bytesToHex(last20) as Address);
+}
+
+export function recoverAddress(parameters: {
+  readonly hash: BytesHex;
+  readonly signature: Bytes65Hex;
+}): ChecksummedAddress {
+  return _publicKeyToAddress(_recoverPublicKey(parameters));
+}

package/core/base/typedValue.ts

@@ -2,6 +2,7 @@ import type { ErrorMetadataParams } from './errors/ErrorBase.js';
 import type {
   AddressValueLike,
   BoolValueLike,
+  Bytes32Hex,
   TypedValue,
   TypedValueFrom,
   TypedValueLike,
@@ -20,6 +21,7 @@ import { asAddress } from './address.js';
 import { toBoolean } from './boolean.js';
 import { InvalidTypeError } from './errors/InvalidTypeError.js';
 import { asUintForType, normalizeUintForType } from './uint.js';
+import { bigIntToBytesHex } from './bytes.js';
 
 ////////////////////////////////////////////////////////////////////////////////
 
@@ -324,3 +326,19 @@ export class TypedValueArrayBuilder {
     return Object.freeze([...this.#arr]);
   }
 }
+
+export function typedValueToBytes32Hex(typedValue: TypedValue): Bytes32Hex {
+  assertIsTypedValue(typedValue, {});
+  switch (typedValue.type) {
+    case 'uint8':
+    case 'uint16':
+    case 'uint32':
+    case 'uint64':
+    case 'uint128':
+    case 'uint256':
+    case 'address':
+      return bigIntToBytesHex(BigInt(typedValue.value), { byteLength: 32 });
+    case 'bool':
+      return bigIntToBytesHex(typedValue.value ? 1n : 0n, { byteLength: 32 });
+  }
+}

package/core/base/uint.ts

@@ -628,3 +628,35 @@ export function assertRecordUintBigIntProperty<K extends string>(
     );
   }
 }
+
+export function parseUintBigIntString(value: string): bigint | undefined {
+  let parsed: bigint;
+  try {
+    parsed = BigInt(value);
+  } catch {
+    return undefined;
+  }
+  if (parsed < 0n || parsed.toString() !== value) {
+    return undefined;
+  }
+  return parsed;
+}
+
+/** Returns `count` unique integers drawn uniformly from [0, n-1]. Mock/debug only. */
+export function randomUniqueUints(n: number, count: number): number[] {
+  if (count > n) {
+    throw new RangeError(`count ${count} cannot exceed n ${n}`);
+  }
+  const pool = Array.from({ length: n }, (_, i) => i);
+  for (let i = 0; i < count; i++) {
+    const j = i + Math.floor(Math.random() * (n - i));
+    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+    const pi = pool[i]!;
+    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+    const pj = pool[j]!;
+
+    pool[i] = pj;
+    pool[j] = pi;
+  }
+  return pool.slice(0, count);
+}