@zama-fhe/sdk 1.0.0-alpha.10

package/dist/cleartext/index.js

@@ -0,0 +1,522 @@
+import { ConfigurationError, EncryptionFailedError, DecryptionFailedError } from '../chunk-6JRD26PS.js';
+import { toBytes, parseAbi, toHex, getAddress, concat, pad, keccak256, hexToBigInt, encodePacked, createPublicClient, http, custom } from 'viem';
+import { privateKeyToAccount } from 'viem/accounts';
+import { mainnet, sepolia } from 'viem/chains';
+
+// src/relayer/cleartext/eip712.ts
+var inputDomain = (chainId, verifyingContract) => ({
+  name: "InputVerification",
+  version: "1",
+  chainId: Number(chainId),
+  verifyingContract
+});
+var decryptionDomain = (chainId, verifyingContract) => ({
+  name: "Decryption",
+  version: "1",
+  chainId: Number(chainId),
+  verifyingContract
+});
+var INPUT_VERIFICATION_EIP712 = {
+  domain: inputDomain,
+  types: {
+    CiphertextVerification: [
+      { name: "ctHandles", type: "bytes32[]" },
+      { name: "userAddress", type: "address" },
+      { name: "contractAddress", type: "address" },
+      { name: "contractChainId", type: "uint256" },
+      { name: "extraData", type: "bytes" }
+    ]
+  }
+};
+var KMS_DECRYPTION_EIP712 = {
+  domain: decryptionDomain,
+  types: {
+    PublicDecryptVerification: [
+      { name: "ctHandles", type: "bytes32[]" },
+      { name: "decryptedResult", type: "bytes" },
+      { name: "extraData", type: "bytes" }
+    ]
+  }
+};
+var USER_DECRYPT_EIP712 = {
+  types: {
+    UserDecryptRequestVerification: [
+      { name: "publicKey", type: "bytes" },
+      { name: "contractAddresses", type: "address[]" },
+      { name: "startTimestamp", type: "uint256" },
+      { name: "durationDays", type: "uint256" },
+      { name: "extraData", type: "bytes" }
+    ]
+  }
+};
+var DELEGATED_USER_DECRYPT_EIP712 = {
+  types: {
+    DelegatedUserDecryptRequestVerification: [
+      { name: "publicKey", type: "bytes" },
+      { name: "contractAddresses", type: "address[]" },
+      { name: "delegatorAddress", type: "address" },
+      { name: "startTimestamp", type: "uint256" },
+      { name: "durationDays", type: "uint256" },
+      { name: "extraData", type: "bytes" }
+    ]
+  }
+};
+
+// src/relayer/cleartext/constants.ts
+var FHE_BIT_WIDTHS = {
+  [0 /* Bool */]: 1,
+  [1 /* Uint4 */]: 4,
+  [2 /* Uint8 */]: 8,
+  [3 /* Uint16 */]: 16,
+  [4 /* Uint32 */]: 32,
+  [5 /* Uint64 */]: 64,
+  [6 /* Uint128 */]: 128,
+  [7 /* Uint160 */]: 160,
+  [8 /* Uint256 */]: 256
+};
+var HANDLE_VERSION = 0;
+var PREHANDLE_MASK = 0xffffffffffffffffffffffffffffffffffffffffff0000000000000000000000n;
+var MOCK_INPUT_SIGNER_PK = "0x7ec8ada6642fc4ccfb7729bc29c17cf8d21b61abd5642d1db992c0b8672ab901";
+var MOCK_KMS_SIGNER_PK = "0x388b7680e4e1afa06efbfd45cdd1fe39f3c6af381df6555a19661f283b97de91";
+var VERIFYING_CONTRACTS = {
+  inputVerification: "0x812b06e1CDCE800494b79fFE4f925A504a9A9810",
+  decryption: "0x5ffdaAB0373E62E2ea2944776209aEf29E631A64"
+};
+var GATEWAY_CHAIN_ID = 10901;
+var RAW_CT_HASH_DOMAIN_SEPARATOR = toBytes("ZK-w_rct");
+var HANDLE_HASH_DOMAIN_SEPARATOR = toBytes("ZK-w_hdl");
+function cleartextToBytes(cleartext, fheType) {
+  const byteLength = Math.ceil(FHE_BIT_WIDTHS[fheType] / 8);
+  return toBytes(pad(toHex(cleartext), { size: byteLength }));
+}
+function computeMockCiphertext(fheType, cleartext, random32) {
+  if (random32.length !== 32) {
+    throw new EncryptionFailedError("random32 must be exactly 32 bytes");
+  }
+  const clearBytes = cleartextToBytes(cleartext, fheType);
+  const inner = keccak256(
+    concat([toHex(new Uint8Array([fheType])), toHex(clearBytes), toHex(random32)])
+  );
+  return keccak256(concat([toHex(RAW_CT_HASH_DOMAIN_SEPARATOR), inner]));
+}
+function computeInputHandle(mockCiphertext, index, fheType, aclAddress, chainId) {
+  if (!Number.isInteger(index) || index < 0 || index > 255) {
+    throw new EncryptionFailedError("index must be an integer between 0 and 255");
+  }
+  const blobHash = keccak256(
+    concat([toHex(RAW_CT_HASH_DOMAIN_SEPARATOR), mockCiphertext])
+  );
+  const handleHash = keccak256(
+    encodePacked(
+      ["bytes", "bytes32", "uint8", "address", "uint256"],
+      [
+        toHex(HANDLE_HASH_DOMAIN_SEPARATOR),
+        blobHash,
+        index,
+        aclAddress,
+        chainId
+      ]
+    )
+  );
+  const chainId64 = chainId & 0xffffffffffffffffn;
+  const handle = BigInt(handleHash) & PREHANDLE_MASK | BigInt(index) << 80n | chainId64 << 16n | BigInt(fheType) << 8n | BigInt(HANDLE_VERSION);
+  return toHex(handle, { size: 32 });
+}
+
+// src/relayer/cleartext/encrypted-input.ts
+var INPUT_SIGNER = privateKeyToAccount(MOCK_INPUT_SIGNER_PK);
+var CleartextEncryptedInput = class {
+  #contractAddress;
+  #userAddress;
+  #config;
+  #values = [];
+  constructor(contractAddress, userAddress, config) {
+    this.#contractAddress = getAddress(contractAddress);
+    this.#userAddress = getAddress(userAddress);
+    this.#config = config;
+  }
+  #addValue(fheType, value) {
+    if (value < 0n) {
+      throw new EncryptionFailedError("Only non-negative cleartext values are supported");
+    }
+    const bitWidth = FHE_BIT_WIDTHS[fheType];
+    const maxValue = (1n << BigInt(bitWidth)) - 1n;
+    if (value > maxValue) {
+      throw new EncryptionFailedError(
+        `Value ${value} exceeds max ${maxValue} for FheType ${fheType}`
+      );
+    }
+    this.#values.push({ fheType, value });
+    return this;
+  }
+  addBool(value) {
+    const normalized = typeof value === "boolean" ? value ? 1n : 0n : value;
+    if (normalized !== 0n && normalized !== 1n) {
+      throw new EncryptionFailedError("Bool value must be 0, 1, true, or false");
+    }
+    return this.#addValue(0 /* Bool */, normalized);
+  }
+  add4(value) {
+    return this.#addValue(1 /* Uint4 */, value);
+  }
+  add8(value) {
+    return this.#addValue(2 /* Uint8 */, value);
+  }
+  add16(value) {
+    return this.#addValue(3 /* Uint16 */, value);
+  }
+  add32(value) {
+    return this.#addValue(4 /* Uint32 */, value);
+  }
+  add64(value) {
+    return this.#addValue(5 /* Uint64 */, value);
+  }
+  add128(value) {
+    return this.#addValue(6 /* Uint128 */, value);
+  }
+  addAddress(value) {
+    return this.#addValue(7 /* Uint160 */, BigInt(getAddress(value)));
+  }
+  add256(value) {
+    return this.#addValue(8 /* Uint256 */, value);
+  }
+  async encrypt() {
+    const random32List = this.#values.map(() => crypto.getRandomValues(new Uint8Array(32)));
+    const mockCiphertexts = this.#values.map(
+      ({ fheType, value }, index) => computeMockCiphertext(fheType, value, random32List[index])
+    );
+    const ciphertextParts = mockCiphertexts.map((ciphertext) => ciphertext);
+    const ciphertextBlob = keccak256(ciphertextParts.length > 0 ? concat(ciphertextParts) : "0x");
+    const handles = this.#values.map(
+      ({ fheType }, index) => computeInputHandle(
+        ciphertextBlob,
+        index,
+        fheType,
+        this.#config.contracts.acl,
+        this.#config.chainId
+      )
+    );
+    const cleartextParts = this.#values.map(({ value }) => pad(toHex(value), { size: 32 }));
+    const cleartextBytes = cleartextParts.length > 0 ? concat(cleartextParts) : "0x";
+    const signature = await INPUT_SIGNER.signTypedData({
+      domain: INPUT_VERIFICATION_EIP712.domain(
+        this.#config.gatewayChainId,
+        this.#config.contracts.verifyingInputVerifier
+      ),
+      types: {
+        CiphertextVerification: [...INPUT_VERIFICATION_EIP712.types.CiphertextVerification]
+      },
+      primaryType: "CiphertextVerification",
+      message: {
+        ctHandles: handles,
+        userAddress: this.#userAddress,
+        contractAddress: this.#contractAddress,
+        contractChainId: this.#config.chainId,
+        extraData: cleartextBytes
+      }
+    });
+    const inputProof = toBytes(
+      concat([
+        toHex(new Uint8Array([handles.length])),
+        toHex(new Uint8Array([1])),
+        ...handles.map((handle) => handle),
+        signature,
+        cleartextBytes
+      ])
+    );
+    return {
+      handles: handles.map((handle) => toBytes(handle)),
+      inputProof
+    };
+  }
+};
+
+// src/relayer/cleartext/cleartext-fhevm-instance.ts
+var KMS_SIGNER = privateKeyToAccount(MOCK_KMS_SIGNER_PK);
+var ACL_ABI = parseAbi([
+  "function persistAllowed(bytes32 handle, address account) view returns (bool)",
+  "function isAllowedForDecryption(bytes32 handle) view returns (bool)",
+  "function isHandleDelegatedForUserDecryption(address delegator, address delegate, address contractAddress, bytes32 handle) view returns (bool)"
+]);
+var EXECUTOR_ABI = parseAbi(["function plaintexts(bytes32 handle) view returns (uint256)"]);
+var USER_DECRYPT_TYPES = {
+  UserDecryptRequestVerification: USER_DECRYPT_EIP712.types.UserDecryptRequestVerification
+};
+var DELEGATED_USER_DECRYPT_TYPES = {
+  EIP712Domain: [
+    { name: "name", type: "string" },
+    { name: "version", type: "string" },
+    { name: "chainId", type: "uint256" },
+    { name: "verifyingContract", type: "address" }
+  ],
+  DelegatedUserDecryptRequestVerification: DELEGATED_USER_DECRYPT_EIP712.types.DelegatedUserDecryptRequestVerification
+};
+var KMS_DECRYPTION_TYPES = {
+  PublicDecryptVerification: KMS_DECRYPTION_EIP712.types.PublicDecryptVerification
+};
+function normalizeHandle(handle) {
+  return toHex(hexToBigInt(handle), { size: 32 });
+}
+function decodeDecryptedValue(handle, rawValue) {
+  const typeByte = Number(BigInt(handle) >> 8n & 0xffn);
+  if (typeByte === 0 /* Bool */) return rawValue !== 0n;
+  if (typeByte === 7 /* Uint160 */) return toHex(rawValue, { size: 20 });
+  return rawValue;
+}
+var CleartextFhevmInstance = class _CleartextFhevmInstance {
+  #client;
+  #config;
+  static #FORBIDDEN_CHAIN_IDS = /* @__PURE__ */ new Set([BigInt(mainnet.id), BigInt(sepolia.id)]);
+  constructor(client, config) {
+    if (_CleartextFhevmInstance.#FORBIDDEN_CHAIN_IDS.has(config.chainId)) {
+      throw new ConfigurationError(
+        `Cleartext mode is not allowed on chain ${config.chainId}. It is intended for local development and testing only.`
+      );
+    }
+    this.#client = client;
+    this.#config = config;
+  }
+  async generateKeypair() {
+    const publicKey = toHex(crypto.getRandomValues(new Uint8Array(32)));
+    let privateKey = toHex(crypto.getRandomValues(new Uint8Array(32)));
+    while (privateKey === publicKey) {
+      privateKey = toHex(crypto.getRandomValues(new Uint8Array(32)));
+    }
+    return { publicKey, privateKey };
+  }
+  async createEIP712(publicKey, contractAddresses, startTimestamp, durationDays = 7) {
+    const domain = {
+      name: "Decryption",
+      version: "1",
+      chainId: Number(this.#config.chainId),
+      verifyingContract: this.#config.contracts.verifyingDecryption
+    };
+    return {
+      domain,
+      types: USER_DECRYPT_TYPES,
+      primaryType: "UserDecryptRequestVerification",
+      message: {
+        publicKey,
+        contractAddresses,
+        startTimestamp: BigInt(startTimestamp),
+        durationDays: BigInt(durationDays),
+        extraData: "0x00"
+      }
+    };
+  }
+  async encrypt(params) {
+    const input = new CleartextEncryptedInput(
+      params.contractAddress,
+      params.userAddress,
+      this.#config
+    );
+    for (const entry of params.values) {
+      const { value, type } = entry;
+      switch (type) {
+        case "ebool":
+          input.addBool(value);
+          break;
+        case "euint8":
+          input.add8(value);
+          break;
+        case "euint16":
+          input.add16(value);
+          break;
+        case "euint32":
+          input.add32(value);
+          break;
+        case "euint64":
+          input.add64(value);
+          break;
+        case "euint128":
+          input.add128(value);
+          break;
+        case "eaddress":
+          input.addAddress(value);
+          break;
+        case "euint256":
+          input.add256(value);
+          break;
+        default:
+          throw new EncryptionFailedError(`Unsupported FHE type: ${type}`);
+      }
+    }
+    return input.encrypt();
+  }
+  async userDecrypt(params) {
+    const normalizedSignerAddress = getAddress(params.signerAddress);
+    const normalizedHandles = params.handles.map(normalizeHandle);
+    const allowedResults = await Promise.all(
+      normalizedHandles.map((handle) => this.#persistAllowed(handle, normalizedSignerAddress))
+    );
+    const unauthorizedIndex = allowedResults.findIndex((isAllowed) => !isAllowed);
+    if (unauthorizedIndex !== -1) {
+      throw new DecryptionFailedError(
+        `Handle ${normalizedHandles[unauthorizedIndex]} is not authorized for user decrypt`
+      );
+    }
+    return this.#decryptHandles(normalizedHandles);
+  }
+  async publicDecrypt(handles) {
+    const normalizedHandles = handles.map(normalizeHandle);
+    const allowedResults = await Promise.all(
+      normalizedHandles.map((handle) => this.#isAllowedForDecryption(handle))
+    );
+    const unauthorizedIndex = allowedResults.findIndex((isAllowed) => !isAllowed);
+    if (unauthorizedIndex !== -1) {
+      throw new DecryptionFailedError(
+        `Handle ${normalizedHandles[unauthorizedIndex]} is not allowed for public decryption`
+      );
+    }
+    const orderedValues = await Promise.all(
+      normalizedHandles.map((handle) => this.#readPlaintext(handle))
+    );
+    const clearValues = Object.fromEntries(
+      normalizedHandles.map((handle, index) => [handle, orderedValues[index]])
+    );
+    const abiEncodedClearValues = concat(orderedValues.map((v) => pad(toHex(v), { size: 32 })));
+    const signature = await KMS_SIGNER.signTypedData({
+      domain: KMS_DECRYPTION_EIP712.domain(
+        this.#config.gatewayChainId,
+        this.#config.contracts.verifyingDecryption
+      ),
+      types: KMS_DECRYPTION_TYPES,
+      primaryType: "PublicDecryptVerification",
+      message: {
+        ctHandles: normalizedHandles,
+        decryptedResult: abiEncodedClearValues,
+        extraData: "0x"
+      }
+    });
+    const decryptionProof = concat([toHex(new Uint8Array([1])), signature]);
+    return {
+      clearValues,
+      abiEncodedClearValues,
+      decryptionProof
+    };
+  }
+  async createDelegatedUserDecryptEIP712(publicKey, contractAddresses, delegatorAddress, startTimestamp, durationDays = 7) {
+    const domain = {
+      name: "Decryption",
+      version: "1",
+      chainId: this.#config.chainId,
+      verifyingContract: this.#config.contracts.verifyingDecryption
+    };
+    const message = {
+      publicKey,
+      contractAddresses,
+      delegatorAddress,
+      startTimestamp: String(startTimestamp),
+      durationDays: String(durationDays),
+      extraData: "0x00"
+    };
+    return {
+      domain,
+      types: DELEGATED_USER_DECRYPT_TYPES,
+      primaryType: "DelegatedUserDecryptRequestVerification",
+      message
+    };
+  }
+  async delegatedUserDecrypt(params) {
+    const normalizedHandles = params.handles.map(normalizeHandle);
+    const delegatedResults = await Promise.all(
+      normalizedHandles.map(
+        (handle) => this.#isHandleDelegatedForUserDecryption(
+          params.delegatorAddress,
+          params.delegateAddress,
+          params.contractAddress,
+          handle
+        )
+      )
+    );
+    const unauthorizedIndex = delegatedResults.findIndex((isDelegated) => !isDelegated);
+    if (unauthorizedIndex !== -1) {
+      throw new DecryptionFailedError(
+        `Handle ${normalizedHandles[unauthorizedIndex]} is not delegated for user decryption (delegator=${params.delegatorAddress}, delegate=${params.delegateAddress}, contract=${params.contractAddress})`
+      );
+    }
+    return this.#decryptHandles(normalizedHandles);
+  }
+  async requestZKProofVerification(_zkProof) {
+    throw new ConfigurationError("Not implemented in cleartext mode");
+  }
+  async getPublicKey() {
+    return null;
+  }
+  async getPublicParams(_bits) {
+    return null;
+  }
+  terminate() {
+  }
+  async #decryptHandles(normalizedHandles) {
+    const values = await Promise.all(
+      normalizedHandles.map((handle) => this.#readPlaintext(handle))
+    );
+    return Object.fromEntries(
+      normalizedHandles.map((handle, index) => [
+        handle,
+        decodeDecryptedValue(handle, values[index])
+      ])
+    );
+  }
+  async #persistAllowed(handle, account) {
+    return this.#client.readContract({
+      address: this.#config.contracts.acl,
+      abi: ACL_ABI,
+      functionName: "persistAllowed",
+      args: [handle, account]
+    });
+  }
+  async #isAllowedForDecryption(handle) {
+    return this.#client.readContract({
+      address: this.#config.contracts.acl,
+      abi: ACL_ABI,
+      functionName: "isAllowedForDecryption",
+      args: [handle]
+    });
+  }
+  async #isHandleDelegatedForUserDecryption(delegator, delegate, contractAddress, handle) {
+    return this.#client.readContract({
+      address: this.#config.contracts.acl,
+      abi: ACL_ABI,
+      functionName: "isHandleDelegatedForUserDecryption",
+      args: [delegator, delegate, contractAddress, handle]
+    });
+  }
+  async #readPlaintext(handle) {
+    return this.#client.readContract({
+      address: this.#config.contracts.executor,
+      abi: EXECUTOR_ABI,
+      functionName: "plaintexts",
+      args: [handle]
+    });
+  }
+};
+
+// src/relayer/cleartext/factory.ts
+function createCleartextRelayer(config) {
+  const client = createPublicClient({
+    transport: typeof config.rpcUrl === "string" ? http(config.rpcUrl) : custom(config.rpcUrl)
+  });
+  const { rpcUrl: _, ...internalConfig } = config;
+  return new CleartextFhevmInstance(client, internalConfig);
+}
+
+// src/relayer/cleartext/presets.ts
+var hoodi = {
+  chainId: 560048n,
+  gatewayChainId: 10901,
+  rpcUrl: "https://rpc.hoodi.ethpandaops.io",
+  contracts: {
+    acl: "0xCC505dF6f244AcBf12C915888eC046939a439dB5",
+    executor: "0xfeec4C7e8Ad0Af0F42b594A453F4dB6da01e21D6",
+    kmsVerifier: "0xdae4028BD86408F59Db79032EDd05170FE350c5d",
+    inputVerifier: "0x2cD198C290d8AD6C5F2020C35F7b5868b74bDD55",
+    verifyingInputVerifier: "0x812b06e1CDCE800494b79fFE4f925A504a9A9810",
+    verifyingDecryption: "0x5ffdaAB0373E62E2ea2944776209aEf29E631A64"
+  }
+};
+
+export { GATEWAY_CHAIN_ID, VERIFYING_CONTRACTS, createCleartextRelayer, hoodi };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map

