@fhevm/sdk 1.0.0-alpha.2 → 1.0.0-alpha.4

package/core/base/uint.ts

@@ -444,6 +444,36 @@ export function normalizeUintForType<T extends UintTypeName>(value: Uint, typeNa
   }
 }
 
+const UINT_TYPE_NAMES = [
+  'uint8',
+  'uint16',
+  'uint32',
+  'uint64',
+  'uint128',
+  'uint160',
+  'uint256',
+] as const satisfies readonly UintTypeName[];
+
+export function isUintTypeName(value: unknown): value is UintTypeName {
+  return typeof value === 'string' && (UINT_TYPE_NAMES as readonly string[]).includes(value);
+}
+
+export function assertIsUintTypeName(
+  value: unknown,
+  options: { subject?: string } & ErrorMetadataParams = {},
+): asserts value is UintTypeName {
+  if (!isUintTypeName(value)) {
+    throw new InvalidTypeError(
+      {
+        subject: options.subject,
+        type: typeof value,
+        expectedType: UINT_TYPE_NAMES,
+      },
+      options,
+    );
+  }
+}
+
 ////////////////////////////////////////////////////////////////////////////////
 // asUintXX
 ////////////////////////////////////////////////////////////////////////////////

package/core/host-contracts/checkDelegation.ts

@@ -0,0 +1,129 @@
+import type { FhevmRuntime } from '../types/coreFhevmRuntime.js';
+import type { Handle } from '../types/encryptedTypes-p.js';
+import type { ChecksummedAddress } from '../types/primitives.js';
+import type { HandleContractPair } from '../types/other-p.js';
+import { AclUserDecryptionError } from '../errors/AclError.js';
+import { isHandleDelegatedForUserDecryption } from './isHandleDelegatedForUserDecryption-p.js';
+import { WILDCARD_DELEGATION_ADDRESS } from './constants.js';
+
+////////////////////////////////////////////////////////////////////////////////
+
+type Context = {
+  readonly runtime: FhevmRuntime;
+  readonly client: NonNullable<object>;
+  readonly options: { readonly batchRpcCalls: boolean };
+};
+
+type Parameters = {
+  readonly address: ChecksummedAddress;
+  readonly delegator: ChecksummedAddress;
+  readonly delegate: ChecksummedAddress;
+  readonly handleContractPairs: ReadonlyArray<{
+    readonly handle: Handle;
+    readonly contractAddress: ChecksummedAddress;
+  }>;
+};
+
+////////////////////////////////////////////////////////////////////////////////
+
+export async function checkDelegation(context: Context, parameters: Parameters): Promise<void> {
+  const { address, delegator, delegate, handleContractPairs } = parameters;
+
+  if (handleContractPairs.length === 0) {
+    throw new Error('checkDelegation requires at least one (handle, contractAddress) pair');
+  }
+
+  // runtime defensive check, use lowercase
+  function getKey(addr: string, handleBytes32Hex: string): string {
+    return `${addr}:${handleBytes32Hex}`.toLowerCase();
+  }
+
+  // 1. Verify rule: delegator !== delegate
+  if (delegator.toLowerCase() === delegate.toLowerCase()) {
+    throw new AclUserDecryptionError({
+      contractAddress: address,
+      message: `delegator ${delegator} cannot be equal to delegate`,
+    });
+  }
+
+  // 2. Verify rule: delegate !== WILDCARD_CONTRACT
+  if (delegate.toLowerCase() === WILDCARD_DELEGATION_ADDRESS.toLowerCase()) {
+    throw new AclUserDecryptionError({
+      contractAddress: address,
+      message: `delegate cannot be equal to wildcard contract address`,
+    });
+  }
+  if (delegator.toLowerCase() === WILDCARD_DELEGATION_ADDRESS.toLowerCase()) {
+    throw new AclUserDecryptionError({
+      contractAddress: address,
+      message: `delegator cannot be equal to wildcard contract address`,
+    });
+  }
+
+  // 3. Verify rules: delegator !== contractAddress & delegate !== contractAddress
+  for (const pair of handleContractPairs) {
+    if (delegator.toLowerCase() === pair.contractAddress.toLowerCase()) {
+      throw new AclUserDecryptionError({
+        contractAddress: address,
+        message: `delegator ${delegator} cannot be equal to contractAddress`,
+      });
+    }
+    if (delegate.toLowerCase() === pair.contractAddress.toLowerCase()) {
+      throw new AclUserDecryptionError({
+        contractAddress: address,
+        message: `delegate ${delegate} cannot be equal to contractAddress`,
+      });
+    }
+  }
+
+  // 4. Collect all unique (contractAddress, handle) pairs to avoid duplicate RPC calls
+  const allChecks: HandleContractPair[] = [];
+  const seenKeys = new Set<string>();
+
+  for (const pair of handleContractPairs) {
+    // runtime defensive check, use lowercase
+    const key = getKey(pair.contractAddress, pair.handle.bytes32Hex);
+    if (!seenKeys.has(key)) {
+      seenKeys.add(key);
+      allChecks.push({
+        handle: pair.handle,
+        contractAddress: pair.contractAddress,
+      });
+    }
+  }
+
+  if (allChecks.length === 0) {
+    throw new Error('checkDelegation: no delegation checks to perform (unexpected empty dedup result)');
+  }
+
+  // 5. Single batched RPC call for all unique checks
+  const allResults = await isHandleDelegatedForUserDecryption(context, {
+    address,
+    delegator,
+    delegate,
+    pairs: allChecks,
+  });
+
+  // 6. Build result map for lookup
+  const resultMap = new Map<string, boolean>();
+  for (const [i, check] of allChecks.entries()) {
+    const result = allResults[i];
+    // tsc: noUncheckedIndexedAccess
+    if (result === undefined) {
+      throw new Error(`Missing result at index ${i}`);
+    }
+    const key = getKey(check.contractAddress, check.handle.bytes32Hex);
+    resultMap.set(key, result);
+  }
+
+  // 7. Verify delegation for each requested pair
+  for (const pair of handleContractPairs) {
+    const key = getKey(pair.contractAddress, pair.handle.bytes32Hex);
+    if (resultMap.get(key) !== true) {
+      throw new AclUserDecryptionError({
+        contractAddress: address,
+        message: `Delegate ${delegate} is not delegated by ${delegator} to user decrypt handle ${pair.handle.bytes32Hex} on contract ${pair.contractAddress}!`,
+      });
+    }
+  }
+}

