@fhevm/sdk 1.1.0-alpha.4 → 1.1.0-alpha.5

package/core/host-contracts/checkPersistAllowed.ts

@@ -14,7 +14,7 @@ type Context = {
 };
 
 type Parameters = {
-  readonly address: ChecksummedAddress;
+  readonly aclAddress: ChecksummedAddress;
   readonly userAddress: ChecksummedAddress;
   readonly handleContractPairs: ReadonlyArray<{
     readonly handle: Handle;
@@ -25,7 +25,7 @@ type Parameters = {
 ////////////////////////////////////////////////////////////////////////////////
 
 export async function checkPersistAllowed(context: Context, parameters: Parameters): Promise<void> {
-  const { address, userAddress, handleContractPairs } = parameters;
+  const { aclAddress, userAddress, handleContractPairs } = parameters;
 
   if (handleContractPairs.length === 0) {
     throw new Error('checkPersistAllowed requires at least one (handle, contractAddress) pair');
@@ -38,9 +38,9 @@ export async function checkPersistAllowed(context: Context, parameters: Paramete
 
   // 1. Verify rule: userAddress !== contractAddress
   for (const pair of handleContractPairs) {
-    if (parameters.userAddress.toLowerCase() === pair.contractAddress.toLowerCase()) {
+    if (userAddress.toLowerCase() === pair.contractAddress.toLowerCase()) {
       throw new AclUserDecryptionError({
-        contractAddress: address,
+        contractAddress: aclAddress,
         message: `userAddress ${userAddress} should not be equal to contractAddress when requesting user decryption!`,
       });
     }
@@ -52,12 +52,12 @@ export async function checkPersistAllowed(context: Context, parameters: Paramete
 
   for (const pair of handleContractPairs) {
     // User check (runtime defensive check, use lowercase)
-    const userKey = getKey(parameters.userAddress, pair.handle.bytes32Hex);
+    const userKey = getKey(userAddress, pair.handle.bytes32Hex);
     if (!seenKeys.has(userKey)) {
       seenKeys.add(userKey);
       allChecks.push({
         handle: pair.handle,
-        account: parameters.userAddress,
+        account: userAddress,
       });
     }
     // Contract check (runtime defensive check, use lowercase)
@@ -77,7 +77,7 @@ export async function checkPersistAllowed(context: Context, parameters: Paramete
 
   // 3. Single batched RPC call for all unique checks
   const allResults = await persistAllowed(context, {
-    address,
+    aclAddress,
     pairs: allChecks,
   });
 
@@ -98,8 +98,8 @@ export async function checkPersistAllowed(context: Context, parameters: Paramete
     const userKey = getKey(parameters.userAddress, pair.handle.bytes32Hex);
     if (resultMap.get(userKey) !== true) {
       throw new AclUserDecryptionError({
-        contractAddress: address,
-        message: `User ${parameters.userAddress} is not authorized to decrypt handle ${pair.handle.bytes32Hex}!`,
+        contractAddress: aclAddress,
+        message: `User ${userAddress} is not authorized to decrypt handle ${pair.handle.bytes32Hex}!`,
       });
     }
 
@@ -107,7 +107,7 @@ export async function checkPersistAllowed(context: Context, parameters: Paramete
     const contractKey = getKey(pair.contractAddress, pair.handle.bytes32Hex);
     if (resultMap.get(contractKey) !== true) {
       throw new AclUserDecryptionError({
-        contractAddress: address,
+        contractAddress: aclAddress,
         message: `Dapp contract ${pair.contractAddress} is not authorized to user decrypt handle ${pair.handle.bytes32Hex}!`,
       });
     }

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

@@ -12,7 +12,7 @@ type Context = {
 };
 
 type Parameters = {
-  readonly address: ChecksummedAddress;
+  readonly fhevmExecutorAddress: ChecksummedAddress;
 };
 
 type ReturnType = ChecksummedAddress;
@@ -26,10 +26,9 @@ type ReturnType = ChecksummedAddress;
  */
 export async function getAclAddress(context: Context, parameters: Parameters): Promise<ReturnType> {
   const trustedClient = getTrustedClient(context);
-  const address = parameters.address;
 
   const res = await context.runtime.ethereum.readContract(trustedClient, {
-    address: address,
+    address: parameters.fhevmExecutorAddress,
     abi: getACLAddressAbi,
     args: [],
     functionName: getACLAddressAbi[0].name,

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

@@ -0,0 +1,92 @@
+import type { ChecksummedAddress, Uint256BigInt } from '../types/primitives.js';
+import type { FhevmRuntime } from '../types/coreFhevmRuntime.js';
+import { getCurrentKmsContextAndEpochAbi } from './abi-fragments/fragments.js';
+import { getTrustedClient } from '../runtime/CoreFhevm-p.js';
+import { getHostContractVersion, isVersionStrictlyBefore } from './HostContractVersion-p.js';
+import { assertIsUint256 } from '../base/uint.js';
+import { CACHE_TTL_24H, createCachedFetch } from '../base/cachedFetch.js';
+
+////////////////////////////////////////////////////////////////////////////////
+
+type Context = {
+  readonly runtime: FhevmRuntime;
+  readonly client: NonNullable<object>;
+};
+
+type Parameters = {
+  readonly protocolConfigAddress: ChecksummedAddress;
+};
+
+type ReturnType = { readonly contextId: Uint256BigInt; readonly epochId: Uint256BigInt };
+
+////////////////////////////////////////////////////////////////////////////////
+
+const cachedGetCurrentKmsContextAndEpoch = createCachedFetch<Context, Parameters, ReturnType>({
+  executeFn: _getCurrentKmsContextAndEpoch,
+  cacheKeyFn: (context, params) => `${context.runtime.uid.toLowerCase()}:${params.protocolConfigAddress.toLowerCase()}`,
+  // Host contract values are immutable per deployment, so a long TTL is safe.
+  ttlMs: CACHE_TTL_24H,
+});
+
+/**
+ * Reads the current KMS context ID and epoch ID from a ProtocolConfig contract.
+ *
+ * Requires ProtocolConfig >= v0.2.0 (protocol v0.14.0).
+ *
+ * Results are cached per (runtime, address) with a 24-hour TTL.
+ * Concurrent callers share a single in-flight RPC request (deduplication).
+ *
+ * @param parameters.address - The checksummed address of the ProtocolConfig contract.
+ * @param parameters.forceRefresh - If `true`, invalidates the cached entry and
+ *   makes a fresh RPC call. The new result is stored back in the cache.
+ */
+export function getCurrentKmsContextAndEpoch(
+  context: Context,
+  parameters: Parameters & { readonly forceRefresh?: boolean | undefined },
+): Promise<ReturnType> {
+  return cachedGetCurrentKmsContextAndEpoch.execute(context, parameters);
+}
+
+async function _getCurrentKmsContextAndEpoch(context: Context, parameters: Parameters): Promise<ReturnType> {
+  const protocolConfigVersion = await getHostContractVersion(context, { address: parameters.protocolConfigAddress });
+
+  // getCurrentKmsContextAndEpoch requires ProtocolConfig >= v0.2.0 (protocol v0.14.0)
+  if (isVersionStrictlyBefore(protocolConfigVersion, { major: 0, minor: 2 })) {
+    throw new Error(
+      'ProtocolConfig.getCurrentKmsContextAndEpoch() requires ProtocolConfig >= v0.2.0 (protocol v0.14.0)',
+    );
+  }
+
+  const trustedClient = getTrustedClient(context);
+
+  const res = await context.runtime.ethereum.readContract(trustedClient, {
+    address: parameters.protocolConfigAddress,
+    abi: getCurrentKmsContextAndEpochAbi,
+    args: [],
+    functionName: getCurrentKmsContextAndEpochAbi[0].name,
+  });
+
+  if (!Array.isArray(res) || res.length < 2) {
+    throw new Error(`Invalid getCurrentKmsContextAndEpoch result.`);
+  }
+
+  const unknownContextId = res[0] as unknown;
+  const unknownEpochId = res[1] as unknown;
+
+  try {
+    assertIsUint256(unknownContextId, {});
+  } catch (e) {
+    throw new Error(`Invalid KMS Context Id.`, { cause: e });
+  }
+
+  try {
+    assertIsUint256(unknownEpochId, {});
+  } catch (e) {
+    throw new Error(`Invalid KMS Epoch Id.`, { cause: e });
+  }
+
+  return Object.freeze({
+    contextId: BigInt(unknownContextId) as Uint256BigInt,
+    epochId: BigInt(unknownEpochId) as Uint256BigInt,
+  });
+}

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

@@ -2,7 +2,7 @@ import type { ChecksummedAddress, Uint256BigInt } from '../types/primitives.js';
 import type { FhevmRuntime } from '../types/coreFhevmRuntime.js';
 import { getCurrentKmsContextIdAbi } from './abi-fragments/fragments.js';
 import { getTrustedClient } from '../runtime/CoreFhevm-p.js';
-import { getVersion, isVersionStrictlyBefore } from './HostContractVersion-p.js';
+import { getHostContractVersion, isVersionStrictlyBefore } from './HostContractVersion-p.js';
 import { assertIsUint256 } from '../base/uint.js';
 import { CACHE_TTL_24H, createCachedFetch } from '../base/cachedFetch.js';
 
@@ -14,7 +14,7 @@ type Context = {
 };
 
 type Parameters = {
-  readonly address: ChecksummedAddress;
+  readonly kmsVerifierAddress: ChecksummedAddress;
 };
 
 type ReturnType = Uint256BigInt;
@@ -23,7 +23,7 @@ type ReturnType = Uint256BigInt;
 
 const cachedGetCurrentKmsContextId = createCachedFetch<Context, Parameters, ReturnType>({
   executeFn: _getCurrentKmsContextId,
-  cacheKeyFn: (context, params) => `${context.runtime.uid.toLowerCase()}:${params.address.toLowerCase()}`,
+  cacheKeyFn: (context, params) => `${context.runtime.uid.toLowerCase()}:${params.kmsVerifierAddress.toLowerCase()}`,
   // Host contract versions are immutable per deployment, so a long TTL is safe.
   ttlMs: CACHE_TTL_24H,
 });
@@ -46,17 +46,17 @@ export function getCurrentKmsContextId(
 }
 
 async function _getCurrentKmsContextId(context: Context, parameters: Parameters): Promise<ReturnType> {
-  const version = await getVersion(context, parameters);
-  // getCurrentKmsContextId has been introduced in KMSVerifier.sol v0.2.0
-  if (isVersionStrictlyBefore(version, { major: 0, minor: 2 })) {
+  const kmsVerifierVersion = await getHostContractVersion(context, { address: parameters.kmsVerifierAddress });
+
+  // getCurrentKmsContextId has been introduced in protocol v0.12.0 (KMSVerifier v0.2.0)
+  if (isVersionStrictlyBefore(kmsVerifierVersion, { major: 0, minor: 2 })) {
     return 0n as Uint256BigInt;
   }
 
   const trustedClient = getTrustedClient(context);
-  const address = parameters.address;
 
   const res = await context.runtime.ethereum.readContract(trustedClient, {
-    address: address,
+    address: parameters.kmsVerifierAddress,
     abi: getCurrentKmsContextIdAbi,
     args: [],
     functionName: getCurrentKmsContextIdAbi[0].name,

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

@@ -12,7 +12,7 @@ type Context = {
 };
 
 type Parameters = {
-  readonly address: ChecksummedAddress;
+  readonly aclAddress: ChecksummedAddress;
 };
 
 type ReturnType = ChecksummedAddress;
@@ -26,7 +26,7 @@ type ReturnType = ChecksummedAddress;
  */
 export async function getFhevmExecutorAddress(context: Context, parameters: Parameters): Promise<ReturnType> {
   const trustedClient = getTrustedClient(context);
-  const address = parameters.address;
+  const address = parameters.aclAddress;
 
   const res = await context.runtime.ethereum.readContract(trustedClient, {
     address: address,

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

@@ -12,7 +12,7 @@ type Context = {
 };
 
 type Parameters = {
-  readonly address: ChecksummedAddress;
+  readonly fhevmExecutorAddress: ChecksummedAddress;
 };
 
 type ReturnType = Uint8Number;
@@ -26,10 +26,9 @@ type ReturnType = Uint8Number;
  */
 export async function getHandleVersion(context: Context, parameters: Parameters): Promise<ReturnType> {
   const trustedClient = getTrustedClient(context);
-  const address = parameters.address;
 
   const res = await context.runtime.ethereum.readContract(trustedClient, {
-    address: address,
+    address: parameters.fhevmExecutorAddress,
     abi: getHandleVersionAbi,
     args: [],
     functionName: getHandleVersionAbi[0].name,

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

@@ -12,7 +12,7 @@ type Context = {
 };
 
 type Parameters = {
-  readonly address: ChecksummedAddress;
+  readonly fhevmExecutorAddress: ChecksummedAddress;
 };
 
 type ReturnType = ChecksummedAddress;
@@ -26,10 +26,9 @@ type ReturnType = ChecksummedAddress;
  */
 export async function getHcuLimitAddress(context: Context, parameters: Parameters): Promise<ReturnType> {
   const trustedClient = getTrustedClient(context);
-  const address = parameters.address;
 
   const res = await context.runtime.ethereum.readContract(trustedClient, {
-    address: address,
+    address: parameters.fhevmExecutorAddress,
     abi: getHCULimitAddressAbi,
     args: [],
     functionName: getHCULimitAddressAbi[0].name,

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

@@ -12,7 +12,7 @@ type Context = {
 };
 
 type Parameters = {
-  readonly address: ChecksummedAddress;
+  readonly fhevmExecutorAddress: ChecksummedAddress;
 };
 
 type ReturnType = ChecksummedAddress;
@@ -26,10 +26,9 @@ type ReturnType = ChecksummedAddress;
  */
 export async function getInputVerifierAddress(context: Context, parameters: Parameters): Promise<ReturnType> {
   const trustedClient = getTrustedClient(context);
-  const address = parameters.address;
 
   const res = await context.runtime.ethereum.readContract(trustedClient, {
-    address: address,
+    address: parameters.fhevmExecutorAddress,
     abi: getInputVerifierAddressAbi,
     args: [],
     functionName: getInputVerifierAddressAbi[0].name,

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

@@ -2,7 +2,7 @@ import type { ChecksummedAddress, Uint8Number } from '../types/primitives.js';
 import type { FhevmRuntime } from '../types/coreFhevmRuntime.js';
 import { assertIsChecksummedAddressArray } from '../base/address.js';
 import { asUint8Number, isUint8 } from '../base/uint.js';
-import { getVersion } from './HostContractVersion-p.js';
+import { getHostContractVersion } from './HostContractVersion-p.js';
 import { isVersionStrictlyBefore } from '../host-contracts/HostContractVersion-p.js';
 import { executeWithBatching } from '../base/promise.js';
 import { getTrustedClient } from '../runtime/CoreFhevm-p.js';
@@ -18,7 +18,7 @@ type Context = {
 };
 
 type Parameters = {
-  readonly address: ChecksummedAddress;
+  readonly kmsVerifierAddress: ChecksummedAddress;
 };
 
 type ReturnType = {
@@ -30,7 +30,7 @@ type ReturnType = {
 
 const cachedGetKmsContextSignersAndThreshold = createCachedFetch<Context, Parameters, ReturnType>({
   executeFn: _getKmsContextSignersAndThreshold,
-  cacheKeyFn: (context, params) => `${context.runtime.uid.toLowerCase()}:${params.address.toLowerCase()}`,
+  cacheKeyFn: (context, params) => `${context.runtime.uid.toLowerCase()}:${params.kmsVerifierAddress.toLowerCase()}`,
   // Host contract versions are immutable per deployment, so a long TTL is safe.
   ttlMs: CACHE_TTL_24H,
 });
@@ -64,8 +64,8 @@ export function getKmsSignersAndThreshold(
 ////////////////////////////////////////////////////////////////////////////////
 
 async function _getKmsContextSignersAndThreshold(context: Context, parameters: Parameters): Promise<ReturnType> {
-  const version = await getVersion(context, { address: parameters.address });
-  if (!isVersionStrictlyBefore(version, { major: 0, minor: 2 })) {
+  const kmsVerifierVersion = await getHostContractVersion(context, { address: parameters.kmsVerifierAddress });
+  if (!isVersionStrictlyBefore(kmsVerifierVersion, { major: 0, minor: 2 })) {
     throw new Error('getContextSignersAndThreshold requires KMSVerifier < v0.2.0');
   }
   ////////////////////////////////////////////////////////////////////////////
@@ -108,10 +108,9 @@ async function _getKmsContextSignersAndThreshold(context: Context, parameters: P
 
 async function _getThreshold(context: Context, parameters: Parameters): Promise<Uint8Number> {
   const trustedClient = getTrustedClient(context);
-  const address = parameters.address;
 
   const res = await context.runtime.ethereum.readContract(trustedClient, {
-    address: address,
+    address: parameters.kmsVerifierAddress,
     abi: getThresholdAbi,
     args: [],
     functionName: getThresholdAbi[0].name,
@@ -128,10 +127,9 @@ async function _getThreshold(context: Context, parameters: Parameters): Promise<
 
 async function _getKmsSigners(context: Context, parameters: Parameters): Promise<ChecksummedAddress[]> {
   const trustedClient = getTrustedClient(context);
-  const address = parameters.address;
 
   const res = await context.runtime.ethereum.readContract(trustedClient, {
-    address: address,
+    address: parameters.kmsVerifierAddress,
     abi: getKmsSignersAbi,
     args: [],
     functionName: getKmsSignersAbi[0].name,

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

@@ -1,6 +1,6 @@
 import type { BytesHex, ChecksummedAddress, Uint8Number } from '../types/primitives.js';
 import type { FhevmRuntime } from '../types/coreFhevmRuntime.js';
-import { getVersion, isVersionStrictlyBefore } from './HostContractVersion-p.js';
+import { getHostContractVersion, isVersionStrictlyBefore } from './HostContractVersion-p.js';
 import { createCachedFetch } from '../base/cachedFetch.js';
 import { assertIsKmsExtraData, fromKmsExtraData } from '../kms/kmsExtraData.js';
 import { assertIsChecksummedAddressArray } from '../base/address.js';
@@ -16,7 +16,7 @@ type Context = {
 };
 
 type Parameters = {
-  readonly address: ChecksummedAddress;
+  readonly kmsVerifierAddress: ChecksummedAddress;
   readonly extraData: BytesHex;
 };
 
@@ -32,7 +32,7 @@ const cachedGetKmsContextSignersAndThresholdFromExtraData = createCachedFetch<Co
   cacheKeyFn: (context, params) => {
     const { kmsContextId } = fromKmsExtraData(params.extraData);
     const contextIdHex = kmsContextId.toString(16).padStart(64, '0');
-    return `${context.runtime.uid.toLowerCase()}:${params.address.toLowerCase()}:${contextIdHex}`;
+    return `${context.runtime.uid.toLowerCase()}:${params.kmsVerifierAddress.toLowerCase()}:${contextIdHex}`;
   },
   // Permanent cache: signers and threshold are immutable per context ID.
 });
@@ -69,16 +69,15 @@ async function _getKmsContextSignersAndThresholdFromExtraData(
   context: Context,
   parameters: Parameters,
 ): Promise<ReturnType> {
-  const version = await getVersion(context, { address: parameters.address });
-  if (isVersionStrictlyBefore(version, { major: 0, minor: 2 })) {
+  const kmsVerifierVersion = await getHostContractVersion(context, { address: parameters.kmsVerifierAddress });
+  if (isVersionStrictlyBefore(kmsVerifierVersion, { major: 0, minor: 2 })) {
     throw new Error('getContextSignersAndThresholdFromExtraData requires KMSVerifier >= v0.2.0');
   }
 
   const trustedClient = getTrustedClient(context);
-  const address = parameters.address;
 
   const res = await context.runtime.ethereum.readContract(trustedClient, {
-    address: address,
+    address: parameters.kmsVerifierAddress,
     abi: getContextSignersAndThresholdFromExtraDataAbi,
     args: [parameters.extraData],
     functionName: getContextSignersAndThresholdFromExtraDataAbi[0].name,

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

@@ -1,6 +1,6 @@
 import type { ChecksummedAddress, Uint256BigInt } from '../types/primitives.js';
 import type { FhevmRuntime } from '../types/coreFhevmRuntime.js';
-import { getVersion, isVersionStrictlyBefore } from './HostContractVersion-p.js';
+import { getHostContractVersion, isVersionStrictlyBefore } from './HostContractVersion-p.js';
 import { getTrustedClient } from '../runtime/CoreFhevm-p.js';
 import { getKmsSignersAbi, getSignersForKmsContextAbi } from './abi-fragments/fragments.js';
 import { assertIsChecksummedAddressArray } from '../base/address.js';
@@ -13,7 +13,7 @@ type Context = {
 };
 
 type Parameters = {
-  readonly address: ChecksummedAddress;
+  readonly kmsVerifierAddress: ChecksummedAddress;
   readonly kmsContextId: Uint256BigInt;
 };
 
@@ -30,11 +30,11 @@ type ReturnType = ChecksummedAddress[];
  * Returns an empty array for KMSVerifier versions before v0.2.0 (where
  * per-context signers were not yet supported).
  *
- * @param parameters.address - The checksummed address of the KMSVerifier contract.
+ * @param parameters.kmsVerifierAddress - The checksummed address of the KMSVerifier contract.
  * @param parameters.kmsContextId - The context ID to query signers for.
  */
 export async function getSignersForKmsContext(context: Context, parameters: Parameters): Promise<ReturnType> {
-  const version = await getVersion(context, parameters);
+  const version = await getHostContractVersion(context, { address: parameters.kmsVerifierAddress });
   // getCurrentKmsContextId has been introduced in KMSVerifier.sol v0.2.0
   if (isVersionStrictlyBefore(version, { major: 0, minor: 2 })) {
     if (parameters.kmsContextId === 0n) {
@@ -44,10 +44,9 @@ export async function getSignersForKmsContext(context: Context, parameters: Para
   }
 
   const trustedClient = getTrustedClient(context);
-  const address = parameters.address;
 
   const res = await context.runtime.ethereum.readContract(trustedClient, {
-    address: address,
+    address: parameters.kmsVerifierAddress,
     abi: getSignersForKmsContextAbi,
     args: [parameters.kmsContextId],
     functionName: getSignersForKmsContextAbi[0].name,
@@ -69,10 +68,9 @@ export async function getKmsSigners(
   parameters: Omit<Parameters, 'kmsContextId'>,
 ): Promise<ReturnType> {
   const trustedClient = getTrustedClient(context);
-  const address = parameters.address;
 
   const res = await context.runtime.ethereum.readContract(trustedClient, {
-    address: address,
+    address: parameters.kmsVerifierAddress,
     abi: getKmsSignersAbi,
     args: [],
     functionName: getKmsSignersAbi[0].name,

package/core/host-contracts/isAllowedForDecryption.ts

@@ -14,7 +14,7 @@ type Context = {
 };
 
 type Parameters = {
-  readonly address: ChecksummedAddress;
+  readonly aclAddress: ChecksummedAddress;
   readonly handles: readonly Handle[];
 };
 
@@ -23,12 +23,12 @@ type ReturnType = boolean[];
 ////////////////////////////////////////////////////////////////////////////////
 
 export async function isAllowedForDecryption(context: Context, parameters: Parameters): Promise<ReturnType> {
-  const { address, handles } = parameters;
+  const { aclAddress, handles } = parameters;
 
   const rpcCalls = handles.map(
     (handle) => () =>
       _isAllowedForDecryption(context, {
-        address,
+        aclAddress,
         handle,
       }),
   );
@@ -43,15 +43,15 @@ export async function isAllowedForDecryption(context: Context, parameters: Param
 async function _isAllowedForDecryption(
   context: Context,
   parameters: {
-    readonly address: ChecksummedAddress;
+    readonly aclAddress: ChecksummedAddress;
     readonly handle: Handle;
   },
 ): Promise<boolean> {
-  const { address, handle } = parameters;
+  const { aclAddress, handle } = parameters;
   const trustedClient = getTrustedClient(context);
 
   const res = await context.runtime.ethereum.readContract(trustedClient, {
-    address: address,
+    address: aclAddress,
     abi: isAllowedForDecryptionAbi,
     args: [handle.bytes32Hex],
     functionName: isAllowedForDecryptionAbi[0].name,

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

@@ -15,7 +15,7 @@ type Context = {
 };
 
 type Parameters = {
-  readonly address: ChecksummedAddress;
+  readonly aclAddress: ChecksummedAddress;
   readonly delegate: ChecksummedAddress;
   readonly delegator: ChecksummedAddress;
   readonly pairs: readonly HandleContractPair[];
@@ -29,12 +29,12 @@ export async function isHandleDelegatedForUserDecryption(
   context: Context,
   parameters: Parameters,
 ): Promise<ReturnType> {
-  const { address, delegate, delegator, pairs } = parameters;
+  const { aclAddress, delegate, delegator, pairs } = parameters;
 
   const rpcCalls = pairs.map(
     (pair) => () =>
       _isHandleDelegatedForUserDecryption(context, {
-        address,
+        aclAddress,
         delegate,
         delegator,
         handle: pair.handle,
@@ -52,25 +52,25 @@ export async function isHandleDelegatedForUserDecryption(
 async function _isHandleDelegatedForUserDecryption(
   context: Context,
   parameters: {
-    readonly address: ChecksummedAddress;
+    readonly aclAddress: ChecksummedAddress;
     readonly delegator: ChecksummedAddress;
     readonly delegate: ChecksummedAddress;
     readonly contractAddress: ChecksummedAddress;
     readonly handle: Handle;
   },
 ): Promise<boolean> {
-  const { address, delegator, delegate, contractAddress, handle } = parameters;
+  const { aclAddress, delegator, delegate, contractAddress, handle } = parameters;
   const trustedClient = getTrustedClient(context);
 
   const res = await context.runtime.ethereum.readContract(trustedClient, {
-    address: address,
+    address: aclAddress,
     abi: isHandleDelegatedForUserDecryptionAbi,
     args: [delegator, delegate, contractAddress, handle.bytes32Hex],
     functionName: isHandleDelegatedForUserDecryptionAbi[0].name,
   });
 
   if (typeof res !== 'boolean') {
-    throw new Error(`Invalid isHandleDelegatedForUserDecryptionAbi result.`);
+    throw new Error(`Invalid isHandleDelegatedForUserDecryption result.`);
   }
 
   return res;

package/core/host-contracts/isUserDecryptable.ts

@@ -13,7 +13,7 @@ type Context = {
 };
 
 type Parameters = {
-  readonly address: ChecksummedAddress;
+  readonly aclAddress: ChecksummedAddress;
   readonly userAddress: ChecksummedAddress;
   readonly handleContractPairs: ReadonlyArray<{
     readonly handle: Handle;
@@ -33,7 +33,7 @@ type ReturnType = ReadonlyArray<{
  * See FHE.sol : isUserDecryptable()
  */
 export async function isUserDecryptable(context: Context, parameters: Parameters): Promise<ReturnType> {
-  const { address, userAddress, handleContractPairs } = parameters;
+  const { aclAddress, userAddress, handleContractPairs } = parameters;
 
   function getKey(addr: string, handleBytes32Hex: string): string {
     return `${addr}:${handleBytes32Hex}`.toLowerCase();
@@ -63,7 +63,7 @@ export async function isUserDecryptable(context: Context, parameters: Parameters
   }
 
   const dedupedResults = await persistAllowed(context, {
-    address,
+    aclAddress,
     pairs: dedupedChecks,
   });
 

package/core/host-contracts/persistAllowed.ts

@@ -15,7 +15,7 @@ type Context = {
 };
 
 type Parameters = {
-  readonly address: ChecksummedAddress;
+  readonly aclAddress: ChecksummedAddress;
   readonly pairs: readonly HandleAccountPair[];
 };
 
@@ -24,12 +24,12 @@ type ReturnType = boolean[];
 ////////////////////////////////////////////////////////////////////////////////
 
 export async function persistAllowed(context: Context, parameters: Parameters): Promise<ReturnType> {
-  const { address, pairs } = parameters;
+  const { aclAddress, pairs } = parameters;
 
   const rpcCalls = pairs.map(
     (pair) => () =>
       _persistAllowed(context, {
-        address,
+        aclAddress,
         handle: pair.handle,
         account: pair.account,
       }),
@@ -45,16 +45,16 @@ export async function persistAllowed(context: Context, parameters: Parameters):
 async function _persistAllowed(
   context: Context,
   parameters: {
-    readonly address: ChecksummedAddress;
+    readonly aclAddress: ChecksummedAddress;
     readonly handle: Handle;
     readonly account: ChecksummedAddress;
   },
 ): Promise<boolean> {
-  const { address, handle, account } = parameters;
+  const { aclAddress, handle, account } = parameters;
   const trustedClient = getTrustedClient(context);
 
   const res = await context.runtime.ethereum.readContract(trustedClient, {
-    address: address,
+    address: aclAddress,
     abi: persistAllowedAbi,
     args: [handle.bytes32Hex, account],
     functionName: persistAllowedAbi[0].name,