package/dist/cleartext/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/relayer/cleartext/eip712.ts","../../src/relayer/cleartext/constants.ts","../../src/relayer/cleartext/handle.ts","../../src/relayer/cleartext/encrypted-input.ts","../../src/relayer/cleartext/cleartext-fhevm-instance.ts","../../src/relayer/cleartext/factory.ts","../../src/relayer/cleartext/presets.ts"],"names":["keccak256","concat","pad","toHex","toBytes","privateKeyToAccount","getAddress"],"mappings":"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","file":"index.js","sourcesContent":["import type { TypedDataDomain } from \"viem\";\n\ntype DomainFactory = (chainId: number | bigint, verifyingContract: string) => TypedDataDomain;\n\nconst inputDomain: DomainFactory = (chainId, verifyingContract) => ({\n  name: \"InputVerification\",\n  version: \"1\",\n  chainId: Number(chainId),\n  verifyingContract: verifyingContract as `0x${string}`,\n});\n\nconst decryptionDomain: DomainFactory = (chainId, verifyingContract) => ({\n  name: \"Decryption\",\n  version: \"1\",\n  chainId: Number(chainId),\n  verifyingContract: verifyingContract as `0x${string}`,\n});\n\nexport const INPUT_VERIFICATION_EIP712 = {\n  domain: inputDomain,\n  types: {\n    CiphertextVerification: [\n      { name: \"ctHandles\", type: \"bytes32[]\" },\n      { name: \"userAddress\", type: \"address\" },\n      { name: \"contractAddress\", type: \"address\" },\n      { name: \"contractChainId\", type: \"uint256\" },\n      { name: \"extraData\", type: \"bytes\" },\n    ],\n  },\n} as const;\n\nexport const KMS_DECRYPTION_EIP712 = {\n  domain: decryptionDomain,\n  types: {\n    PublicDecryptVerification: [\n      { name: \"ctHandles\", type: \"bytes32[]\" },\n      { name: \"decryptedResult\", type: \"bytes\" },\n      { name: \"extraData\", type: \"bytes\" },\n    ],\n  },\n} as const;\n\nexport const USER_DECRYPT_EIP712 = {\n  domain: decryptionDomain,\n  types: {\n    UserDecryptRequestVerification: [\n      { name: \"publicKey\", type: \"bytes\" },\n      { name: \"contractAddresses\", type: \"address[]\" },\n      { name: \"startTimestamp\", type: \"uint256\" },\n      { name: \"durationDays\", type: \"uint256\" },\n      { name: \"extraData\", type: \"bytes\" },\n    ],\n  },\n} as const;\n\nexport const DELEGATED_USER_DECRYPT_EIP712 = {\n  domain: decryptionDomain,\n  types: {\n    DelegatedUserDecryptRequestVerification: [\n      { name: \"publicKey\", type: \"bytes\" },\n      { name: \"contractAddresses\", type: \"address[]\" },\n      { name: \"delegatorAddress\", type: \"address\" },\n      { name: \"startTimestamp\", type: \"uint256\" },\n      { name: \"durationDays\", type: \"uint256\" },\n      { name: \"extraData\", type: \"bytes\" },\n    ],\n  },\n} as const;\n","export enum FheType {\n  Bool = 0,\n  Uint4 = 1,\n  Uint8 = 2,\n  Uint16 = 3,\n  Uint32 = 4,\n  Uint64 = 5,\n  Uint128 = 6,\n  Uint160 = 7,\n  Uint256 = 8,\n}\n\nexport const FHE_BIT_WIDTHS: Record<FheType, number> = {\n  [FheType.Bool]: 1,\n  [FheType.Uint4]: 4,\n  [FheType.Uint8]: 8,\n  [FheType.Uint16]: 16,\n  [FheType.Uint32]: 32,\n  [FheType.Uint64]: 64,\n  [FheType.Uint128]: 128,\n  [FheType.Uint160]: 160,\n  [FheType.Uint256]: 256,\n};\n\nexport const HANDLE_VERSION = 0;\n\nexport const PREHANDLE_MASK = 0xffffffffffffffffffffffffffffffffffffffffff0000000000000000000000n;\n\n// Constants used for instanciation of the cleartext FHEVM instance.\nexport const MOCK_INPUT_SIGNER_PK =\n  \"0x7ec8ada6642fc4ccfb7729bc29c17cf8d21b61abd5642d1db992c0b8672ab901\";\nexport const MOCK_KMS_SIGNER_PK =\n  \"0x388b7680e4e1afa06efbfd45cdd1fe39f3c6af381df6555a19661f283b97de91\";\n\nexport const VERIFYING_CONTRACTS = {\n  inputVerification: \"0x812b06e1CDCE800494b79fFE4f925A504a9A9810\",\n  decryption: \"0x5ffdaAB0373E62E2ea2944776209aEf29E631A64\",\n} as const;\n\nexport const GATEWAY_CHAIN_ID = 10_901;\n","import { concat, encodePacked, keccak256, pad, toBytes, toHex } from \"viem\";\nimport { FHE_BIT_WIDTHS, FheType, HANDLE_VERSION, PREHANDLE_MASK } from \"./constants\";\nimport { EncryptionFailedError } from \"../../token/errors\";\n\nconst RAW_CT_HASH_DOMAIN_SEPARATOR = toBytes(\"ZK-w_rct\");\nconst HANDLE_HASH_DOMAIN_SEPARATOR = toBytes(\"ZK-w_hdl\");\n\nfunction cleartextToBytes(cleartext: bigint, fheType: FheType): Uint8Array {\n  const byteLength = Math.ceil(FHE_BIT_WIDTHS[fheType] / 8);\n  return toBytes(pad(toHex(cleartext), { size: byteLength }));\n}\n\nexport function computeMockCiphertext(\n  fheType: FheType,\n  cleartext: bigint,\n  random32: Uint8Array,\n): string {\n  if (random32.length !== 32) {\n    throw new EncryptionFailedError(\"random32 must be exactly 32 bytes\");\n  }\n\n  const clearBytes = cleartextToBytes(cleartext, fheType);\n  const inner = keccak256(\n    concat([toHex(new Uint8Array([fheType])), toHex(clearBytes), toHex(random32)]),\n  );\n\n  return keccak256(concat([toHex(RAW_CT_HASH_DOMAIN_SEPARATOR), inner]));\n}\n\nexport function computeInputHandle(\n  mockCiphertext: string,\n  index: number,\n  fheType: FheType,\n  aclAddress: string,\n  chainId: bigint,\n): string {\n  if (!Number.isInteger(index) || index < 0 || index > 255) {\n    throw new EncryptionFailedError(\"index must be an integer between 0 and 255\");\n  }\n\n  const blobHash = keccak256(\n    concat([toHex(RAW_CT_HASH_DOMAIN_SEPARATOR), mockCiphertext as `0x${string}`]),\n  );\n  const handleHash = keccak256(\n    encodePacked(\n      [\"bytes\", \"bytes32\", \"uint8\", \"address\", \"uint256\"],\n      [\n        toHex(HANDLE_HASH_DOMAIN_SEPARATOR),\n        blobHash as `0x${string}`,\n        index,\n        aclAddress as `0x${string}`,\n        chainId,\n      ],\n    ),\n  );\n\n  const chainId64 = chainId & 0xffff_ffff_ffff_ffffn;\n  const handle =\n    (BigInt(handleHash) & PREHANDLE_MASK) |\n    (BigInt(index) << 80n) |\n    (chainId64 << 16n) |\n    (BigInt(fheType) << 8n) |\n    BigInt(HANDLE_VERSION);\n\n  return toHex(handle, { size: 32 });\n}\n","import { concat, getAddress, keccak256, pad, toBytes, toHex } from \"viem\";\nimport { privateKeyToAccount } from \"viem/accounts\";\nimport { FHE_BIT_WIDTHS, FheType } from \"./constants\";\nimport { INPUT_VERIFICATION_EIP712 } from \"./eip712\";\nimport { computeInputHandle, computeMockCiphertext } from \"./handle\";\nimport { MOCK_INPUT_SIGNER_PK } from \"./constants\";\nimport type { CleartextConfig } from \"./types\";\nimport { EncryptionFailedError } from \"../../token/errors\";\n\nconst INPUT_SIGNER = privateKeyToAccount(MOCK_INPUT_SIGNER_PK as `0x${string}`);\n\ntype AddedValue = {\n  fheType: FheType;\n  value: bigint;\n};\n\nexport class CleartextEncryptedInput {\n  readonly #contractAddress: string;\n  readonly #userAddress: string;\n  readonly #config: CleartextConfig;\n  readonly #values: AddedValue[] = [];\n\n  constructor(contractAddress: string, userAddress: string, config: CleartextConfig) {\n    this.#contractAddress = getAddress(contractAddress);\n    this.#userAddress = getAddress(userAddress);\n    this.#config = config;\n  }\n\n  #addValue(fheType: FheType, value: bigint): this {\n    if (value < 0n) {\n      throw new EncryptionFailedError(\"Only non-negative cleartext values are supported\");\n    }\n\n    const bitWidth = FHE_BIT_WIDTHS[fheType];\n    const maxValue = (1n << BigInt(bitWidth)) - 1n;\n    if (value > maxValue) {\n      throw new EncryptionFailedError(\n        `Value ${value} exceeds max ${maxValue} for FheType ${fheType}`,\n      );\n    }\n\n    this.#values.push({ fheType, value });\n    return this;\n  }\n\n  addBool(value: boolean | bigint): this {\n    const normalized = typeof value === \"boolean\" ? (value ? 1n : 0n) : value;\n    if (normalized !== 0n && normalized !== 1n) {\n      throw new EncryptionFailedError(\"Bool value must be 0, 1, true, or false\");\n    }\n    return this.#addValue(FheType.Bool, normalized);\n  }\n\n  add4(value: bigint): this {\n    return this.#addValue(FheType.Uint4, value);\n  }\n\n  add8(value: bigint): this {\n    return this.#addValue(FheType.Uint8, value);\n  }\n\n  add16(value: bigint): this {\n    return this.#addValue(FheType.Uint16, value);\n  }\n\n  add32(value: bigint): this {\n    return this.#addValue(FheType.Uint32, value);\n  }\n\n  add64(value: bigint): this {\n    return this.#addValue(FheType.Uint64, value);\n  }\n\n  add128(value: bigint): this {\n    return this.#addValue(FheType.Uint128, value);\n  }\n\n  addAddress(value: string): this {\n    return this.#addValue(FheType.Uint160, BigInt(getAddress(value)));\n  }\n\n  add256(value: bigint): this {\n    return this.#addValue(FheType.Uint256, value);\n  }\n\n  async encrypt(): Promise<{ handles: Uint8Array[]; inputProof: Uint8Array }> {\n    const random32List = this.#values.map(() => crypto.getRandomValues(new Uint8Array(32)));\n\n    const mockCiphertexts = this.#values.map(({ fheType, value }, index) =>\n      computeMockCiphertext(fheType, value, random32List[index]!),\n    );\n\n    const ciphertextParts = mockCiphertexts.map((ciphertext) => ciphertext as `0x${string}`);\n    const ciphertextBlob = keccak256(ciphertextParts.length > 0 ? concat(ciphertextParts) : \"0x\");\n\n    const handles = this.#values.map(({ fheType }, index) =>\n      computeInputHandle(\n        ciphertextBlob,\n        index,\n        fheType,\n        this.#config.contracts.acl,\n        this.#config.chainId,\n      ),\n    );\n\n    const cleartextParts = this.#values.map(({ value }) => pad(toHex(value), { size: 32 }));\n    const cleartextBytes: `0x${string}` = cleartextParts.length > 0 ? concat(cleartextParts) : \"0x\";\n\n    const signature = await INPUT_SIGNER.signTypedData({\n      domain: INPUT_VERIFICATION_EIP712.domain(\n        this.#config.gatewayChainId,\n        this.#config.contracts.verifyingInputVerifier,\n      ),\n      types: {\n        CiphertextVerification: [...INPUT_VERIFICATION_EIP712.types.CiphertextVerification],\n      },\n      primaryType: \"CiphertextVerification\",\n      message: {\n        ctHandles: handles as `0x${string}`[],\n        userAddress: this.#userAddress as `0x${string}`,\n        contractAddress: this.#contractAddress as `0x${string}`,\n        contractChainId: this.#config.chainId,\n        extraData: cleartextBytes,\n      },\n    });\n\n    const inputProof = toBytes(\n      concat([\n        toHex(new Uint8Array([handles.length])),\n        toHex(new Uint8Array([1])),\n        ...handles.map((handle) => handle as `0x${string}`),\n        signature,\n        cleartextBytes,\n      ]),\n    );\n\n    return {\n      handles: handles.map((handle) => toBytes(handle as `0x${string}`)),\n      inputProof,\n    };\n  }\n}\n","import { privateKeyToAccount } from \"viem/accounts\";\nimport { concat, getAddress, hexToBigInt, pad, parseAbi, toHex } from \"viem\";\nimport type { PublicClient } from \"viem\";\nimport { mainnet, sepolia } from \"viem/chains\";\nimport type { RelayerSDK } from \"../relayer-sdk\";\nimport type {\n  Address,\n  DecryptedValue,\n  DelegatedUserDecryptParams,\n  EIP712TypedData,\n  EncryptInput,\n  EncryptParams,\n  EncryptResult,\n  FHEKeypair,\n  InputProofBytesType,\n  KmsDelegatedUserDecryptEIP712Type,\n  PublicDecryptResult,\n  UserDecryptParams,\n  ZKProofLike,\n} from \"../relayer-sdk.types\";\nimport {\n  DELEGATED_USER_DECRYPT_EIP712,\n  KMS_DECRYPTION_EIP712,\n  USER_DECRYPT_EIP712,\n} from \"./eip712\";\nimport { CleartextEncryptedInput } from \"./encrypted-input\";\nimport { FheType, MOCK_KMS_SIGNER_PK } from \"./constants\";\nimport type { CleartextConfig } from \"./types\";\nimport {\n  ConfigurationError,\n  DecryptionFailedError,\n  EncryptionFailedError,\n} from \"../../token/errors\";\n\nconst KMS_SIGNER = privateKeyToAccount(MOCK_KMS_SIGNER_PK as `0x${string}`);\n\nconst ACL_ABI = parseAbi([\n  \"function persistAllowed(bytes32 handle, address account) view returns (bool)\",\n  \"function isAllowedForDecryption(bytes32 handle) view returns (bool)\",\n  \"function isHandleDelegatedForUserDecryption(address delegator, address delegate, address contractAddress, bytes32 handle) view returns (bool)\",\n]);\n\nconst EXECUTOR_ABI = parseAbi([\"function plaintexts(bytes32 handle) view returns (uint256)\"]);\n\nconst USER_DECRYPT_TYPES = {\n  UserDecryptRequestVerification: USER_DECRYPT_EIP712.types\n    .UserDecryptRequestVerification as unknown as Array<{ name: string; type: string }>,\n};\nconst DELEGATED_USER_DECRYPT_TYPES: KmsDelegatedUserDecryptEIP712Type[\"types\"] = {\n  EIP712Domain: [\n    { name: \"name\", type: \"string\" },\n    { name: \"version\", type: \"string\" },\n    { name: \"chainId\", type: \"uint256\" },\n    { name: \"verifyingContract\", type: \"address\" },\n  ],\n  DelegatedUserDecryptRequestVerification:\n    DELEGATED_USER_DECRYPT_EIP712.types.DelegatedUserDecryptRequestVerification,\n};\nconst KMS_DECRYPTION_TYPES = {\n  PublicDecryptVerification: KMS_DECRYPTION_EIP712.types\n    .PublicDecryptVerification as unknown as Array<{ name: string; type: string }>,\n};\n\ntype Hex = `0x${string}`;\n\nfunction normalizeHandle(handle: string): Hex {\n  return toHex(hexToBigInt(handle as Hex), { size: 32 });\n}\n\nfunction decodeDecryptedValue(handle: string, rawValue: bigint): DecryptedValue {\n  const typeByte = Number((BigInt(handle) >> 8n) & 0xffn);\n  if (typeByte === FheType.Bool) return rawValue !== 0n;\n  if (typeByte === FheType.Uint160) return toHex(rawValue, { size: 20 });\n  return rawValue;\n}\n\nexport class CleartextFhevmInstance implements RelayerSDK {\n  readonly #client: PublicClient;\n  readonly #config: CleartextConfig;\n\n  static readonly #FORBIDDEN_CHAIN_IDS = new Set([BigInt(mainnet.id), BigInt(sepolia.id)]);\n\n  constructor(client: PublicClient, config: CleartextConfig) {\n    if (CleartextFhevmInstance.#FORBIDDEN_CHAIN_IDS.has(config.chainId)) {\n      throw new ConfigurationError(\n        `Cleartext mode is not allowed on chain ${config.chainId}. ` +\n          `It is intended for local development and testing only.`,\n      );\n    }\n    this.#client = client;\n    this.#config = config;\n  }\n\n  async generateKeypair(): Promise<FHEKeypair> {\n    const publicKey = toHex(crypto.getRandomValues(new Uint8Array(32)));\n    let privateKey = toHex(crypto.getRandomValues(new Uint8Array(32)));\n\n    while (privateKey === publicKey) {\n      privateKey = toHex(crypto.getRandomValues(new Uint8Array(32)));\n    }\n\n    return { publicKey, privateKey };\n  }\n\n  async createEIP712(\n    publicKey: string,\n    contractAddresses: Address[],\n    startTimestamp: number,\n    durationDays: number = 7,\n  ): Promise<EIP712TypedData> {\n    const domain: EIP712TypedData[\"domain\"] = {\n      name: \"Decryption\",\n      version: \"1\",\n      chainId: Number(this.#config.chainId),\n      verifyingContract: this.#config.contracts.verifyingDecryption as Address,\n    };\n\n    return {\n      domain,\n      types: USER_DECRYPT_TYPES,\n      primaryType: \"UserDecryptRequestVerification\",\n      message: {\n        publicKey,\n        contractAddresses,\n        startTimestamp: BigInt(startTimestamp),\n        durationDays: BigInt(durationDays),\n        extraData: \"0x00\",\n      },\n    };\n  }\n\n  async encrypt(params: EncryptParams): Promise<EncryptResult> {\n    const input = new CleartextEncryptedInput(\n      params.contractAddress,\n      params.userAddress,\n      this.#config,\n    );\n\n    for (const entry of params.values) {\n      const { value, type } = entry as EncryptInput;\n      switch (type) {\n        case \"ebool\":\n          input.addBool(value);\n          break;\n        case \"euint8\":\n          input.add8(value as bigint);\n          break;\n        case \"euint16\":\n          input.add16(value as bigint);\n          break;\n        case \"euint32\":\n          input.add32(value as bigint);\n          break;\n        case \"euint64\":\n          input.add64(value as bigint);\n          break;\n        case \"euint128\":\n          input.add128(value as bigint);\n          break;\n        case \"eaddress\":\n          input.addAddress(value as unknown as string);\n          break;\n        case \"euint256\":\n          input.add256(value as bigint);\n          break;\n        default:\n          throw new EncryptionFailedError(`Unsupported FHE type: ${type satisfies never}`);\n      }\n    }\n\n    return input.encrypt();\n  }\n\n  async userDecrypt(params: UserDecryptParams): Promise<Record<string, DecryptedValue>> {\n    const normalizedSignerAddress = getAddress(params.signerAddress);\n    const normalizedHandles = params.handles.map(normalizeHandle);\n\n    const allowedResults = await Promise.all(\n      normalizedHandles.map((handle) => this.#persistAllowed(handle, normalizedSignerAddress)),\n    );\n    const unauthorizedIndex = allowedResults.findIndex((isAllowed) => !isAllowed);\n    if (unauthorizedIndex !== -1) {\n      throw new DecryptionFailedError(\n        `Handle ${normalizedHandles[unauthorizedIndex]!} is not authorized for user decrypt`,\n      );\n    }\n\n    return this.#decryptHandles(normalizedHandles);\n  }\n\n  async publicDecrypt(handles: string[]): Promise<PublicDecryptResult> {\n    const normalizedHandles = handles.map(normalizeHandle);\n\n    const allowedResults = await Promise.all(\n      normalizedHandles.map((handle) => this.#isAllowedForDecryption(handle)),\n    );\n    const unauthorizedIndex = allowedResults.findIndex((isAllowed) => !isAllowed);\n    if (unauthorizedIndex !== -1) {\n      throw new DecryptionFailedError(\n        `Handle ${normalizedHandles[unauthorizedIndex]!} is not allowed for public decryption`,\n      );\n    }\n\n    const orderedValues = await Promise.all(\n      normalizedHandles.map((handle) => this.#readPlaintext(handle)),\n    );\n    const clearValues = Object.fromEntries(\n      normalizedHandles.map((handle, index) => [handle, orderedValues[index]!]),\n    ) as Record<string, bigint>;\n\n    const abiEncodedClearValues = concat(orderedValues.map((v) => pad(toHex(v), { size: 32 })));\n\n    const signature = await KMS_SIGNER.signTypedData({\n      domain: KMS_DECRYPTION_EIP712.domain(\n        this.#config.gatewayChainId,\n        this.#config.contracts.verifyingDecryption,\n      ) as {\n        name: string;\n        version: string;\n        chainId: number | bigint;\n        verifyingContract: Hex;\n      },\n      types: KMS_DECRYPTION_TYPES,\n      primaryType: \"PublicDecryptVerification\",\n      message: {\n        ctHandles: normalizedHandles,\n        decryptedResult: abiEncodedClearValues,\n        extraData: \"0x\",\n      },\n    });\n\n    const decryptionProof = concat([toHex(new Uint8Array([1])), signature]) as Address;\n\n    return {\n      clearValues,\n      abiEncodedClearValues,\n      decryptionProof,\n    };\n  }\n\n  async createDelegatedUserDecryptEIP712(\n    publicKey: string,\n    contractAddresses: Address[],\n    delegatorAddress: string,\n    startTimestamp: number,\n    durationDays: number = 7,\n  ): Promise<KmsDelegatedUserDecryptEIP712Type> {\n    const domain: KmsDelegatedUserDecryptEIP712Type[\"domain\"] = {\n      name: \"Decryption\",\n      version: \"1\",\n      chainId: this.#config.chainId,\n      verifyingContract: this.#config.contracts.verifyingDecryption as Address,\n    };\n    const message: KmsDelegatedUserDecryptEIP712Type[\"message\"] = {\n      publicKey: publicKey as KmsDelegatedUserDecryptEIP712Type[\"message\"][\"publicKey\"],\n      contractAddresses:\n        contractAddresses as KmsDelegatedUserDecryptEIP712Type[\"message\"][\"contractAddresses\"],\n      delegatorAddress:\n        delegatorAddress as KmsDelegatedUserDecryptEIP712Type[\"message\"][\"delegatorAddress\"],\n      startTimestamp: String(startTimestamp),\n      durationDays: String(durationDays),\n      extraData: \"0x00\" as KmsDelegatedUserDecryptEIP712Type[\"message\"][\"extraData\"],\n    };\n\n    return {\n      domain,\n      types: DELEGATED_USER_DECRYPT_TYPES,\n      primaryType: \"DelegatedUserDecryptRequestVerification\",\n      message,\n    };\n  }\n\n  async delegatedUserDecrypt(\n    params: DelegatedUserDecryptParams,\n  ): Promise<Record<string, DecryptedValue>> {\n    const normalizedHandles = params.handles.map(normalizeHandle);\n\n    const delegatedResults = await Promise.all(\n      normalizedHandles.map((handle) =>\n        this.#isHandleDelegatedForUserDecryption(\n          params.delegatorAddress,\n          params.delegateAddress,\n          params.contractAddress,\n          handle,\n        ),\n      ),\n    );\n    const unauthorizedIndex = delegatedResults.findIndex((isDelegated) => !isDelegated);\n    if (unauthorizedIndex !== -1) {\n      throw new DecryptionFailedError(\n        `Handle ${normalizedHandles[unauthorizedIndex]!} is not delegated for user decryption (delegator=${params.delegatorAddress}, delegate=${params.delegateAddress}, contract=${params.contractAddress})`,\n      );\n    }\n\n    return this.#decryptHandles(normalizedHandles);\n  }\n\n  async requestZKProofVerification(_zkProof: ZKProofLike): Promise<InputProofBytesType> {\n    throw new ConfigurationError(\"Not implemented in cleartext mode\");\n  }\n\n  async getPublicKey(): Promise<{ publicKeyId: string; publicKey: Uint8Array } | null> {\n    return null;\n  }\n\n  async getPublicParams(\n    _bits: number,\n  ): Promise<{ publicParams: Uint8Array; publicParamsId: string } | null> {\n    return null;\n  }\n\n  terminate(): void {\n    // No resources to release in cleartext mode.\n  }\n\n  async #decryptHandles(normalizedHandles: Hex[]): Promise<Record<string, DecryptedValue>> {\n    const values = await Promise.all(\n      normalizedHandles.map((handle) => this.#readPlaintext(handle)),\n    );\n\n    return Object.fromEntries(\n      normalizedHandles.map((handle, index) => [\n        handle,\n        decodeDecryptedValue(handle, values[index]!),\n      ]),\n    ) as Record<string, DecryptedValue>;\n  }\n\n  async #persistAllowed(handle: Hex, account: Hex): Promise<boolean> {\n    return this.#client.readContract({\n      address: this.#config.contracts.acl as Hex,\n      abi: ACL_ABI,\n      functionName: \"persistAllowed\",\n      args: [handle, account],\n    });\n  }\n\n  async #isAllowedForDecryption(handle: Hex): Promise<boolean> {\n    return this.#client.readContract({\n      address: this.#config.contracts.acl as Hex,\n      abi: ACL_ABI,\n      functionName: \"isAllowedForDecryption\",\n      args: [handle],\n    });\n  }\n\n  async #isHandleDelegatedForUserDecryption(\n    delegator: string,\n    delegate: string,\n    contractAddress: string,\n    handle: Hex,\n  ): Promise<boolean> {\n    return this.#client.readContract({\n      address: this.#config.contracts.acl as Hex,\n      abi: ACL_ABI,\n      functionName: \"isHandleDelegatedForUserDecryption\",\n      args: [delegator as Hex, delegate as Hex, contractAddress as Hex, handle],\n    });\n  }\n\n  async #readPlaintext(handle: Hex): Promise<bigint> {\n    return this.#client.readContract({\n      address: this.#config.contracts.executor as Hex,\n      abi: EXECUTOR_ABI,\n      functionName: \"plaintexts\",\n      args: [handle],\n    });\n  }\n}\n","import { createPublicClient, custom, http } from \"viem\";\nimport type { RelayerSDK } from \"../relayer-sdk\";\nimport { CleartextFhevmInstance } from \"./cleartext-fhevm-instance\";\nimport type { CleartextChainConfig } from \"./types\";\n\nexport function createCleartextRelayer(config: CleartextChainConfig): RelayerSDK {\n  const client = createPublicClient({\n    transport: typeof config.rpcUrl === \"string\" ? http(config.rpcUrl) : custom(config.rpcUrl),\n  });\n\n  const { rpcUrl: _, ...internalConfig } = config;\n\n  return new CleartextFhevmInstance(client, internalConfig);\n}\n","import type { CleartextChainConfig } from \"./types\";\n\nexport const hoodi = {\n  chainId: 560048n,\n  gatewayChainId: 10901,\n  rpcUrl: \"https://rpc.hoodi.ethpandaops.io\",\n  contracts: {\n    acl: \"0xCC505dF6f244AcBf12C915888eC046939a439dB5\",\n    executor: \"0xfeec4C7e8Ad0Af0F42b594A453F4dB6da01e21D6\",\n    kmsVerifier: \"0xdae4028BD86408F59Db79032EDd05170FE350c5d\",\n    inputVerifier: \"0x2cD198C290d8AD6C5F2020C35F7b5868b74bDD55\",\n    verifyingInputVerifier: \"0x812b06e1CDCE800494b79fFE4f925A504a9A9810\",\n    verifyingDecryption: \"0x5ffdaAB0373E62E2ea2944776209aEf29E631A64\",\n  },\n} satisfies CleartextChainConfig;\n"]}