@tokenops/sdk 1.0.0

package/dist/fhe-vesting/react/index.js

@@ -0,0 +1,771 @@
+import { useMemoFactoryClient, buildQueryKey, useMemoManagerClient } from '../../chunk-ECT3NL2L.js';
+export { ClaimLockedError, NoPendingTransferError, NotPendingRecipientError, NotVestingRecipientError, TransferAlreadyPendingError, TransferExpiredError, VestingExpiredError, VestingNotFoundError, VestingNotRevocableError, VestingRevokedError, encryptUint64, encryptUint64Batch, resolveEncryptor } from '../../chunk-52TC6BF7.js';
+import '../../chunk-ZXCOJY2Z.js';
+export { scaleRatio } from '../../chunk-XSNLAS5M.js';
+import '../../chunk-FYQ2UW4T.js';
+export { DisclosureType, FeeType } from '../../chunk-72YGZEQE.js';
+import '../../chunk-JFLEEXKP.js';
+import '../../chunk-COPFW5Z4.js';
+import '../../chunk-BE2AIZ3K.js';
+import '../../chunk-Q2GP5UDC.js';
+import '../../chunk-KWFFIJYX.js';
+import { MissingClientError } from '../../chunk-IVE3QEGD.js';
+export { AccessDeniedError, AlreadyInitializedError, BatchTooLargeError, ContractRevertError, DecryptionFailedError, DeploymentAddressUnavailableError, EncryptionFailedError, FeatureDisabledError, FheHandleNotAllowedError, InsufficientBalanceError, InsufficientFeeError, InsufficientGasFundsError, InvalidArgumentError, InvalidSignatureError, MissingAccountError, MissingClientError, MissingEncryptorError, MissingPublicClientError, MissingWalletClientError, NetworkError, PausedError, ReceiptEventAmbiguousError, ReceiptEventNotFoundError, ReentrancyError, RelayerUnreachableError, SigningFailedError, TokenOpsSdkError, TransferFailedError, UnknownWriteFailureError, UnsupportedChainError, UserDecryptNotAllowedError, UserRejectedSignatureError, WalletChainMismatchError, WalletRejectedError, isTokenOpsSdkError } from '../../chunk-IVE3QEGD.js';
+import { useQuery, useMutation } from '@tanstack/react-query';
+
+function useConfidentialVestingFactoryImplementation(options = {}) {
+  const { client, chainId, resolvedAddress } = useMemoFactoryClient(options);
+  return useQuery({
+    queryKey: buildQueryKey("factory:implementation", chainId, resolvedAddress),
+    queryFn: () => client.implementation(),
+    enabled: !!client,
+    staleTime: 0
+  });
+}
+function useFactoryDefaultGasFee(options = {}) {
+  const { client, chainId, resolvedAddress } = useMemoFactoryClient(options);
+  return useQuery({
+    queryKey: buildQueryKey("factory:defaultGasFee", chainId, resolvedAddress),
+    queryFn: () => client.defaultGasFee(),
+    enabled: !!client,
+    staleTime: 0
+  });
+}
+function useFactoryDefaultTokenFee(options = {}) {
+  const { client, chainId, resolvedAddress } = useMemoFactoryClient(options);
+  return useQuery({
+    queryKey: buildQueryKey("factory:defaultTokenFee", chainId, resolvedAddress),
+    queryFn: () => client.defaultTokenFee(),
+    enabled: !!client,
+    staleTime: 0
+  });
+}
+function useFactoryDefaultFeeType(options = {}) {
+  const { client, chainId, resolvedAddress } = useMemoFactoryClient(options);
+  return useQuery({
+    queryKey: buildQueryKey("factory:defaultFeeType", chainId, resolvedAddress),
+    queryFn: () => client.defaultFeeType(),
+    enabled: !!client,
+    staleTime: 0
+  });
+}
+function useFactoryFeeCollector(options = {}) {
+  const { client, chainId, resolvedAddress } = useMemoFactoryClient(options);
+  return useQuery({
+    queryKey: buildQueryKey("factory:feeCollector", chainId, resolvedAddress),
+    queryFn: () => client.feeCollector(),
+    enabled: !!client,
+    staleTime: 0
+  });
+}
+function useFactoryCustomFee(args = {}) {
+  const { creator, ...base } = args;
+  const { client, chainId, resolvedAddress } = useMemoFactoryClient(base);
+  return useQuery({
+    queryKey: buildQueryKey("factory:getCustomFee", chainId, resolvedAddress, creator),
+    queryFn: () => client.getCustomFee(creator),
+    enabled: !!client && !!creator,
+    staleTime: 0
+  });
+}
+function useFactoryInitCodeHash(args = {}) {
+  const { token, deployer, splitEnabled, pausableEnabled, ...base } = args;
+  const { client, chainId, resolvedAddress } = useMemoFactoryClient(base);
+  return useQuery({
+    queryKey: buildQueryKey(
+      "factory:getInitCodeHash",
+      chainId,
+      resolvedAddress,
+      token,
+      deployer,
+      splitEnabled ?? null,
+      pausableEnabled ?? null
+    ),
+    queryFn: () => client.getInitCodeHash({
+      token,
+      deployer,
+      ...splitEnabled !== void 0 && { splitEnabled },
+      ...pausableEnabled !== void 0 && { pausableEnabled }
+    }),
+    enabled: !!client && !!token && !!deployer,
+    staleTime: 0
+  });
+}
+function useCreateManagerAndGetAddress(options = {}) {
+  const { client, resolutionError } = useMemoFactoryClient(options);
+  return useMutation({
+    mutationFn: async (args) => {
+      if (!client) {
+        throw resolutionError ?? new MissingClientError("useCreateManagerAndGetAddress", "factory");
+      }
+      return client.createManagerAndGetAddress(args);
+    }
+  });
+}
+function useCreateManager(options = {}) {
+  const { client, resolutionError } = useMemoFactoryClient(options);
+  return useMutation({
+    mutationFn: async (args) => {
+      if (!client) {
+        throw resolutionError ?? new MissingClientError("useCreateManager", "factory");
+      }
+      return client.createManager(args);
+    }
+  });
+}
+function useSetDefaultGasFee(options = {}) {
+  const { client, resolutionError } = useMemoFactoryClient(options);
+  return useMutation({
+    mutationFn: async ({ fee, account }) => {
+      if (!client)
+        throw resolutionError ?? new MissingClientError("useSetDefaultGasFee", "factory");
+      return client.setDefaultGasFee(fee, account);
+    }
+  });
+}
+function useSetDefaultTokenFee(options = {}) {
+  const { client, resolutionError } = useMemoFactoryClient(options);
+  return useMutation({
+    mutationFn: async ({ feeBps, account }) => {
+      if (!client)
+        throw resolutionError ?? new MissingClientError("useSetDefaultTokenFee", "factory");
+      return client.setDefaultTokenFee(feeBps, account);
+    }
+  });
+}
+function useSetDefaultFeeType(options = {}) {
+  const { client, resolutionError } = useMemoFactoryClient(options);
+  return useMutation({
+    mutationFn: async ({ feeType, account }) => {
+      if (!client)
+        throw resolutionError ?? new MissingClientError("useSetDefaultFeeType", "factory");
+      return client.setDefaultFeeType(feeType, account);
+    }
+  });
+}
+function useResetGasFee(options = {}) {
+  const { client, resolutionError } = useMemoFactoryClient(options);
+  return useMutation({
+    mutationFn: async (args) => {
+      if (!client) throw resolutionError ?? new MissingClientError("useResetGasFee", "factory");
+      return client.resetGasFee(args?.account);
+    }
+  });
+}
+function useResetTokenFee(options = {}) {
+  const { client, resolutionError } = useMemoFactoryClient(options);
+  return useMutation({
+    mutationFn: async (args) => {
+      if (!client) throw resolutionError ?? new MissingClientError("useResetTokenFee", "factory");
+      return client.resetTokenFee(args?.account);
+    }
+  });
+}
+function useSetCustomFee(options = {}) {
+  const { client, resolutionError } = useMemoFactoryClient(options);
+  return useMutation({
+    mutationFn: async ({ creator, feeType, gasFee, tokenFee, account }) => {
+      if (!client) throw resolutionError ?? new MissingClientError("useSetCustomFee", "factory");
+      return client.setCustomFee({ creator, feeType, gasFee, tokenFee }, account);
+    }
+  });
+}
+function useDisableCustomFee(options = {}) {
+  const { client, resolutionError } = useMemoFactoryClient(options);
+  return useMutation({
+    mutationFn: async ({ creator, account }) => {
+      if (!client)
+        throw resolutionError ?? new MissingClientError("useDisableCustomFee", "factory");
+      return client.disableCustomFee(creator, account);
+    }
+  });
+}
+function useSetFeeCollector(options = {}) {
+  const { client, resolutionError } = useMemoFactoryClient(options);
+  return useMutation({
+    mutationFn: async ({ newCollector, account }) => {
+      if (!client) throw resolutionError ?? new MissingClientError("useSetFeeCollector", "factory");
+      return client.setFeeCollector(newCollector, account);
+    }
+  });
+}
+function useManagerToken(options) {
+  const { client, chainId } = useMemoManagerClient(options);
+  return useQuery({
+    queryKey: buildQueryKey("manager:TOKEN_ADDRESS", chainId, options.address),
+    queryFn: () => client.token(),
+    enabled: !!client,
+    staleTime: 0
+  });
+}
+function useManagerFeeType(options) {
+  const { client, chainId } = useMemoManagerClient(options);
+  return useQuery({
+    queryKey: buildQueryKey("manager:FEE_TYPE", chainId, options.address),
+    queryFn: () => client.feeType(),
+    enabled: !!client,
+    staleTime: 0
+  });
+}
+function useManagerFee(options) {
+  const { client, chainId } = useMemoManagerClient(options);
+  return useQuery({
+    queryKey: buildQueryKey("manager:FEE", chainId, options.address),
+    queryFn: () => client.fee(),
+    enabled: !!client,
+    staleTime: 0
+  });
+}
+function useManagerFeeInfo(options) {
+  const { client, chainId } = useMemoManagerClient(options);
+  return useQuery({
+    queryKey: buildQueryKey("manager:getFeeInfo", chainId, options.address),
+    queryFn: () => client.getFeeInfo(),
+    enabled: !!client,
+    staleTime: 0
+  });
+}
+function useManagerDeploymentBlockNumber(options) {
+  const { client, chainId } = useMemoManagerClient(options);
+  return useQuery({
+    queryKey: buildQueryKey("manager:DEPLOYMENT_BLOCK_NUMBER", chainId, options.address),
+    queryFn: () => client.deploymentBlockNumber(),
+    enabled: !!client,
+    staleTime: 0
+  });
+}
+function useManagerIsSplitEnabled(options) {
+  const { client, chainId } = useMemoManagerClient(options);
+  return useQuery({
+    queryKey: buildQueryKey("manager:isSplitEnabled", chainId, options.address),
+    queryFn: () => client.isSplitEnabled(),
+    enabled: !!client,
+    staleTime: 0
+  });
+}
+function useManagerIsPausable(options) {
+  const { client, chainId } = useMemoManagerClient(options);
+  return useQuery({
+    queryKey: buildQueryKey("manager:isPausable", chainId, options.address),
+    queryFn: () => client.isPausable(),
+    enabled: !!client,
+    staleTime: 0
+  });
+}
+function useManagerPaused(options) {
+  const { client, chainId } = useMemoManagerClient(options);
+  return useQuery({
+    queryKey: buildQueryKey("manager:paused", chainId, options.address),
+    queryFn: () => client.paused(),
+    enabled: !!client,
+    staleTime: 0
+  });
+}
+function useManagerMaxBatchSize(options) {
+  const { client, chainId } = useMemoManagerClient(options);
+  return useQuery({
+    queryKey: buildQueryKey("manager:maxBatchSize", chainId, options.address),
+    queryFn: () => client.maxBatchSize(),
+    enabled: !!client,
+    staleTime: 0
+  });
+}
+function useManagerMaxRevokeBatchSize(options) {
+  const { client, chainId } = useMemoManagerClient(options);
+  return useQuery({
+    queryKey: buildQueryKey("manager:maxRevokeBatchSize", chainId, options.address),
+    queryFn: () => client.maxRevokeBatchSize(),
+    enabled: !!client,
+    staleTime: 0
+  });
+}
+function useVestingInfo(args) {
+  const { vestingId, ...base } = args;
+  const { client, chainId } = useMemoManagerClient(base);
+  return useQuery({
+    queryKey: buildQueryKey("manager:getVestingInfo", chainId, base.address, vestingId),
+    queryFn: () => client.getVestingInfo(vestingId),
+    enabled: !!client && !!vestingId,
+    staleTime: 0
+  });
+}
+function useAllRecipients(options) {
+  const { client, chainId } = useMemoManagerClient(options);
+  return useQuery({
+    queryKey: buildQueryKey("manager:getAllRecipients", chainId, options.address),
+    queryFn: () => client.getAllRecipients(),
+    enabled: !!client,
+    staleTime: 0
+  });
+}
+function useAllRecipientsLength(options) {
+  const { client, chainId } = useMemoManagerClient(options);
+  return useQuery({
+    queryKey: buildQueryKey("manager:getAllRecipientsLength", chainId, options.address),
+    queryFn: () => client.getAllRecipientsLength(),
+    enabled: !!client,
+    staleTime: 0
+  });
+}
+function useAllRecipientsSliced(args) {
+  const { start, end, ...base } = args;
+  const { client, chainId } = useMemoManagerClient(base);
+  return useQuery({
+    queryKey: buildQueryKey("manager:getAllRecipientsSliced", chainId, base.address, start, end),
+    queryFn: () => client.getAllRecipientsSliced(start, end),
+    enabled: !!client && start !== void 0 && end !== void 0,
+    staleTime: 0
+  });
+}
+function useIsRecipient(args) {
+  const { account, ...base } = args;
+  const { client, chainId } = useMemoManagerClient(base);
+  return useQuery({
+    queryKey: buildQueryKey("manager:isRecipient", chainId, base.address, account),
+    queryFn: () => client.isRecipient(account),
+    enabled: !!client && !!account,
+    staleTime: 0
+  });
+}
+function useRecipientVestings(args) {
+  const { recipient, ...base } = args;
+  const { client, chainId } = useMemoManagerClient(base);
+  return useQuery({
+    queryKey: buildQueryKey("manager:getAllRecipientVestings", chainId, base.address, recipient),
+    queryFn: () => client.getAllRecipientVestings(recipient),
+    enabled: !!client && !!recipient,
+    staleTime: 0
+  });
+}
+function useRecipientVestingsLength(args) {
+  const { recipient, ...base } = args;
+  const { client, chainId } = useMemoManagerClient(base);
+  return useQuery({
+    queryKey: buildQueryKey(
+      "manager:getAllRecipientVestingsLength",
+      chainId,
+      base.address,
+      recipient
+    ),
+    queryFn: () => client.getAllRecipientVestingsLength(recipient),
+    enabled: !!client && !!recipient,
+    staleTime: 0
+  });
+}
+function useRecipientVestingsSliced(args) {
+  const { recipient, start, end, ...base } = args;
+  const { client, chainId } = useMemoManagerClient(base);
+  return useQuery({
+    queryKey: buildQueryKey(
+      "manager:getAllRecipientVestingsSliced",
+      chainId,
+      base.address,
+      recipient,
+      start,
+      end
+    ),
+    queryFn: () => client.getAllRecipientVestingsSliced(recipient, start, end),
+    enabled: !!client && !!recipient && start !== void 0 && end !== void 0,
+    staleTime: 0
+  });
+}
+function usePendingVestingTransfer(args) {
+  const { vestingId, ...base } = args;
+  const { client, chainId } = useMemoManagerClient(base);
+  return useQuery({
+    queryKey: buildQueryKey("manager:getPendingVestingTransfer", chainId, base.address, vestingId),
+    queryFn: () => client.getPendingVestingTransfer(vestingId),
+    enabled: !!client && !!vestingId,
+    staleTime: 0
+  });
+}
+function useHasRole(args) {
+  const { role, account, ...base } = args;
+  const { client, chainId } = useMemoManagerClient(base);
+  return useQuery({
+    queryKey: buildQueryKey("manager:hasRole", chainId, base.address, role, account),
+    queryFn: () => client.hasRole(role, account),
+    enabled: !!client && !!role && !!account,
+    staleTime: 0
+  });
+}
+function useRoleConstants(options) {
+  const { client, chainId } = useMemoManagerClient(options);
+  return useQuery({
+    queryKey: buildQueryKey("manager:roleConstants", chainId, options.address),
+    queryFn: () => client.roleConstants(),
+    enabled: !!client,
+    staleTime: 0
+  });
+}
+function useGetVestedAmount(options) {
+  const { client } = useMemoManagerClient(options);
+  return useMutation({
+    mutationFn: async (args) => {
+      if (!client) throw new MissingClientError("useGetVestedAmount", "manager");
+      return client.getVestedAmount(args);
+    }
+  });
+}
+function useGetClaimableAmount(options) {
+  const { client } = useMemoManagerClient(options);
+  return useMutation({
+    mutationFn: async (args) => {
+      if (!client) throw new MissingClientError("useGetClaimableAmount", "manager");
+      return client.getClaimableAmount(args);
+    }
+  });
+}
+function useGetTotalAllocation(options) {
+  const { client } = useMemoManagerClient(options);
+  return useMutation({
+    mutationFn: async (args) => {
+      if (!client) throw new MissingClientError("useGetTotalAllocation", "manager");
+      return client.getTotalAllocation(args);
+    }
+  });
+}
+function useGetSettledAmount(options) {
+  const { client } = useMemoManagerClient(options);
+  return useMutation({
+    mutationFn: async (args) => {
+      if (!client) throw new MissingClientError("useGetSettledAmount", "manager");
+      return client.getSettledAmount(args);
+    }
+  });
+}
+function useAdminGetVestedAmount(options) {
+  const { client } = useMemoManagerClient(options);
+  return useMutation({
+    mutationFn: async (args) => {
+      if (!client) throw new MissingClientError("useAdminGetVestedAmount", "manager");
+      return client.adminGetVestedAmount(args);
+    }
+  });
+}
+function useAdminGetClaimableAmount(options) {
+  const { client } = useMemoManagerClient(options);
+  return useMutation({
+    mutationFn: async (args) => {
+      if (!client) throw new MissingClientError("useAdminGetClaimableAmount", "manager");
+      return client.adminGetClaimableAmount(args);
+    }
+  });
+}
+function useAdminGetTotalAllocation(options) {
+  const { client } = useMemoManagerClient(options);
+  return useMutation({
+    mutationFn: async (args) => {
+      if (!client) throw new MissingClientError("useAdminGetTotalAllocation", "manager");
+      return client.adminGetTotalAllocation(args);
+    }
+  });
+}
+function useAdminGetSettledAmount(options) {
+  const { client } = useMemoManagerClient(options);
+  return useMutation({
+    mutationFn: async (args) => {
+      if (!client) throw new MissingClientError("useAdminGetSettledAmount", "manager");
+      return client.adminGetSettledAmount(args);
+    }
+  });
+}
+function useAdminGetTokenBalance(options) {
+  const { client } = useMemoManagerClient(options);
+  return useMutation({
+    mutationFn: async (args) => {
+      if (!client) throw new MissingClientError("useAdminGetTokenBalance", "manager");
+      return client.adminGetTokenBalance(args);
+    }
+  });
+}
+function useCreateVesting(options) {
+  const { client } = useMemoManagerClient(options);
+  return useMutation({
+    mutationFn: async (args) => {
+      if (!client) throw new MissingClientError("useCreateVesting", "manager");
+      return client.createVesting(args);
+    }
+  });
+}
+function useBatchCreateVesting(options) {
+  const { client } = useMemoManagerClient(options);
+  return useMutation({
+    mutationFn: async (args) => {
+      if (!client) throw new MissingClientError("useBatchCreateVesting", "manager");
+      return client.batchCreateVesting(args);
+    }
+  });
+}
+function useClaim(options) {
+  const { client } = useMemoManagerClient(options);
+  return useMutation({
+    mutationFn: async (args) => {
+      if (!client) throw new MissingClientError("useClaim", "manager");
+      return client.claim(args);
+    }
+  });
+}
+function useAdminClaim(options) {
+  const { client } = useMemoManagerClient(options);
+  return useMutation({
+    mutationFn: async (args) => {
+      if (!client) throw new MissingClientError("useAdminClaim", "manager");
+      return client.adminClaim(args);
+    }
+  });
+}
+function usePartialClaim(options) {
+  const { client } = useMemoManagerClient(options);
+  return useMutation({
+    mutationFn: async (args) => {
+      if (!client) throw new MissingClientError("usePartialClaim", "manager");
+      return client.partialClaim(args);
+    }
+  });
+}
+function useAdminPartialClaim(options) {
+  const { client } = useMemoManagerClient(options);
+  return useMutation({
+    mutationFn: async (args) => {
+      if (!client) throw new MissingClientError("useAdminPartialClaim", "manager");
+      return client.adminPartialClaim(args);
+    }
+  });
+}
+function useRevokeVesting(options) {
+  const { client } = useMemoManagerClient(options);
+  return useMutation({
+    mutationFn: async ({ vestingId, account }) => {
+      if (!client) throw new MissingClientError("useRevokeVesting", "manager");
+      return client.revokeVesting(vestingId, account);
+    }
+  });
+}
+function useBatchRevokeVesting(options) {
+  const { client } = useMemoManagerClient(options);
+  return useMutation({
+    mutationFn: async ({ vestingIds, account }) => {
+      if (!client) throw new MissingClientError("useBatchRevokeVesting", "manager");
+      return client.batchRevokeVesting(vestingIds, account);
+    }
+  });
+}
+function useSplitVesting(options) {
+  const { client } = useMemoManagerClient(options);
+  return useMutation({
+    mutationFn: async (args) => {
+      if (!client) throw new MissingClientError("useSplitVesting", "manager");
+      return client.splitVesting(args);
+    }
+  });
+}
+function useInitiateVestingTransfer(options) {
+  const { client } = useMemoManagerClient(options);
+  return useMutation({
+    mutationFn: async (args) => {
+      if (!client) throw new MissingClientError("useInitiateVestingTransfer", "manager");
+      return client.initiateVestingTransfer(args);
+    }
+  });
+}
+function useAcceptVestingTransfer(options) {
+  const { client } = useMemoManagerClient(options);
+  return useMutation({
+    mutationFn: async ({ vestingId, account }) => {
+      if (!client) throw new MissingClientError("useAcceptVestingTransfer", "manager");
+      return client.acceptVestingTransfer(vestingId, account);
+    }
+  });
+}
+function useCancelVestingTransfer(options) {
+  const { client } = useMemoManagerClient(options);
+  return useMutation({
+    mutationFn: async ({ vestingId, account }) => {
+      if (!client) throw new MissingClientError("useCancelVestingTransfer", "manager");
+      return client.cancelVestingTransfer(vestingId, account);
+    }
+  });
+}
+function useDirectVestingTransfer(options) {
+  const { client } = useMemoManagerClient(options);
+  return useMutation({
+    mutationFn: async ({ vestingId, newOwner, account }) => {
+      if (!client) throw new MissingClientError("useDirectVestingTransfer", "manager");
+      return client.directVestingTransfer(vestingId, newOwner, account);
+    }
+  });
+}
+function useDiscloseToParty(options) {
+  const { client } = useMemoManagerClient(options);
+  return useMutation({
+    mutationFn: async (args) => {
+      if (!client) throw new MissingClientError("useDiscloseToParty", "manager");
+      return client.discloseToParty(args);
+    }
+  });
+}
+function useBatchDiscloseToParty(options) {
+  const { client } = useMemoManagerClient(options);
+  return useMutation({
+    mutationFn: async (args) => {
+      if (!client) throw new MissingClientError("useBatchDiscloseToParty", "manager");
+      return client.batchDiscloseToParty(args);
+    }
+  });
+}
+function useAdminDiscloseToParty(options) {
+  const { client } = useMemoManagerClient(options);
+  return useMutation({
+    mutationFn: async (args) => {
+      if (!client) throw new MissingClientError("useAdminDiscloseToParty", "manager");
+      return client.adminDiscloseToParty(args);
+    }
+  });
+}
+function useAdminBatchDiscloseToParty(options) {
+  const { client } = useMemoManagerClient(options);
+  return useMutation({
+    mutationFn: async (args) => {
+      if (!client) throw new MissingClientError("useAdminBatchDiscloseToParty", "manager");
+      return client.adminBatchDiscloseToParty(args);
+    }
+  });
+}
+function useDiscloseHandleToParty(options) {
+  const { client } = useMemoManagerClient(options);
+  return useMutation({
+    mutationFn: async ({ handle, party, account }) => {
+      if (!client) throw new MissingClientError("useDiscloseHandleToParty", "manager");
+      return client.discloseHandleToParty(handle, party, account);
+    }
+  });
+}
+function useBatchDiscloseHandlesToParty(options) {
+  const { client } = useMemoManagerClient(options);
+  return useMutation({
+    mutationFn: async ({ handles, party, account }) => {
+      if (!client) throw new MissingClientError("useBatchDiscloseHandlesToParty", "manager");
+      return client.batchDiscloseHandlesToParty(handles, party, account);
+    }
+  });
+}
+function useWithdrawAdmin(options) {
+  const { client } = useMemoManagerClient(options);
+  return useMutation({
+    mutationFn: async (args) => {
+      if (!client) throw new MissingClientError("useWithdrawAdmin", "manager");
+      return client.withdrawAdmin(args);
+    }
+  });
+}
+function useWithdrawOtherToken(options) {
+  const { client } = useMemoManagerClient(options);
+  return useMutation({
+    mutationFn: async ({ token, to, account }) => {
+      if (!client) throw new MissingClientError("useWithdrawOtherToken", "manager");
+      return client.withdrawOtherToken(token, to, account);
+    }
+  });
+}
+function useWithdrawOtherConfidentialToken(options) {
+  const { client } = useMemoManagerClient(options);
+  return useMutation({
+    mutationFn: async ({ token, to, account }) => {
+      if (!client) throw new MissingClientError("useWithdrawOtherConfidentialToken", "manager");
+      return client.withdrawOtherConfidentialToken(token, to, account);
+    }
+  });
+}
+function useWithdrawGasFee(options) {
+  const { client } = useMemoManagerClient(options);
+  return useMutation({
+    mutationFn: async ({ to, amount, account }) => {
+      if (!client) throw new MissingClientError("useWithdrawGasFee", "manager");
+      return client.withdrawGasFee(to, amount, account);
+    }
+  });
+}
+function useWithdrawTokenFee(options) {
+  const { client } = useMemoManagerClient(options);
+  return useMutation({
+    mutationFn: async (args) => {
+      if (!client) throw new MissingClientError("useWithdrawTokenFee", "manager");
+      return client.withdrawTokenFee(args);
+    }
+  });
+}
+function useSetMaxBatchSize(options) {
+  const { client } = useMemoManagerClient(options);
+  return useMutation({
+    mutationFn: async ({ newMax, account }) => {
+      if (!client) throw new MissingClientError("useSetMaxBatchSize", "manager");
+      return client.setMaxBatchSize(newMax, account);
+    }
+  });
+}
+function useSetMaxRevokeBatchSize(options) {
+  const { client } = useMemoManagerClient(options);
+  return useMutation({
+    mutationFn: async ({ newMax, account }) => {
+      if (!client) throw new MissingClientError("useSetMaxRevokeBatchSize", "manager");
+      return client.setMaxRevokeBatchSize(newMax, account);
+    }
+  });
+}
+function useTransferFeeCollectorRole(options) {
+  const { client } = useMemoManagerClient(options);
+  return useMutation({
+    mutationFn: async ({ newCollector, account }) => {
+      if (!client) throw new MissingClientError("useTransferFeeCollectorRole", "manager");
+      return client.transferFeeCollectorRole(newCollector, account);
+    }
+  });
+}
+function usePause(options) {
+  const { client } = useMemoManagerClient(options);
+  return useMutation({
+    mutationFn: async (args) => {
+      if (!client) throw new MissingClientError("usePause", "manager");
+      return client.pause(args?.account);
+    }
+  });
+}
+function useUnpause(options) {
+  const { client } = useMemoManagerClient(options);
+  return useMutation({
+    mutationFn: async (args) => {
+      if (!client) throw new MissingClientError("useUnpause", "manager");
+      return client.unpause(args?.account);
+    }
+  });
+}
+function useGrantRole(options) {
+  const { client } = useMemoManagerClient(options);
+  return useMutation({
+    mutationFn: async ({ role, accountTarget, account }) => {
+      if (!client) throw new MissingClientError("useGrantRole", "manager");
+      return client.grantRole(role, accountTarget, account);
+    }
+  });
+}
+function useRevokeRole(options) {
+  const { client } = useMemoManagerClient(options);
+  return useMutation({
+    mutationFn: async ({ role, accountTarget, account }) => {
+      if (!client) throw new MissingClientError("useRevokeRole", "manager");
+      return client.revokeRole(role, accountTarget, account);
+    }
+  });
+}
+function useRenounceRole(options) {
+  const { client } = useMemoManagerClient(options);
+  return useMutation({
+    mutationFn: async ({ role, callerConfirm, account }) => {
+      if (!client) throw new MissingClientError("useRenounceRole", "manager");
+      return client.renounceRole(role, callerConfirm, account);
+    }
+  });
+}
+
+export { useAcceptVestingTransfer, useAdminBatchDiscloseToParty, useAdminClaim, useAdminDiscloseToParty, useAdminGetClaimableAmount, useAdminGetSettledAmount, useAdminGetTokenBalance, useAdminGetTotalAllocation, useAdminGetVestedAmount, useAdminPartialClaim, useAllRecipients, useAllRecipientsLength, useAllRecipientsSliced, useBatchCreateVesting, useBatchDiscloseHandlesToParty, useBatchDiscloseToParty, useBatchRevokeVesting, useCancelVestingTransfer, useClaim, useConfidentialVestingFactoryImplementation, useCreateManager, useCreateManagerAndGetAddress, useCreateVesting, useDirectVestingTransfer, useDisableCustomFee, useDiscloseHandleToParty, useDiscloseToParty, useFactoryCustomFee, useFactoryDefaultFeeType, useFactoryDefaultGasFee, useFactoryDefaultTokenFee, useFactoryFeeCollector, useFactoryInitCodeHash, useGetClaimableAmount, useGetSettledAmount, useGetTotalAllocation, useGetVestedAmount, useGrantRole, useHasRole, useInitiateVestingTransfer, useIsRecipient, useManagerDeploymentBlockNumber, useManagerFee, useManagerFeeInfo, useManagerFeeType, useManagerIsPausable, useManagerIsSplitEnabled, useManagerMaxBatchSize, useManagerMaxRevokeBatchSize, useManagerPaused, useManagerToken, usePartialClaim, usePause, usePendingVestingTransfer, useRecipientVestings, useRecipientVestingsLength, useRecipientVestingsSliced, useRenounceRole, useResetGasFee, useResetTokenFee, useRevokeRole, useRevokeVesting, useRoleConstants, useSetCustomFee, useSetDefaultFeeType, useSetDefaultGasFee, useSetDefaultTokenFee, useSetFeeCollector, useSetMaxBatchSize, useSetMaxRevokeBatchSize, useSplitVesting, useTransferFeeCollectorRole, useUnpause, useVestingInfo, useWithdrawAdmin, useWithdrawGasFee, useWithdrawOtherConfidentialToken, useWithdrawOtherToken, useWithdrawTokenFee };