@cofhe/sdk 0.7.1 → 0.8.0

package/dist/{chunk-Q7CBWGQX.js → chunk-UJYOBHYA.js}

@@ -1,5 +1,5 @@
-import { TASK_MANAGER_ADDRESS } from './chunk-ESMZCFJY.js';
-import { isAddress, getAddress, zeroAddress, isHex, keccak256, toHex, BaseError, ContractFunctionRevertedError, decodeErrorResult, parseAbi } from 'viem';
+import { TASK_MANAGER_ID, COFHE_ADDRESS_BOOK_ADDRESS } from './chunk-NMKMCAI3.js';
+import { isAddress, getAddress, zeroAddress, isHex, parseAbi, keccak256, toHex, encodeAbiParameters, decodeErrorResult } from 'viem';
 import nacl from 'tweetnacl';
 import { z } from 'zod';
 import { createStore } from 'zustand/vanilla';
@@ -389,11 +389,202 @@ var SignatureUtils = {
     throw new Error(`Unknown acp type: ${acpType}`);
   }
 };
+
+// core/error.ts
+var CofheErrorCode = /* @__PURE__ */ ((CofheErrorCode2) => {
+  CofheErrorCode2["InternalError"] = "INTERNAL_ERROR";
+  CofheErrorCode2["UnknownEnvironment"] = "UNKNOWN_ENVIRONMENT";
+  CofheErrorCode2["InitTfheFailed"] = "INIT_TFHE_FAILED";
+  CofheErrorCode2["InitViemFailed"] = "INIT_VIEM_FAILED";
+  CofheErrorCode2["InitEthersFailed"] = "INIT_ETHERS_FAILED";
+  CofheErrorCode2["NotConnected"] = "NOT_CONNECTED";
+  CofheErrorCode2["MissingPublicClient"] = "MISSING_PUBLIC_CLIENT";
+  CofheErrorCode2["MissingWalletClient"] = "MISSING_WALLET_CLIENT";
+  CofheErrorCode2["MissingProviderParam"] = "MISSING_PROVIDER_PARAM";
+  CofheErrorCode2["EmptySecurityZonesParam"] = "EMPTY_SECURITY_ZONES_PARAM";
+  CofheErrorCode2["InvalidACPData"] = "INVALID_ACP_DATA";
+  CofheErrorCode2["InvalidACPDomain"] = "INVALID_ACP_DOMAIN";
+  CofheErrorCode2["ACPNotFound"] = "ACP_NOT_FOUND";
+  CofheErrorCode2["CannotRemoveLastACP"] = "CANNOT_REMOVE_LAST_ACP";
+  CofheErrorCode2["AccountUninitialized"] = "ACCOUNT_UNINITIALIZED";
+  CofheErrorCode2["ChainIdUninitialized"] = "CHAIN_ID_UNINITIALIZED";
+  CofheErrorCode2["ConsumingContractUninitialized"] = "CONSUMING_CONTRACT_UNINITIALIZED";
+  CofheErrorCode2["SealOutputFailed"] = "SEAL_OUTPUT_FAILED";
+  CofheErrorCode2["SealOutputReturnedNull"] = "SEAL_OUTPUT_RETURNED_NULL";
+  CofheErrorCode2["InvalidUtype"] = "INVALID_UTYPE";
+  CofheErrorCode2["DecryptFailed"] = "DECRYPT_FAILED";
+  CofheErrorCode2["DecryptReturnedNull"] = "DECRYPT_RETURNED_NULL";
+  CofheErrorCode2["ZkMocksInsertCtHashesFailed"] = "ZK_MOCKS_INSERT_CT_HASHES_FAILED";
+  CofheErrorCode2["ZkMocksCalcCtHashesFailed"] = "ZK_MOCKS_CALC_CT_HASHES_FAILED";
+  CofheErrorCode2["ZkMocksVerifySignFailed"] = "ZK_MOCKS_VERIFY_SIGN_FAILED";
+  CofheErrorCode2["ZkMocksCreateProofSignatureFailed"] = "ZK_MOCKS_CREATE_PROOF_SIGNATURE_FAILED";
+  CofheErrorCode2["ZkVerifyFailed"] = "ZK_VERIFY_FAILED";
+  CofheErrorCode2["ZkPackFailed"] = "ZK_PACK_FAILED";
+  CofheErrorCode2["ZkProveFailed"] = "ZK_PROVE_FAILED";
+  CofheErrorCode2["EncryptRemainingInItems"] = "ENCRYPT_REMAINING_IN_ITEMS";
+  CofheErrorCode2["ZkUninitialized"] = "ZK_UNINITIALIZED";
+  CofheErrorCode2["ZkVerifierUrlUninitialized"] = "ZK_VERIFIER_URL_UNINITIALIZED";
+  CofheErrorCode2["ThresholdNetworkUrlUninitialized"] = "THRESHOLD_NETWORK_URL_UNINITIALIZED";
+  CofheErrorCode2["MissingConfig"] = "MISSING_CONFIG";
+  CofheErrorCode2["UnsupportedChain"] = "UNSUPPORTED_CHAIN";
+  CofheErrorCode2["MissingZkBuilderAndCrsGenerator"] = "MISSING_ZK_BUILDER_AND_CRS_GENERATOR";
+  CofheErrorCode2["MissingTfhePublicKeyDeserializer"] = "MISSING_TFHE_PUBLIC_KEY_DESERIALIZER";
+  CofheErrorCode2["MissingCompactPkeCrsDeserializer"] = "MISSING_COMPACT_PKE_CRS_DESERIALIZER";
+  CofheErrorCode2["MissingFheKey"] = "MISSING_FHE_KEY";
+  CofheErrorCode2["MissingCrs"] = "MISSING_CRS";
+  CofheErrorCode2["FetchKeysFailed"] = "FETCH_KEYS_FAILED";
+  CofheErrorCode2["PublicWalletGetChainIdFailed"] = "PUBLIC_WALLET_GET_CHAIN_ID_FAILED";
+  CofheErrorCode2["PublicWalletGetAddressesFailed"] = "PUBLIC_WALLET_GET_ADDRESSES_FAILED";
+  CofheErrorCode2["RehydrateKeysStoreFailed"] = "REHYDRATE_KEYS_STORE_FAILED";
+  CofheErrorCode2["TaskManagerUnresolved"] = "TASK_MANAGER_UNRESOLVED";
+  CofheErrorCode2["BadRequest"] = "BAD_REQUEST";
+  CofheErrorCode2["UnknownChain"] = "UNKNOWN_CHAIN";
+  CofheErrorCode2["ACPMalformed"] = "ACP_MALFORMED";
+  CofheErrorCode2["ACPDenied"] = "ACP_DENIED";
+  CofheErrorCode2["ACPExpired"] = "ACP_EXPIRED";
+  CofheErrorCode2["ACPInvalid"] = "ACP_INVALID";
+  CofheErrorCode2["ACPRevoked"] = "ACP_REVOKED";
+  CofheErrorCode2["NotPubliclyAllowed"] = "NOT_PUBLICLY_ALLOWED";
+  CofheErrorCode2["CtNotFound"] = "CT_NOT_FOUND";
+  CofheErrorCode2["UnsupportedSecurityZone"] = "UNSUPPORTED_SECURITY_ZONE";
+  CofheErrorCode2["UnsupportedType"] = "UNSUPPORTED_TYPE";
+  CofheErrorCode2["SigningFailed"] = "SIGNING_FAILED";
+  CofheErrorCode2["CtSourceError"] = "CT_SOURCE_ERROR";
+  CofheErrorCode2["ACPVerifierError"] = "ACP_VERIFIER_ERROR";
+  CofheErrorCode2["CtSourceTimeout"] = "CT_SOURCE_TIMEOUT";
+  CofheErrorCode2["ACPVerifierTimeout"] = "ACP_VERIFIER_TIMEOUT";
+  CofheErrorCode2["ACPRequired"] = "ACP_REQUIRED";
+  CofheErrorCode2["SealFailed"] = "SEAL_FAILED";
+  return CofheErrorCode2;
+})(CofheErrorCode || {});
+var CofheError = class _CofheError extends Error {
+  code;
+  cause;
+  hint;
+  context;
+  apiErrorCode;
+  constructor({ code, message, cause, hint, context, apiErrorCode }) {
+    const fullMessage = cause ? `${message} | Caused by: ${cause.message}` : message;
+    super(fullMessage);
+    this.name = "CofheError";
+    this.code = code;
+    this.cause = cause;
+    this.hint = hint;
+    this.context = context;
+    this.apiErrorCode = apiErrorCode;
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, _CofheError);
+    }
+  }
+  /**
+   * Creates a CofheError from an unknown error
+   * If the error is a CofheError, it is returned unchanged, else a new CofheError is created
+   * If a wrapperError is provided, it is used to create the new CofheError, else a default is used
+   */
+  static fromError(error, wrapperError) {
+    if (isCofheError(error))
+      return error;
+    const cause = error instanceof Error ? error : new Error(`${error}`);
+    return new _CofheError({
+      code: wrapperError?.code ?? "INTERNAL_ERROR" /* InternalError */,
+      message: wrapperError?.message ?? "An internal error occurred",
+      hint: wrapperError?.hint,
+      context: wrapperError?.context,
+      apiErrorCode: wrapperError?.apiErrorCode,
+      cause
+    });
+  }
+  /**
+   * Serializes the error to JSON string with proper handling of Error objects
+   */
+  serialize() {
+    return bigintSafeJsonStringify({
+      name: this.name,
+      code: this.code,
+      message: this.message,
+      hint: this.hint,
+      context: this.context,
+      apiErrorCode: this.apiErrorCode,
+      cause: this.cause ? {
+        name: this.cause.name,
+        message: this.cause.message,
+        stack: this.cause.stack
+      } : void 0,
+      stack: this.stack
+    });
+  }
+  /**
+   * Returns a human-readable string representation of the error
+   */
+  toString() {
+    const codeSuffix = this.apiErrorCode ? ` (api: ${this.apiErrorCode})` : "";
+    const parts = [`${this.name} [${this.code}]${codeSuffix}: ${this.message}`];
+    if (this.hint) {
+      parts.push(`Hint: ${this.hint}`);
+    }
+    if (this.context && Object.keys(this.context).length > 0) {
+      parts.push(`Context: ${bigintSafeJsonStringify(this.context)}`);
+    }
+    if (this.stack) {
+      parts.push(`
+Stack trace:`);
+      parts.push(this.stack);
+    }
+    if (this.cause) {
+      parts.push(`
+Caused by: ${this.cause.name}: ${this.cause.message}`);
+      if (this.cause.stack) {
+        parts.push(this.cause.stack);
+      }
+    }
+    return parts.join("\n");
+  }
+};
+var bigintSafeJsonStringify = (value) => {
+  return JSON.stringify(value, (key, value2) => {
+    if (typeof value2 === "bigint") {
+      return `${value2}n`;
+    }
+    return value2;
+  });
+};
+var isCofheError = (error) => error instanceof CofheError;
+
+// core/taskManager.ts
+var ADDRESS_BOOK_ABI = parseAbi([
+  "function getTm(uint256 id) view returns (address)",
+  "error TaskManagerNotSet(uint256 id)"
+]);
+var taskManagerAddressCache = /* @__PURE__ */ new Map();
+var getTaskManagerAddress = async (publicClient, chainId) => {
+  const id = chainId ?? publicClient.chain?.id ?? await publicClient.getChainId();
+  const cached = taskManagerAddressCache.get(id);
+  if (cached != null)
+    return cached;
+  const pending = publicClient.readContract({
+    address: COFHE_ADDRESS_BOOK_ADDRESS,
+    abi: ADDRESS_BOOK_ABI,
+    functionName: "getTm",
+    args: [TASK_MANAGER_ID]
+  }).catch((error) => {
+    taskManagerAddressCache.delete(id);
+    throw CofheError.fromError(error, {
+      code: "TASK_MANAGER_UNRESOLVED" /* TaskManagerUnresolved */,
+      message: `Failed to resolve the Task Manager from the CoFHEAddressBook on chain ${id}`,
+      hint: "Ensure CoFHE is deployed on this chain. On a local hardhat / anvil chain, deploy the CoFHE mocks first.",
+      context: { chainId: id, addressBook: COFHE_ADDRESS_BOOK_ADDRESS, taskManagerId: TASK_MANAGER_ID }
+    });
+  });
+  taskManagerAddressCache.set(id, pending);
+  return pending;
+};
+
+// acps/onchain-utils.ts
 var getAclAddress = async (publicClient) => {
   const ACL_IFACE = "function acl() view returns (address)";
   const aclAbi = parseAbi([ACL_IFACE]);
   return await publicClient.readContract({
-    address: TASK_MANAGER_ADDRESS,
+    address: await getTaskManagerAddress(publicClient),
     abi: aclAbi,
     functionName: "acl"
   });
@@ -420,6 +611,34 @@ var getAclEIP712Domain = async (publicClient) => {
     verifyingContract
   };
 };
