@tokenops/sdk 1.0.0

package/dist/fhe-disperse/react/index.cjs

@@ -0,0 +1,752 @@
+'use strict';
+
+var chunkHTOMTEA3_cjs = require('../../chunk-HTOMTEA3.cjs');
+require('../../chunk-ITQ7WKVC.cjs');
+require('../../chunk-FWHYQZ5E.cjs');
+require('../../chunk-NS44KBV5.cjs');
+require('../../chunk-Q7ARQSUH.cjs');
+require('../../chunk-VDXVNZCO.cjs');
+var chunkOLDGMKW2_cjs = require('../../chunk-OLDGMKW2.cjs');
+require('../../chunk-CQIPRNS7.cjs');
+require('../../chunk-VJKZWYYJ.cjs');
+require('../../chunk-66IHPTOK.cjs');
+var chunk56UI7LUR_cjs = require('../../chunk-56UI7LUR.cjs');
+var reactQuery = require('@tanstack/react-query');
+var react = require('react');
+var wagmi = require('wagmi');
+
+var FHE_DISPERSE_KEY = "tokenops-sdk";
+var FHE_DISPERSE_NAMESPACE = "fhe-disperse";
+function tryResolveSingletonAddress(override, chainId) {
+  if (override) return override;
+  if (chainId === void 0) return void 0;
+  return chunkOLDGMKW2_cjs.getFheDisperseSingletonAddress(chainId);
+}
+function useMemoDisperseClient(opts = {}) {
+  const publicClient = wagmi.usePublicClient({ chainId: opts.chainId });
+  const { data: walletClient } = wagmi.useWalletClient({ chainId: opts.chainId });
+  const chainId = opts.chainId ?? publicClient?.chain?.id;
+  const resolvedAddress = tryResolveSingletonAddress(opts.address, chainId);
+  const resolutionError = computeSingletonResolutionError(opts.address, chainId);
+  const encryptorSourceRef = react.useRef(opts.encryptor);
+  encryptorSourceRef.current = opts.encryptor;
+  const client = react.useMemo(() => {
+    if (!publicClient) return void 0;
+    if (!resolvedAddress) return void 0;
+    return chunkHTOMTEA3_cjs.createConfidentialDisperseClient({
+      publicClient,
+      ...walletClient ? { walletClient } : {},
+      address: resolvedAddress,
+      ...chainId !== void 0 ? { chainId } : {},
+      // Lazy — invoked per-encryption inside the headless client. Picks up
+      // whichever EncryptorSource the consumer last passed in.
+      encryptor: () => chunkHTOMTEA3_cjs.resolveEncryptor(encryptorSourceRef.current),
+      ...opts.aclAddress ? { aclAddress: opts.aclAddress } : {}
+    });
+  }, [publicClient, walletClient, resolvedAddress, chainId, opts.aclAddress]);
+  return {
+    client,
+    resolutionError,
+    publicClient,
+    walletClient: walletClient ?? void 0,
+    chainId,
+    resolvedAddress
+  };
+}
+function computeSingletonResolutionError(override, chainId) {
+  if (override) return void 0;
+  if (chainId === void 0) {
+    return new chunk56UI7LUR_cjs.DeploymentAddressUnavailableError({
+      reason: "chain-id-missing",
+      product: "fheDisperse",
+      contract: "disperseConfidentialSingleton",
+      clientLabel: "ConfidentialDisperseClient"
+    });
+  }
+  const resolved = chunkOLDGMKW2_cjs.getFheDisperseSingletonAddress(chainId);
+  if (!resolved) {
+    return new chunk56UI7LUR_cjs.DeploymentAddressUnavailableError({
+      reason: "registry-not-deployed",
+      product: "fheDisperse",
+      contract: "disperseConfidentialSingleton",
+      chainId,
+      clientLabel: "ConfidentialDisperseClient"
+    });
+  }
+  return void 0;
+}
+function buildQueryKey(method, chainId, address, ...args) {
+  return [
+    FHE_DISPERSE_KEY,
+    FHE_DISPERSE_NAMESPACE,
+    method,
+    chainId ?? null,
+    address ? address.toLowerCase() : null,
+    ...args.map(normalizeKeyArg)
+  ];
+}
+function normalizeKeyArg(value) {
+  if (typeof value === "bigint") return value.toString();
+  if (Array.isArray(value)) return value.map(normalizeKeyArg);
+  if (value && typeof value === "object") {
+    return Object.fromEntries(
+      Object.entries(value).map(([k, v]) => [k, normalizeKeyArg(v)])
+    );
+  }
+  if (typeof value === "string" && value.startsWith("0x")) return value.toLowerCase();
+  return value;
+}
+
+// src/fhe-disperse/react/useIsRegistered.ts
+function useIsRegistered(args = {}) {
+  const { user, ...base } = args;
+  const { client, chainId, resolvedAddress } = useMemoDisperseClient(base);
+  return reactQuery.useQuery({
+    queryKey: buildQueryKey("disperse:isRegistered", chainId, resolvedAddress, user),
+    queryFn: () => client.isRegistered(user),
+    enabled: !!client && !!user,
+    staleTime: 0
+  });
+}
+function useGetWallets(args = {}) {
+  const { user, ...base } = args;
+  const { client, chainId, resolvedAddress } = useMemoDisperseClient(base);
+  return reactQuery.useQuery({
+    queryKey: buildQueryKey("disperse:getWallets", chainId, resolvedAddress, user),
+    queryFn: () => client.getWallets(user),
+    enabled: !!client && !!user,
+    staleTime: 0
+  });
+}
+function usePredictWallets(args = {}) {
+  const { user, ...base } = args;
+  const { client, chainId, resolvedAddress } = useMemoDisperseClient(base);
+  return reactQuery.useQuery({
+    queryKey: buildQueryKey("disperse:predictWallets", chainId, resolvedAddress, user),
+    queryFn: () => client.predictWallets(user),
+    enabled: !!client && !!user,
+    staleTime: 0
+  });
+}
+function useGetFees(args = {}) {
+  const { user, ...base } = args;
+  const { client, chainId, resolvedAddress } = useMemoDisperseClient(base);
+  return reactQuery.useQuery({
+    queryKey: buildQueryKey("disperse:getFees", chainId, resolvedAddress, user),
+    queryFn: () => client.getFees(user),
+    enabled: !!client && !!user,
+    staleTime: 0
+  });
+}
+function useGetFeeConfig(options = {}) {
+  const { client, chainId, resolvedAddress } = useMemoDisperseClient(options);
+  return reactQuery.useQuery({
+    queryKey: buildQueryKey("disperse:getFeeConfig", chainId, resolvedAddress),
+    queryFn: () => client.getFeeConfig(),
+    enabled: !!client,
+    staleTime: 0
+  });
+}
+function useGetBatchLimits(options = {}) {
+  const { client, chainId, resolvedAddress } = useMemoDisperseClient(options);
+  return reactQuery.useQuery({
+    queryKey: buildQueryKey("disperse:getBatchLimits", chainId, resolvedAddress),
+    queryFn: () => client.getBatchLimits(),
+    enabled: !!client,
+    staleTime: 0
+  });
+}
+function useCalculateFee(args = {}) {
+  const { user, mode, recipients, totalTokens, ...base } = args;
+  const { client, chainId, resolvedAddress } = useMemoDisperseClient(base);
+  return reactQuery.useQuery({
+    queryKey: buildQueryKey(
+      "disperse:calculateFee",
+      chainId,
+      resolvedAddress,
+      user,
+      mode,
+      recipients,
+      totalTokens
+    ),
+    queryFn: () => {
+      const callArgs = {
+        user,
+        mode,
+        recipients,
+        ...totalTokens !== void 0 ? { totalTokens } : {}
+      };
+      return client.calculateFee(callArgs);
+    },
+    enabled: !!client && !!user && !!mode && recipients !== void 0,
+    staleTime: 0
+  });
+}
+function useHasApprovedSubwallets(args = {}) {
+  const { user, token, ...base } = args;
+  const { client, chainId, resolvedAddress } = useMemoDisperseClient(base);
+  return reactQuery.useQuery({
+    queryKey: buildQueryKey(
+      "disperse:hasApprovedSubwallets",
+      chainId,
+      resolvedAddress,
+      user,
+      token
+    ),
+    queryFn: () => client.hasApprovedSubwallets({ user, token }),
+    enabled: !!client && !!user && !!token,
+    staleTime: 0
+  });
+}
+function useHasRole(args = {}) {
+  const { role, account, ...base } = args;
+  const { client, chainId, resolvedAddress } = useMemoDisperseClient(base);
+  return reactQuery.useQuery({
+    queryKey: buildQueryKey("disperse:hasRole", chainId, resolvedAddress, role, account),
+    queryFn: () => client.hasRole(role, account),
+    enabled: !!client && !!role && !!account,
+    staleTime: 0
+  });
+}
+function useIsPaused(options = {}) {
+  const { client, chainId, resolvedAddress } = useMemoDisperseClient(options);
+  return reactQuery.useQuery({
+    queryKey: buildQueryKey("disperse:paused", chainId, resolvedAddress),
+    queryFn: () => client.paused(),
+    enabled: !!client,
+    staleTime: 0
+  });
+}
+function useDeploymentBlockNumber(options = {}) {
+  const { client, chainId, resolvedAddress } = useMemoDisperseClient(options);
+  return reactQuery.useQuery({
+    queryKey: buildQueryKey("disperse:deploymentBlockNumber", chainId, resolvedAddress),
+    queryFn: () => client.deploymentBlockNumber(),
+    enabled: !!client,
+    staleTime: 0
+  });
+}
+function useWalletImplementation(options = {}) {
+  const { client, chainId, resolvedAddress } = useMemoDisperseClient(options);
+  return reactQuery.useQuery({
+    queryKey: buildQueryKey("disperse:walletImplementation", chainId, resolvedAddress),
+    queryFn: () => client.walletImplementation(),
+    enabled: !!client,
+    staleTime: 0
+  });
+}
+function usePreflightDisperse(args = {}) {
+  const { user, token, recipients, amounts, mode, ...base } = args;
+  const { client, chainId, resolvedAddress } = useMemoDisperseClient(base);
+  return reactQuery.useQuery({
+    queryKey: buildQueryKey(
+      "disperse:preflightDisperse",
+      chainId,
+      resolvedAddress,
+      user,
+      token,
+      recipients,
+      amounts,
+      mode
+    ),
+    queryFn: () => client.preflightDisperse({
+      user,
+      token,
+      recipients,
+      amounts,
+      mode
+    }),
+    // Empty arrays must surface as headless `EmptyRecipientsError` / `EmptyAmountsError`
+    // blockers, so the gate enables once each input is *defined* (even if empty).
+    // The SDK explains the invalid state; the UI shouldn't sit in an idle query.
+    enabled: !!client && !!user && !!token && !!mode && !!recipients && !!amounts,
+    staleTime: 0
+  });
+}
+function useRegister(options = {}) {
+  const { client, resolutionError } = useMemoDisperseClient(options);
+  return reactQuery.useMutation({
+    mutationFn: async (args) => {
+      if (!client) {
+        throw resolutionError ?? new chunk56UI7LUR_cjs.MissingClientError("useRegister", "disperse");
+      }
+      return client.register(args);
+    }
+  });
+}
+function useApproveTokenOnWallets(options = {}) {
+  const { client, resolutionError } = useMemoDisperseClient(options);
+  return reactQuery.useMutation({
+    mutationFn: async (args) => {
+      if (!client) {
+        throw resolutionError ?? new chunk56UI7LUR_cjs.MissingClientError("useApproveTokenOnWallets", "disperse");
+      }
+      return client.approveTokenOnWallets(args);
+    }
+  });
+}
+function useRevokeTokenOnWallets(options = {}) {
+  const { client, resolutionError } = useMemoDisperseClient(options);
+  return reactQuery.useMutation({
+    mutationFn: async (args) => {
+      if (!client) {
+        throw resolutionError ?? new chunk56UI7LUR_cjs.MissingClientError("useRevokeTokenOnWallets", "disperse");
+      }
+      return client.revokeTokenOnWallets(args);
+    }
+  });
+}
+function useRecoverFromWallets(options = {}) {
+  const { client, resolutionError } = useMemoDisperseClient(options);
+  return reactQuery.useMutation({
+    mutationFn: async (args) => {
+      if (!client) {
+        throw resolutionError ?? new chunk56UI7LUR_cjs.MissingClientError("useRecoverFromWallets", "disperse");
+      }
+      return client.recoverFromWallets(args);
+    }
+  });
+}
+function useRecoverERC20FromWallets(options = {}) {
+  const { client, resolutionError } = useMemoDisperseClient(options);
+  return reactQuery.useMutation({
+    mutationFn: async (args) => {
+      if (!client) {
+        throw resolutionError ?? new chunk56UI7LUR_cjs.MissingClientError("useRecoverERC20FromWallets", "disperse");
+      }
+      return client.recoverERC20FromWallets(args);
+    }
+  });
+}
+function useDisperse(options = {}) {
+  const { client, resolutionError } = useMemoDisperseClient(options);
+  return reactQuery.useMutation({
+    mutationFn: async (args) => {
+      if (!client) {
+        throw resolutionError ?? new chunk56UI7LUR_cjs.MissingClientError("useDisperse", "disperse");
+      }
+      return client.disperse(args);
+    }
+  });
+}
+function useAccessEncryptedFeeReserve(options = {}) {
+  const { client, resolutionError } = useMemoDisperseClient(options);
+  return reactQuery.useMutation({
+    mutationFn: async (args) => {
+      if (!client) {
+        throw resolutionError ?? new chunk56UI7LUR_cjs.MissingClientError("useAccessEncryptedFeeReserve", "disperse");
+      }
+      return client.getEncryptedFeeReserve(args);
+    }
+  });
+}
+var useGetEncryptedFeeReserve = useAccessEncryptedFeeReserve;
+function useDiscloseHandleToParty(options = {}) {
+  const { client, resolutionError } = useMemoDisperseClient(options);
+  return reactQuery.useMutation({
+    mutationFn: async (args) => {
+      if (!client) {
+        throw resolutionError ?? new chunk56UI7LUR_cjs.MissingClientError("useDiscloseHandleToParty", "disperse");
+      }
+      return client.discloseHandleToParty(args);
+    }
+  });
+}
+function useBatchDiscloseHandlesToParty(options = {}) {
+  const { client, resolutionError } = useMemoDisperseClient(options);
+  return reactQuery.useMutation({
+    mutationFn: async (args) => {
+      if (!client) {
+        throw resolutionError ?? new chunk56UI7LUR_cjs.MissingClientError("useBatchDiscloseHandlesToParty", "disperse");
+      }
+      return client.batchDiscloseHandlesToParty(args);
+    }
+  });
+}
+function usePause(options = {}) {
+  const { client, resolutionError } = useMemoDisperseClient(options);
+  return reactQuery.useMutation({
+    mutationFn: async ({ account }) => {
+      if (!client) throw resolutionError ?? new chunk56UI7LUR_cjs.MissingClientError("usePause", "disperse");
+      return client.pause(account);
+    }
+  });
+}
+function useUnpause(options = {}) {
+  const { client, resolutionError } = useMemoDisperseClient(options);
+  return reactQuery.useMutation({
+    mutationFn: async ({ account }) => {
+      if (!client) throw resolutionError ?? new chunk56UI7LUR_cjs.MissingClientError("useUnpause", "disperse");
+      return client.unpause(account);
+    }
+  });
+}
+function useSetFeeConfig(options = {}) {
+  const { client, resolutionError } = useMemoDisperseClient(options);
+  return reactQuery.useMutation({
+    mutationFn: async ({ config, account }) => {
+      if (!client) throw resolutionError ?? new chunk56UI7LUR_cjs.MissingClientError("useSetFeeConfig", "disperse");
+      return client.setFeeConfig(config, account);
+    }
+  });
+}
+function useSetCustomFee(options = {}) {
+  const { client, resolutionError } = useMemoDisperseClient(options);
+  return reactQuery.useMutation({
+    mutationFn: async ({ user, gasFee, tokenFee, account }) => {
+      if (!client) throw resolutionError ?? new chunk56UI7LUR_cjs.MissingClientError("useSetCustomFee", "disperse");
+      return client.setCustomFee(user, gasFee, tokenFee, account);
+    }
+  });
+}
+function useDisableCustomFee(options = {}) {
+  const { client, resolutionError } = useMemoDisperseClient(options);
+  return reactQuery.useMutation({
+    mutationFn: async ({ user, account }) => {
+      if (!client) {
+        throw resolutionError ?? new chunk56UI7LUR_cjs.MissingClientError("useDisableCustomFee", "disperse");
+      }
+      return client.disableCustomFee(user, account);
+    }
+  });
+}
+function useSetMaxBatchSizeHolding(options = {}) {
+  const { client, resolutionError } = useMemoDisperseClient(options);
+  return reactQuery.useMutation({
+    mutationFn: async ({ size, account }) => {
+      if (!client) {
+        throw resolutionError ?? new chunk56UI7LUR_cjs.MissingClientError("useSetMaxBatchSizeHolding", "disperse");
+      }
+      return client.setMaxBatchSizeHolding(size, account);
+    }
+  });
+}
+function useSetMaxBatchSizeDirect(options = {}) {
+  const { client, resolutionError } = useMemoDisperseClient(options);
+  return reactQuery.useMutation({
+    mutationFn: async ({ size, account }) => {
+      if (!client) {
+        throw resolutionError ?? new chunk56UI7LUR_cjs.MissingClientError("useSetMaxBatchSizeDirect", "disperse");
+      }
+      return client.setMaxBatchSizeDirect(size, account);
+    }
+  });
+}
+function useSetMaxBatchSizeTokenFee(options = {}) {
+  const { client, resolutionError } = useMemoDisperseClient(options);
+  return reactQuery.useMutation({
+    mutationFn: async ({ size, account }) => {
+      if (!client) {
+        throw resolutionError ?? new chunk56UI7LUR_cjs.MissingClientError("useSetMaxBatchSizeTokenFee", "disperse");
+      }
+      return client.setMaxBatchSizeTokenFee(size, account);
+    }
+  });
+}
+function useWithdrawGasFee(options = {}) {
+  const { client, resolutionError } = useMemoDisperseClient(options);
+  return reactQuery.useMutation({
+    mutationFn: async ({ to, amount, account }) => {
+      if (!client) throw resolutionError ?? new chunk56UI7LUR_cjs.MissingClientError("useWithdrawGasFee", "disperse");
+      return client.withdrawGasFee(to, amount, account);
+    }
+  });
+}
+function useWithdrawTokenFee(options = {}) {
+  const { client, resolutionError } = useMemoDisperseClient(options);
+  return reactQuery.useMutation({
+    mutationFn: async (args) => {
+      if (!client) {
+        throw resolutionError ?? new chunk56UI7LUR_cjs.MissingClientError("useWithdrawTokenFee", "disperse");
+      }
+      if (args.encryptedInput !== void 0) {
+        const { token: token2, to: to2, encryptedInput, account: account2 } = args;
+        return client.withdrawTokenFee({
+          token: token2,
+          to: to2,
+          encryptedInput,
+          ...account2 !== void 0 ? { account: account2 } : {}
+        });
+      }
+      const { token, to, amount, encryptor: encryptorSource, account } = args;
+      const eager = encryptorSource ? chunkHTOMTEA3_cjs.resolveEncryptor(encryptorSource) : void 0;
+      return client.withdrawTokenFee({
+        token,
+        to,
+        amount,
+        ...eager ? { encryptor: eager } : {},
+        ...account !== void 0 ? { account } : {}
+      });
+    }
+  });
+}
+function useRescueConfidentialTokens(options = {}) {
+  const { client, resolutionError } = useMemoDisperseClient(options);
+  return reactQuery.useMutation({
+    mutationFn: async ({ token, to, account }) => {
+      if (!client) {
+        throw resolutionError ?? new chunk56UI7LUR_cjs.MissingClientError("useRescueConfidentialTokens", "disperse");
+      }
+      return client.rescueConfidentialTokens(token, to, account);
+    }
+  });
+}
+function useRescueERC20(options = {}) {
+  const { client, resolutionError } = useMemoDisperseClient(options);
+  return reactQuery.useMutation({
+    mutationFn: async ({ token, to, account }) => {
+      if (!client) throw resolutionError ?? new chunk56UI7LUR_cjs.MissingClientError("useRescueERC20", "disperse");
+      return client.rescueERC20(token, to, account);
+    }
+  });
+}
+function useGrantRole(options = {}) {
+  const { client, resolutionError } = useMemoDisperseClient(options);
+  return reactQuery.useMutation({
+    mutationFn: async ({ role, accountTarget, account }) => {
+      if (!client) throw resolutionError ?? new chunk56UI7LUR_cjs.MissingClientError("useGrantRole", "disperse");
+      return client.grantRole(role, accountTarget, account);
+    }
+  });
+}
+function useRevokeRole(options = {}) {
+  const { client, resolutionError } = useMemoDisperseClient(options);
+  return reactQuery.useMutation({
+    mutationFn: async ({ role, accountTarget, account }) => {
+      if (!client) throw resolutionError ?? new chunk56UI7LUR_cjs.MissingClientError("useRevokeRole", "disperse");
+      return client.revokeRole(role, accountTarget, account);
+    }
+  });
+}
+
+Object.defineProperty(exports, "AlreadyRegisteredError", {
+  enumerable: true,
+  get: function () { return chunkHTOMTEA3_cjs.AlreadyRegisteredError; }
+});
+Object.defineProperty(exports, "DEFAULT_ADMIN_ROLE", {
+  enumerable: true,
+  get: function () { return chunkHTOMTEA3_cjs.DEFAULT_ADMIN_ROLE; }
+});
+Object.defineProperty(exports, "DisperseEncryptedReserveNotGrantedError", {
+  enumerable: true,
+  get: function () { return chunkHTOMTEA3_cjs.DisperseEncryptedReserveNotGrantedError; }
+});
+Object.defineProperty(exports, "DisperseSubwalletNotFoundError", {
+  enumerable: true,
+  get: function () { return chunkHTOMTEA3_cjs.DisperseSubwalletNotFoundError; }
+});
+Object.defineProperty(exports, "FEE_COLLECTOR_ROLE", {
+  enumerable: true,
+  get: function () { return chunkHTOMTEA3_cjs.FEE_COLLECTOR_ROLE; }
+});
+Object.defineProperty(exports, "FEE_MANAGER_ROLE", {
+  enumerable: true,
+  get: function () { return chunkHTOMTEA3_cjs.FEE_MANAGER_ROLE; }
+});
+Object.defineProperty(exports, "NotRegisteredError", {
+  enumerable: true,
+  get: function () { return chunkHTOMTEA3_cjs.NotRegisteredError; }
+});
+Object.defineProperty(exports, "PAUSER_ROLE", {
+  enumerable: true,
+  get: function () { return chunkHTOMTEA3_cjs.PAUSER_ROLE; }
+});
+Object.defineProperty(exports, "WITHDRAWER_ROLE", {
+  enumerable: true,
+  get: function () { return chunkHTOMTEA3_cjs.WITHDRAWER_ROLE; }
+});
+Object.defineProperty(exports, "computeSubtotals", {
+  enumerable: true,
+  get: function () { return chunkHTOMTEA3_cjs.computeSubtotals; }
+});
+Object.defineProperty(exports, "encryptUint64", {
+  enumerable: true,
+  get: function () { return chunkHTOMTEA3_cjs.encryptUint64; }
+});
+Object.defineProperty(exports, "encryptUint64Batch", {
+  enumerable: true,
+  get: function () { return chunkHTOMTEA3_cjs.encryptUint64Batch; }
+});
+Object.defineProperty(exports, "resolveEncryptor", {
+  enumerable: true,
+  get: function () { return chunkHTOMTEA3_cjs.resolveEncryptor; }
+});
+Object.defineProperty(exports, "AccessDeniedError", {
+  enumerable: true,
+  get: function () { return chunk56UI7LUR_cjs.AccessDeniedError; }
+});
+Object.defineProperty(exports, "AlreadyInitializedError", {
+  enumerable: true,
+  get: function () { return chunk56UI7LUR_cjs.AlreadyInitializedError; }
+});
+Object.defineProperty(exports, "BatchTooLargeError", {
+  enumerable: true,
+  get: function () { return chunk56UI7LUR_cjs.BatchTooLargeError; }
+});
+Object.defineProperty(exports, "ContractRevertError", {
+  enumerable: true,
+  get: function () { return chunk56UI7LUR_cjs.ContractRevertError; }
+});
+Object.defineProperty(exports, "DecryptionFailedError", {
+  enumerable: true,
+  get: function () { return chunk56UI7LUR_cjs.DecryptionFailedError; }
+});
+Object.defineProperty(exports, "DeploymentAddressUnavailableError", {
+  enumerable: true,
+  get: function () { return chunk56UI7LUR_cjs.DeploymentAddressUnavailableError; }
+});
+Object.defineProperty(exports, "EncryptionFailedError", {
+  enumerable: true,
+  get: function () { return chunk56UI7LUR_cjs.EncryptionFailedError; }
+});
+Object.defineProperty(exports, "FeatureDisabledError", {
+  enumerable: true,
+  get: function () { return chunk56UI7LUR_cjs.FeatureDisabledError; }
+});
+Object.defineProperty(exports, "FheHandleNotAllowedError", {
+  enumerable: true,
+  get: function () { return chunk56UI7LUR_cjs.FheHandleNotAllowedError; }
+});
+Object.defineProperty(exports, "InsufficientBalanceError", {
+  enumerable: true,
+  get: function () { return chunk56UI7LUR_cjs.InsufficientBalanceError; }
+});
+Object.defineProperty(exports, "InsufficientFeeError", {
+  enumerable: true,
+  get: function () { return chunk56UI7LUR_cjs.InsufficientFeeError; }
+});
+Object.defineProperty(exports, "InsufficientGasFundsError", {
+  enumerable: true,
+  get: function () { return chunk56UI7LUR_cjs.InsufficientGasFundsError; }
+});
+Object.defineProperty(exports, "InvalidArgumentError", {
+  enumerable: true,
+  get: function () { return chunk56UI7LUR_cjs.InvalidArgumentError; }
+});
+Object.defineProperty(exports, "InvalidSignatureError", {
+  enumerable: true,
+  get: function () { return chunk56UI7LUR_cjs.InvalidSignatureError; }
+});
+Object.defineProperty(exports, "MissingAccountError", {
+  enumerable: true,
+  get: function () { return chunk56UI7LUR_cjs.MissingAccountError; }
+});
+Object.defineProperty(exports, "MissingClientError", {
+  enumerable: true,
+  get: function () { return chunk56UI7LUR_cjs.MissingClientError; }
+});
+Object.defineProperty(exports, "MissingEncryptorError", {
+  enumerable: true,
+  get: function () { return chunk56UI7LUR_cjs.MissingEncryptorError; }
+});
+Object.defineProperty(exports, "MissingPublicClientError", {
+  enumerable: true,
+  get: function () { return chunk56UI7LUR_cjs.MissingPublicClientError; }
+});
+Object.defineProperty(exports, "MissingWalletClientError", {
+  enumerable: true,
+  get: function () { return chunk56UI7LUR_cjs.MissingWalletClientError; }
+});
+Object.defineProperty(exports, "NetworkError", {
+  enumerable: true,
+  get: function () { return chunk56UI7LUR_cjs.NetworkError; }
+});
+Object.defineProperty(exports, "PausedError", {
+  enumerable: true,
+  get: function () { return chunk56UI7LUR_cjs.PausedError; }
+});
+Object.defineProperty(exports, "ReceiptEventAmbiguousError", {
+  enumerable: true,
+  get: function () { return chunk56UI7LUR_cjs.ReceiptEventAmbiguousError; }
+});
+Object.defineProperty(exports, "ReceiptEventNotFoundError", {
+  enumerable: true,
+  get: function () { return chunk56UI7LUR_cjs.ReceiptEventNotFoundError; }
+});
+Object.defineProperty(exports, "ReentrancyError", {
+  enumerable: true,
+  get: function () { return chunk56UI7LUR_cjs.ReentrancyError; }
+});
+Object.defineProperty(exports, "RelayerUnreachableError", {
+  enumerable: true,
+  get: function () { return chunk56UI7LUR_cjs.RelayerUnreachableError; }
+});
+Object.defineProperty(exports, "SigningFailedError", {
+  enumerable: true,
+  get: function () { return chunk56UI7LUR_cjs.SigningFailedError; }
+});
+Object.defineProperty(exports, "TokenOpsSdkError", {
+  enumerable: true,
+  get: function () { return chunk56UI7LUR_cjs.TokenOpsSdkError; }
+});
+Object.defineProperty(exports, "TransferFailedError", {
+  enumerable: true,
+  get: function () { return chunk56UI7LUR_cjs.TransferFailedError; }
+});
+Object.defineProperty(exports, "UnknownWriteFailureError", {
+  enumerable: true,
+  get: function () { return chunk56UI7LUR_cjs.UnknownWriteFailureError; }
+});
+Object.defineProperty(exports, "UnsupportedChainError", {
+  enumerable: true,
+  get: function () { return chunk56UI7LUR_cjs.UnsupportedChainError; }
+});
+Object.defineProperty(exports, "UserDecryptNotAllowedError", {
+  enumerable: true,
+  get: function () { return chunk56UI7LUR_cjs.UserDecryptNotAllowedError; }
+});
+Object.defineProperty(exports, "UserRejectedSignatureError", {
+  enumerable: true,
+  get: function () { return chunk56UI7LUR_cjs.UserRejectedSignatureError; }
+});
+Object.defineProperty(exports, "WalletChainMismatchError", {
+  enumerable: true,
+  get: function () { return chunk56UI7LUR_cjs.WalletChainMismatchError; }
+});
+Object.defineProperty(exports, "WalletRejectedError", {
+  enumerable: true,
+  get: function () { return chunk56UI7LUR_cjs.WalletRejectedError; }
+});
+Object.defineProperty(exports, "isTokenOpsSdkError", {
+  enumerable: true,
+  get: function () { return chunk56UI7LUR_cjs.isTokenOpsSdkError; }
+});
+exports.FHE_DISPERSE_KEY = FHE_DISPERSE_KEY;
+exports.FHE_DISPERSE_NAMESPACE = FHE_DISPERSE_NAMESPACE;
+exports.useAccessEncryptedFeeReserve = useAccessEncryptedFeeReserve;
+exports.useApproveTokenOnWallets = useApproveTokenOnWallets;
+exports.useBatchDiscloseHandlesToParty = useBatchDiscloseHandlesToParty;
+exports.useCalculateFee = useCalculateFee;
+exports.useDeploymentBlockNumber = useDeploymentBlockNumber;
+exports.useDisableCustomFee = useDisableCustomFee;
+exports.useDiscloseHandleToParty = useDiscloseHandleToParty;
+exports.useDisperse = useDisperse;
+exports.useGetBatchLimits = useGetBatchLimits;
+exports.useGetEncryptedFeeReserve = useGetEncryptedFeeReserve;
+exports.useGetFeeConfig = useGetFeeConfig;
+exports.useGetFees = useGetFees;
+exports.useGetWallets = useGetWallets;
+exports.useGrantRole = useGrantRole;
+exports.useHasApprovedSubwallets = useHasApprovedSubwallets;
+exports.useHasRole = useHasRole;
+exports.useIsPaused = useIsPaused;
+exports.useIsRegistered = useIsRegistered;
+exports.usePause = usePause;
+exports.usePredictWallets = usePredictWallets;
+exports.usePreflightDisperse = usePreflightDisperse;
+exports.useRecoverERC20FromWallets = useRecoverERC20FromWallets;
+exports.useRecoverFromWallets = useRecoverFromWallets;
+exports.useRegister = useRegister;
+exports.useRescueConfidentialTokens = useRescueConfidentialTokens;
+exports.useRescueERC20 = useRescueERC20;
+exports.useRevokeRole = useRevokeRole;
+exports.useRevokeTokenOnWallets = useRevokeTokenOnWallets;
+exports.useSetCustomFee = useSetCustomFee;
+exports.useSetFeeConfig = useSetFeeConfig;
+exports.useSetMaxBatchSizeDirect = useSetMaxBatchSizeDirect;
+exports.useSetMaxBatchSizeHolding = useSetMaxBatchSizeHolding;
+exports.useSetMaxBatchSizeTokenFee = useSetMaxBatchSizeTokenFee;
+exports.useUnpause = useUnpause;
+exports.useWalletImplementation = useWalletImplementation;
+exports.useWithdrawGasFee = useWithdrawGasFee;
+exports.useWithdrawTokenFee = useWithdrawTokenFee;