package/core/host-contracts/constants.ts

@@ -0,0 +1,3 @@
+import type { ChecksummedAddress } from '../types/primitives.js';
+
+export const WILDCARD_DELEGATION_ADDRESS = '0xFFfFfFffFFfffFFfFFfFFFFFffFFFffffFfFFFfF' as ChecksummedAddress;

package/core/host-contracts/getUserDecryptionDelegationExpirationDate.ts

@@ -0,0 +1,45 @@
+import type { FhevmRuntime } from '../types/coreFhevmRuntime.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';
+
+////////////////////////////////////////////////////////////////////////////////
+
+type Context = {
+  readonly runtime: FhevmRuntime;
+  readonly client: NonNullable<object>;
+  readonly options: { readonly batchRpcCalls: boolean };
+};
+
+type Parameters = {
+  readonly address: ChecksummedAddress;
+  readonly delegator: ChecksummedAddress;
+  readonly delegate: ChecksummedAddress;
+  readonly contractAddress: ChecksummedAddress;
+};
+
+type ReturnType = Uint64BigInt;
+
+////////////////////////////////////////////////////////////////////////////////
+
+export async function getUserDecryptionDelegationExpirationDate(
+  context: Context,
+  parameters: Parameters,
+): Promise<ReturnType> {
+  const trustedClient = getTrustedClient(context);
+  const address = parameters.address;
+
+  const res = await context.runtime.ethereum.readContract(trustedClient, {
+    address: address,
+    abi: getUserDecryptionDelegationExpirationDateAbi,
+    args: [parameters.delegator, parameters.delegate, parameters.contractAddress],
+    functionName: getUserDecryptionDelegationExpirationDateAbi[0].name,
+  });
+
+  if (!isUint64(res)) {
+    throw new Error(`Invalid expiration date.`);
+  }
+
+  return BigInt(res) as Uint64BigInt;
+}