+var toACPTuple = (acp) => ({
+  issuer: acp.issuer,
+  expiration: BigInt(acp.expiration),
+  recipient: acp.recipient,
+  revokerData: BigInt(acp.revokerData),
+  revokerContract: acp.revokerContract,
+  scope: acp.scope,
+  contracts: acp.contracts,
+  handles: acp.handles,
+  sealingKey: acp.sealingKey,
+  issuerSignature: acp.issuerSignature,
+  recipientSignature: acp.recipientSignature
+});
+function revertErrorName(err, abi) {
+  const walk = err?.walk;
+  if (typeof walk === "function") {
+    const revertError = walk.call(err, (e) => e?.name === "ContractFunctionRevertedError");
+    if (revertError)
+      return revertError.data?.errorName ?? "";
+  }
+  const customErrorName = extractCustomErrorFromDetails(err, abi);
+  if (customErrorName)
+    return customErrorName;
+  const hhDetailsData = extractReturnData(err);
+  if (hhDetailsData != null)
+    return decodeErrorResult({ abi, data: hhDetailsData }).errorName;
+  return void 0;
+}
 var checkACPValidityOnChain = async (acp, publicClient) => {
   const aclAddress = await getAclAddress(publicClient);
   try {
@@ -427,43 +646,54 @@ var checkACPValidityOnChain = async (acp, publicClient) => {
       address: aclAddress,
       abi: checkACPValidityAbi,
       functionName: "checkPermissionValidity",
-      args: [
-        {
-          issuer: acp.issuer,
-          expiration: BigInt(acp.expiration),
-          recipient: acp.recipient,
-          revokerData: BigInt(acp.revokerData),
-          revokerContract: acp.revokerContract,
-          scope: acp.scope,
-          contracts: acp.contracts,
-          handles: acp.handles,
-          sealingKey: acp.sealingKey,
-          issuerSignature: acp.issuerSignature,
-          recipientSignature: acp.recipientSignature
-        }
-      ]
+      args: [toACPTuple(acp)]
     });
     return true;
   } catch (err) {
-    if (err instanceof BaseError) {
-      const revertError = err.walk((err2) => err2 instanceof ContractFunctionRevertedError);
-      if (revertError instanceof ContractFunctionRevertedError) {
-        const errorName = revertError.data?.errorName ?? "";
-        throw new Error(errorName);
-      }
-    }
-    const customErrorName = extractCustomErrorFromDetails(err, checkACPValidityAbi);
-    if (customErrorName) {
-      throw new Error(customErrorName);
-    }
-    const hhDetailsData = extractReturnData(err);
-    if (hhDetailsData != null) {
-      const decoded = decodeErrorResult({
-        abi: checkACPValidityAbi,
-        data: hhDetailsData
+    const errorName = revertErrorName(err, checkACPValidityAbi);
+    if (errorName !== void 0)
+      throw new Error(errorName);
+    throw err;
+  }
+};
+var PERMISSION_ERROR_STATUS = {
+  PermissionInvalid_Expired: "expired",
+  PermissionInvalid_Disabled: "revoked",
+  PermissionInvalid_IssuerSignature: "invalid-issuer-signature",
+  PermissionInvalid_RecipientSignature: "invalid-recipient-signature"
+};
+var getACPAccessStatusOnChain = async (acp, publicClient, handle) => {
+  const aclAddress = await getAclAddress(publicClient);
+  try {
+    if (handle === void 0) {
+      await publicClient.simulateContract({
+        address: aclAddress,
+        abi: acpAccessAbi,
+        functionName: "checkPermissionValidity",
+        args: [toACPTuple(acp)]
       });
-      throw new Error(decoded.errorName);
+      return "valid";
     }
+    const ctHash = BigInt(handle);
+    const allowed = await publicClient.readContract({
+      address: aclAddress,
+      abi: acpAccessAbi,
+      functionName: "isAllowedWithPermission",
+      args: [toACPTuple(acp), ctHash]
+    });
+    if (allowed)
+      return "allowed";
+    const issuerAllowed = await publicClient.readContract({
+      address: aclAddress,
+      abi: acpAccessAbi,
+      functionName: "isAllowed",
+      args: [ctHash, acp.issuer]
+    });
+    return issuerAllowed ? "out-of-scope" : "issuer-not-allowed";
+  } catch (err) {
+    const status = PERMISSION_ERROR_STATUS[revertErrorName(err, acpAccessAbi) ?? ""];
+    if (status)
+      return status;
     throw err;
   }
 };
@@ -485,7 +715,8 @@ function extractCustomErrorFromDetails(err, abi) {
 function extractReturnData(err) {
   const anyErr = err;
   const s = anyErr?.details ?? anyErr?.cause?.details ?? anyErr?.shortMessage ?? anyErr?.message ?? String(err);
-  return s.match(/return data:\s*(0x[a-fA-F0-9]+)/)?.[1];
+  const match = s.match(/return data:\s*(0x[a-fA-F0-9]+)/) ?? s.match(/custom error (0x[a-fA-F0-9]{8,})/);
+  return match?.[1];
 }
 var checkACPValidityAbi = [
   {
@@ -585,6 +816,58 @@ var checkACPValidityAbi = [
     inputs: []
   }
 ];
+var acpAccessAbi = [
+  ...checkACPValidityAbi,
+  {
+    type: "function",
+    name: "isAllowedWithPermission",
+    inputs: [checkACPValidityAbi[0].inputs[0], { name: "handle", type: "uint256", internalType: "uint256" }],
+    outputs: [{ name: "", type: "bool", internalType: "bool" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "isAllowed",
+    inputs: [
+      { name: "handle", type: "uint256", internalType: "uint256" },
+      { name: "account", type: "address", internalType: "address" }
+    ],
+    outputs: [{ name: "", type: "bool", internalType: "bool" }],
+    stateMutability: "view"
+  }
+];
+var ACL_SERVED_ADDRESSES_ABI = parseAbi([
+  "function acl() view returns (address)",
+  "function defaultRevokerContract() view returns (address)",
+  "function shareRegistry() view returns (address)"
+]);
+var aclServedAddressesCache = /* @__PURE__ */ new Map();
+var clearAclServedAddresses = () => aclServedAddressesCache.clear();
+var getAclServedAddresses = async (publicClient, chainId) => {
+  const cached = aclServedAddressesCache.get(chainId);
+  if (cached != null)
+    return cached;
+  let aclAddress;
+  try {
+    aclAddress = await publicClient.readContract({
+      address: await getTaskManagerAddress(publicClient, chainId),
+      abi: ACL_SERVED_ADDRESSES_ABI,
+      functionName: "acl"
+    });
+  } catch {
+    return {};
+  }
+  const [defaultRevoker, shareRegistry] = await Promise.all([
+    publicClient.readContract({ address: aclAddress, abi: ACL_SERVED_ADDRESSES_ABI, functionName: "defaultRevokerContract" }).catch(() => void 0),
+    publicClient.readContract({ address: aclAddress, abi: ACL_SERVED_ADDRESSES_ABI, functionName: "shareRegistry" }).catch(() => void 0)
+  ]);
+  const resolved = {
+    defaultRevoker: defaultRevoker != null && defaultRevoker !== zeroAddress ? defaultRevoker : void 0,
+    shareRegistry: shareRegistry != null && shareRegistry !== zeroAddress ? shareRegistry : void 0
+  };
+  aclServedAddressesCache.set(chainId, resolved);
+  return resolved;
+};
 
 // acps/acp.ts
 var ACPUtils = {
@@ -898,8 +1181,62 @@ var ACPUtils = {
   checkValidityOnChain: async (acp, publicClient) => {
     const publicAcp = ACPUtils.getPublic(acp);
     return checkACPValidityOnChain(publicAcp, publicClient);
+  },
+  /**
+   * The acp on-chain status as a value instead of a revert: 'valid' or why not, and given a
+   * handle, whether the acp may read it (see `ACPAccessStatus`).
+   */
+  checkAccessOnChain: async (acp, publicClient, handle) => {
+    return getACPAccessStatusOnChain(ACPUtils.getPublic(acp), publicClient, handle);
+  }
+};
+var ACP_REVOKER_ABI = parseAbi([
+  "function revokeSingle(uint256 id)",
+  "function revokeAllExisting()",
+  "function disabled(address issuer, uint256 id) view returns (bool)"
+]);
+var ACP_SHARE_REGISTRY_ABI = parseAbi([
+  "struct ACP { address issuer; uint64 expiration; address recipient; uint256 revokerData; address revokerContract; uint8 scope; address[] contracts; bytes32[] handles; bytes32 sealingKey; bytes issuerSignature; bytes recipientSignature; }",
+  "function share(ACP calldata acp) external returns (bytes32)",
+  "function removeShare(bytes32 shareId) external",
+  "function sharesFor(address recipient) external view returns (ACP[] memory)",
+  "function getShare(bytes32 shareId) external view returns (ACP memory)",
+  "function isShareValid(bytes32 shareId) external view returns (bool)"
+]);
+var ACP_SHARE_TUPLE_ABI = [
+  {
+    type: "tuple",
+    components: [
+      { name: "issuer", type: "address" },
+      { name: "expiration", type: "uint64" },
+      { name: "recipient", type: "address" },
+      { name: "revokerData", type: "uint256" },
+      { name: "revokerContract", type: "address" },
+      { name: "scope", type: "uint8" },
+      { name: "contracts", type: "address[]" },
+      { name: "handles", type: "bytes32[]" },
+      { name: "sealingKey", type: "bytes32" },
+      { name: "issuerSignature", type: "bytes" },
+      { name: "recipientSignature", type: "bytes" }
+    ]
   }
+];
+var ZERO_BYTES32 = `0x${"0".repeat(64)}`;
+var toChainShare = (acp) => {
+  const pub = ACPUtils.getPublic(acp, true);
+  return {
+    ...pub,
+    expiration: BigInt(pub.expiration),
+    revokerData: BigInt(pub.revokerData),
+    sealingKey: ZERO_BYTES32,
+    recipientSignature: "0x"
+  };
+};
+var computeShareId = (acp) => {
+  const p = toChainShare(acp);
+  return keccak256(encodeAbiParameters(ACP_SHARE_TUPLE_ABI, [p]));
 };
+var shareIdOfChainShare = (share) => keccak256(encodeAbiParameters(ACP_SHARE_TUPLE_ABI, [share]));
 var ACP_STORE_DEFAULTS = {
   acps: {},
   activeACPHash: {}
@@ -1026,4 +1363,4 @@ var acpStore = {
   resetStore
 };
 
-export { ACPScope, ACPUtils, ACP_STORE_DEFAULTS, GenerateSealingKey, ImportACPOptionsValidator, ImportACPValidator, SelfACPOptionsValidator, SelfACPValidator, SharingACPOptionsValidator, SharingACPValidator, SignatureTypes, SignatureUtils, ValidationUtils, _acpStore, acpStore, addressNotZeroSchema, addressSchema, bytesNotEmptySchema, bytesSchema, clearStaleStore, contractsSchema, getACP, getACPs, getActiveACP, getActiveACPHash, getSignatureTypesAndMessage, handlesSchema, removeACP, removeActiveACPHash, resetStore, seal, setACP, setActiveACPHash, unsealWithPrivateKey, validateImportACP, validateImportACPOptions, validateSelfACP, validateSelfACPOptions, validateSharingACP, validateSharingACPOptions };
+export { ACPScope, ACPUtils, ACP_REVOKER_ABI, ACP_SHARE_REGISTRY_ABI, ACP_SHARE_TUPLE_ABI, ACP_STORE_DEFAULTS, CofheError, CofheErrorCode, GenerateSealingKey, ImportACPOptionsValidator, ImportACPValidator, SelfACPOptionsValidator, SelfACPValidator, SharingACPOptionsValidator, SharingACPValidator, SignatureTypes, SignatureUtils, ValidationUtils, _acpStore, acpStore, addressNotZeroSchema, addressSchema, bytesNotEmptySchema, bytesSchema, clearAclServedAddresses, clearStaleStore, computeShareId, contractsSchema, getACP, getACPs, getAclAddress, getAclServedAddresses, getActiveACP, getActiveACPHash, getSignatureTypesAndMessage, getTaskManagerAddress, handlesSchema, isCofheError, removeACP, removeActiveACPHash, resetStore, seal, setACP, setActiveACPHash, shareIdOfChainShare, toChainShare, unsealWithPrivateKey, validateImportACP, validateImportACPOptions, validateSelfACP, validateSelfACPOptions, validateSharingACP, validateSharingACPOptions };

package/dist/{chunk-N6IDQRRU.js → chunk-UKQAJK4N.js}

@@ -59,6 +59,28 @@ var baseSepolia = defineChain({
   environment: "TESTNET"
 });
 
+// chains/chains/ethereum.ts
+var ethereum = defineChain({
+  id: 1,
+  name: "Ethereum",
+  network: "ethereum",
+  coFheUrl: "https://cofhe.mainnet.fhenix.zone",
+  verifierUrl: "https://cofhe-vrf.mainnet.fhenix.zone",
+  thresholdNetworkUrl: "https://cofhe-tn.mainnet.fhenix.zone",
+  environment: "MAINNET"
+});
+
+// chains/chains/arbitrum.ts
+var arbitrum = defineChain({
+  id: 42161,
+  name: "Arbitrum One",
+  network: "arbitrum",
+  coFheUrl: "https://cofhe.mainnet.fhenix.zone",
+  verifierUrl: "https://cofhe-vrf.mainnet.fhenix.zone",
+  thresholdNetworkUrl: "https://cofhe-tn.mainnet.fhenix.zone",
+  environment: "MAINNET"
+});
+
 // chains/chains/hardhat.ts
 var hardhat = defineChain({
   id: 31337,
@@ -98,6 +120,8 @@ var chains = {
   sepolia,
   arbSepolia,
   baseSepolia,
+  ethereum,
+  arbitrum,
   hardhat,
   localcofhe,
   stagingCofhe
@@ -111,4 +135,4 @@ var getChainByName = (name) => {
   );
 };
 
-export { arbSepolia, baseSepolia, chains, getChainById, getChainByName, hardhat, localcofhe, sepolia, stagingCofhe };
+export { arbSepolia, arbitrum, baseSepolia, chains, ethereum, getChainById, getChainByName, hardhat, localcofhe, sepolia, stagingCofhe };