package/core/host-contracts/isHandleDelegatedForUserDecryption-p.ts

@@ -0,0 +1,77 @@
+import type { ChecksummedAddress } from '../types/primitives.js';
+import type { FhevmRuntime } from '../types/coreFhevmRuntime.js';
+import type { Handle } from '../types/encryptedTypes-p.js';
+import type { HandleContractPair } from '../types/other-p.js';
+import { isHandleDelegatedForUserDecryptionAbi } from './abi-fragments/fragments.js';
+import { getTrustedClient } from '../runtime/CoreFhevm-p.js';
+import { executeWithBatching } from '../base/promise.js';
+
+////////////////////////////////////////////////////////////////////////////////
+
+type Context = {
+  readonly runtime: FhevmRuntime;
+  readonly client: NonNullable<object>;
+  readonly options: { readonly batchRpcCalls: boolean };
+};
+
+type Parameters = {
+  readonly address: ChecksummedAddress;
+  readonly delegate: ChecksummedAddress;
+  readonly delegator: ChecksummedAddress;
+  readonly pairs: readonly HandleContractPair[];
+};
+
+type ReturnType = boolean[];
+
+////////////////////////////////////////////////////////////////////////////////
+
+export async function isHandleDelegatedForUserDecryption(
+  context: Context,
+  parameters: Parameters,
+): Promise<ReturnType> {
+  const { address, delegate, delegator, pairs } = parameters;
+
+  const rpcCalls = pairs.map(
+    (pair) => () =>
+      _isHandleDelegatedForUserDecryption(context, {
+        address,
+        delegate,
+        delegator,
+        handle: pair.handle,
+        contractAddress: pair.contractAddress,
+      }),
+  );
+
+  const results = await executeWithBatching(rpcCalls, context.options.batchRpcCalls);
+
+  return results;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+async function _isHandleDelegatedForUserDecryption(
+  context: Context,
+  parameters: {
+    readonly address: ChecksummedAddress;
+    readonly delegator: ChecksummedAddress;
+    readonly delegate: ChecksummedAddress;
+    readonly contractAddress: ChecksummedAddress;
+    readonly handle: Handle;
+  },
+): Promise<boolean> {
+  const { address, delegator, delegate, contractAddress, handle } = parameters;
+  const trustedClient = getTrustedClient(context);
+
+  const res = await context.runtime.ethereum.readContract(trustedClient, {
+    address: address,
+    abi: isHandleDelegatedForUserDecryptionAbi,
+    args: [delegator, delegate, contractAddress, handle.bytes32Hex],
+    functionName: isHandleDelegatedForUserDecryptionAbi[0].name,
+  });
+
+  if (typeof res !== 'boolean') {
+    throw new Error(`Invalid isHandleDelegatedForUserDecryptionAbi result.`);
+  }
+
+  return res;
+}

package/core/host-contracts/persistAllowed.ts

@@ -61,7 +61,7 @@ async function _persistAllowed(
   });
 
   if (typeof res !== 'boolean') {
-    throw new Error(`Invalid isAllowedForDecryption result.`);
+    throw new Error(`Invalid persistAllowed result.`);
   }
 
   return res;

package/core/kms/fetchKmsSignedcryptedShares-p.ts

@@ -15,6 +15,7 @@ import { assertKmsDecryptionBitLimit } from './utils.js';
 import { checkPersistAllowed } from '../host-contracts/checkPersistAllowed.js';
 import { assertExtraDataMatchesKmsSingersContext } from '../host-contracts/KmsSignersContext-p.js';
 import { createKmsEip712Domain } from './createKmsEip712Domain.js';
+import { checkDelegation } from '../host-contracts/checkDelegation.js';
 
 /*
     See: in KMS (eip712Domain)
@@ -118,11 +119,20 @@ export async function fetchKmsSignedcryptedShares(context: Context, parameters:
   signedPermit.assertNotExpired();
 
   // 7. Check: ACL permissions (user is signer or delegatorAddress)
-  await checkPersistAllowed(context, {
-    address: context.chain.fhevm.contracts.acl.address as ChecksummedAddress,
-    userAddress: encryptedDataOwnerAddress,
-    handleContractPairs,
-  });
+  if (signedPermit.isDelegated) {
+    await checkDelegation(context, {
+      address: context.chain.fhevm.contracts.acl.address as ChecksummedAddress,
+      delegate: signerAddress,
+      delegator: encryptedDataOwnerAddress,
+      handleContractPairs,
+    });
+  } else {
+    await checkPersistAllowed(context, {
+      address: context.chain.fhevm.contracts.acl.address as ChecksummedAddress,
+      userAddress: encryptedDataOwnerAddress,
+      handleContractPairs,
+    });
+  }
 
   // 8. Verify the EIP712 signature
   // Not required because a signedPermit is guaranteed to be verified.

package/core/types/index.ts

@@ -1,2 +1,3 @@
 export type { TypedValue } from './primitives.js';
 export type { EncryptedValue, EncryptedValueLike } from './encryptedTypes.js';
+export type { KmsDecryptEip712Like } from './kms.js';

package/core/types/kms.ts

@@ -99,6 +99,25 @@ export type KmsPublicDecryptEip712Message = Readonly<{
   extraData: BytesHex;
 }>;
 
+export type KmsDecryptEip712Like = {
+  readonly domain: {
+    readonly name: string;
+    readonly version: string;
+    readonly chainId: number | bigint;
+    readonly verifyingContract: string;
+  };
+  readonly primaryType?: string | undefined;
+  readonly types: Record<string, ReadonlyArray<{ readonly name: string; readonly type: string }>>;
+  readonly message: {
+    readonly publicKey: string | Uint8Array;
+    readonly contractAddresses: string[];
+    readonly startTimestamp: number;
+    readonly durationDays: number;
+    readonly extraData: string | Uint8Array;
+    readonly delegatorAddress?: string | undefined;
+  };
+};
+
 export type KmsUserDecryptEip712 = Prettify<{
   readonly domain: KmsEip712Domain;
   readonly types: KmsUserDecryptEip712Types;

package/core/types/primitives.ts

@@ -631,6 +631,10 @@ type TypedValueLikeMap = Readonly<{
   address: AddressValueLike;
 }>;
 
+export type RawTypedValue = {
+  readonly type: string;
+  readonly value: boolean | bigint | number | string;
+};
 export type TypedValueLike = TypedValueLikeMap[ValueTypeName];
 
 /**

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@fhevm/sdk",
   "description": "TypeScript Interface for FHEVM",
-  "version": "1.0.0-alpha.2",
+  "version": "1.0.0-alpha.4",
   "type": "module",
   "main": "./_cjs/index.js",
   "module": "./_esm/index.js",

package/tsconfig.json

@@ -1,7 +1,7 @@
 {
   "extends": "../tsconfig.base.json",
   "include": ["./**/*.ts"],
-  "exclude": ["./**/*.test.ts", "./**/*.test-d.ts", "./**/*.bench.ts", "./**/*.bench-d.ts"],
+  "exclude": ["./**/*.test.ts", "./**/*.test-d.ts", "./**/*.bench.ts", "./**/*.bench-d.ts", "./vitest.config.ts"],
   "compilerOptions": {
     "composite": true,
     "noEmit": true

package/vitest.config.ts

@@ -0,0 +1,17 @@
+import { defineConfig } from 'vitest/config';
+
+export default defineConfig({
+  test: {
+    include: ['src/**/*.test.ts'],
+    exclude: ['src/index.hello.test.ts'],
+    reporters: ['verbose'],
+    passWithNoTests: false,
+    typecheck: { enabled: true },
+    coverage: {
+      provider: 'v8',
+      reporter: ['text'],
+      //include: ['src/**/*.ts'],
+      //exclude: ['src/**/*.test.ts', 'src/**/*.test-d.ts', 'src/vitest.config.ts'],
+    },
+  },
+});