@sudobility/contracts 1.11.2 → 1.13.0

package/dist/unified-esm/src/react/hooks/useMailerMutations.js

@@ -1,400 +1,392 @@
 import { useMutation, useQueryClient } from '@tanstack/react-query';
-import { useMailerClient } from '../context/MailerProvider.js';
 import { mailerQueryKeys } from './useMailerQueries.js';
 /**
- * Hook to send a message
+ * Hook for message-related operations
  *
  * @example
  * ```tsx
- * function SendMessageForm() {
- *   const sendMessage = useSendMessage();
+ * function MessageSender() {
+ *   const client = useMailerClient(); // Get client from context or create it
+ *   const { sendMessage, sendPrepared } = useMessaging(client, wallet, chainInfo);
  *
  *   const handleSend = () => {
  *     sendMessage.mutate({
  *       subject: 'Hello',
  *       body: 'World!',
- *       priority: true,
- *       resolveSenderToName: false
+ *       priority: true
  *     });
  *   };
  *
  *   return (
  *     <button onClick={handleSend} disabled={sendMessage.isPending}>
- *       {sendMessage.isPending ? 'Sending...' : 'Send Message'}
+ *       Send Message
  *     </button>
  *   );
  * }
  * ```
  */
-export function useSendMessage(options) {
-    const client = useMailerClient();
+export function useMessaging(client, connectedWallet, chainInfo, options) {
     const queryClient = useQueryClient();
-    return useMutation({
-        mutationFn: async ({ subject, body, priority = false, resolveSenderToName = false }) => client.sendMessage(subject, body, priority, resolveSenderToName),
+    const sendMessage = useMutation({
+        mutationFn: async ({ subject, body, priority = false, resolveSenderToName = false }) => client.sendMessage(connectedWallet, chainInfo, subject, body, { priority, resolveSenderToName }),
         onSuccess: () => {
-            // Invalidate claimable amounts as sending affects balances
             queryClient.invalidateQueries({ queryKey: mailerQueryKeys.claimableAmount() });
             queryClient.invalidateQueries({ queryKey: mailerQueryKeys.ownerClaimable() });
         },
-        ...options,
+        ...options?.sendMessage,
     });
-}
-/**
- * Hook to send a prepared message
- *
- * @example
- * ```tsx
- * function SendPreparedButton() {
- *   const sendPrepared = useSendPrepared();
- *
- *   return (
- *     <button
- *       onClick={() => sendPrepared.mutate({
- *         to: '0x123...',
- *         mailId: 'template-001',
- *         priority: true
- *       })}
- *       disabled={sendPrepared.isPending}
- *     >
- *       Send Prepared
- *     </button>
- *   );
- * }
- * ```
- */
-export function useSendPrepared(options) {
-    const client = useMailerClient();
-    const queryClient = useQueryClient();
-    return useMutation({
-        mutationFn: async ({ to, mailId, priority = false, resolveSenderToName = false }) => client.sendPrepared(to, mailId, priority, resolveSenderToName),
+    const sendPrepared = useMutation({
+        mutationFn: async ({ to, mailId, priority = false, resolveSenderToName = false }) => client.sendPrepared(connectedWallet, chainInfo, to, mailId, { priority, resolveSenderToName }),
         onSuccess: () => {
             queryClient.invalidateQueries({ queryKey: mailerQueryKeys.claimableAmount() });
             queryClient.invalidateQueries({ queryKey: mailerQueryKeys.ownerClaimable() });
         },
-        ...options,
+        ...options?.sendPrepared,
     });
+    return {
+        sendMessage,
+        sendPrepared,
+    };
 }
 /**
- * Hook to send message to email address
+ * Hook for claim-related operations
  *
  * @example
  * ```tsx
- * function SendToEmailForm() {
- *   const sendToEmail = useSendToEmail();
+ * function ClaimPanel() {
+ *   const { claimRevenue, claimOwnerShare, claimExpiredShares } = useClaims(client, wallet, chainInfo);
  *
  *   return (
- *     <button
- *       onClick={() => sendToEmail.mutate({
- *         toEmail: 'user@example.com',
- *         subject: 'Hello',
- *         body: 'Welcome!'
- *       })}
- *     >
- *       Send to Email
- *     </button>
+ *     <div>
+ *       <button onClick={() => claimRevenue.mutate()}>
+ *         Claim Revenue
+ *       </button>
+ *       <button onClick={() => claimOwnerShare.mutate()}>
+ *         Claim Owner Share
+ *       </button>
+ *     </div>
  *   );
  * }
  * ```
  */
-export function useSendToEmail(options) {
-    const client = useMailerClient();
-    const queryClient = useQueryClient();
-    return useMutation({
-        mutationFn: async ({ toEmail, subject, body }) => client.sendToEmail(toEmail, subject, body),
-        onSuccess: () => {
-            queryClient.invalidateQueries({ queryKey: mailerQueryKeys.ownerClaimable() });
-        },
-        ...options,
-    });
-}
-/**
- * Hook to send prepared message to email address
- */
-export function useSendPreparedToEmail(options) {
-    const client = useMailerClient();
+export function useClaims(client, connectedWallet, chainInfo, options) {
     const queryClient = useQueryClient();
-    return useMutation({
-        mutationFn: async ({ toEmail, mailId }) => client.sendPreparedToEmail(toEmail, mailId),
+    const claimRevenue = useMutation({
+        mutationFn: () => client.claimRevenue(connectedWallet, chainInfo),
         onSuccess: () => {
-            queryClient.invalidateQueries({ queryKey: mailerQueryKeys.ownerClaimable() });
-        },
-        ...options,
-    });
-}
-/**
- * Hook to claim revenue share
- *
- * @example
- * ```tsx
- * function ClaimButton() {
- *   const { data: claimable } = useGetClaimableAmount();
- *   const claimRevenue = useClaimRevenue();
- *
- *   if (!claimable || claimable === 0n) return null;
- *
- *   return (
- *     <button
- *       onClick={() => claimRevenue.mutate()}
- *       disabled={claimRevenue.isPending}
- *     >
- *       Claim {Number(claimable) / 1_000_000} USDC
- *     </button>
- *   );
- * }
- * ```
- */
-export function useClaimRevenue(options) {
-    const client = useMailerClient();
-    const queryClient = useQueryClient();
-    return useMutation({
-        mutationFn: () => client.claimRevenue(),
-        onSuccess: () => {
-            // Invalidate claimable amount after successful claim
             queryClient.invalidateQueries({ queryKey: mailerQueryKeys.claimableAmount() });
         },
-        ...options,
+        ...options?.claimRevenue,
     });
-}
-/**
- * Hook to claim owner share (owner only)
- *
- * @example
- * ```tsx
- * function OwnerClaimButton() {
- *   const { data: ownerClaimable } = useGetOwnerClaimable();
- *   const claimOwner = useClaimOwnerShare();
- *
- *   return (
- *     <button onClick={() => claimOwner.mutate()}>
- *       Claim Owner Fees: {Number(ownerClaimable) / 1_000_000} USDC
- *     </button>
- *   );
- * }
- * ```
- */
-export function useClaimOwnerShare(options) {
-    const client = useMailerClient();
-    const queryClient = useQueryClient();
-    return useMutation({
-        mutationFn: () => client.claimOwnerShare(),
+    const claimOwnerShare = useMutation({
+        mutationFn: () => client.claimOwnerShare(connectedWallet, chainInfo),
         onSuccess: () => {
             queryClient.invalidateQueries({ queryKey: mailerQueryKeys.ownerClaimable() });
         },
-        ...options,
+        ...options?.claimOwnerShare,
     });
-}
-/**
- * Hook to reclaim expired recipient shares (owner only)
- */
-export function useClaimExpiredShares(options) {
-    const client = useMailerClient();
-    const queryClient = useQueryClient();
-    return useMutation({
-        mutationFn: async ({ recipient }) => client.claimExpiredShares(recipient),
+    const claimExpiredShares = useMutation({
+        mutationFn: async ({ recipient }) => client.claimExpiredShares(connectedWallet, chainInfo, recipient),
         onSuccess: (_, variables) => {
             queryClient.invalidateQueries({ queryKey: mailerQueryKeys.claimableAmount(variables.recipient) });
             queryClient.invalidateQueries({ queryKey: mailerQueryKeys.ownerClaimable() });
         },
-        ...options,
+        ...options?.claimExpiredShares,
     });
+    return {
+        claimRevenue,
+        claimOwnerShare,
+        claimExpiredShares,
+    };
 }
 /**
- * Hook to delegate to another address
+ * Hook for delegation-related operations
  *
  * @example
  * ```tsx
- * function DelegateButton() {
- *   const delegate = useDelegateTo();
+ * function DelegationManager() {
+ *   const { delegateTo, rejectDelegation } = useDelegation(client, wallet, chainInfo);
  *
  *   return (
- *     <button
- *       onClick={() => delegate.mutate({ delegate: '0xABC...' })}
- *       disabled={delegate.isPending}
- *     >
- *       Delegate
- *     </button>
+ *     <>
+ *       <button onClick={() => delegateTo.mutate({ delegate: '0xABC...' })}>
+ *         Delegate
+ *       </button>
+ *       <button onClick={() => rejectDelegation.mutate({ delegatorAddress: '0xDEF...' })}>
+ *         Reject Delegation
+ *       </button>
+ *     </>
  *   );
  * }
  * ```
  */
-export function useDelegateTo(options) {
-    const client = useMailerClient();
+export function useDelegation(client, connectedWallet, chainInfo, options) {
     const queryClient = useQueryClient();
-    return useMutation({
-        mutationFn: async ({ delegate }) => client.delegateTo(delegate),
+    const delegateTo = useMutation({
+        mutationFn: async ({ delegate }) => client.delegateTo(connectedWallet, chainInfo, delegate),
         onSuccess: () => {
             queryClient.invalidateQueries({ queryKey: mailerQueryKeys.delegation() });
         },
-        ...options,
+        ...options?.delegateTo,
     });
-}
-/**
- * Hook to reject a delegation made to you
- *
- * @example
- * ```tsx
- * function RejectDelegationButton({ delegatorAddress }: { delegatorAddress: string }) {
- *   const rejectDelegation = useRejectDelegation();
- *
- *   return (
- *     <button
- *       onClick={() => rejectDelegation.mutate({ delegatorAddress })}
- *     >
- *       Reject Delegation
- *     </button>
- *   );
- * }
- * ```
- */
-export function useRejectDelegation(options) {
-    const client = useMailerClient();
-    const queryClient = useQueryClient();
-    return useMutation({
-        mutationFn: async ({ delegatorAddress }) => client.rejectDelegation(delegatorAddress),
+    const rejectDelegation = useMutation({
+        mutationFn: async ({ delegatorAddress }) => client.rejectDelegation(connectedWallet, chainInfo, delegatorAddress),
         onSuccess: () => {
             queryClient.invalidateQueries({ queryKey: mailerQueryKeys.delegation() });
         },
-        ...options,
+        ...options?.rejectDelegation,
     });
+    return {
+        delegateTo,
+        rejectDelegation,
+    };
 }
 /**
- * Hook to set send fee (owner only)
+ * Hook for permission-related operations (EVM only)
  *
  * @example
  * ```tsx
- * function SetFeeForm() {
- *   const setFee = useSetFee();
+ * function PermissionManager() {
+ *   const { setPermission, removePermission } = usePermissions(client, wallet, chainInfo);
  *
  *   return (
- *     <button onClick={() => setFee.mutate({ newFee: 200000n })}>
- *       Update Fee to 0.2 USDC
- *     </button>
+ *     <>
+ *       <button onClick={() => setPermission.mutate({ contractAddress: '0xABC...' })}>
+ *         Grant Permission
+ *       </button>
+ *       <button onClick={() => removePermission.mutate({ contractAddress: '0xABC...' })}>
+ *         Revoke Permission
+ *       </button>
+ *     </>
  *   );
  * }
  * ```
  */
-export function useSetFee(options) {
-    const client = useMailerClient();
+export function usePermissions(client, connectedWallet, chainInfo, options) {
     const queryClient = useQueryClient();
-    return useMutation({
-        mutationFn: async ({ newFee }) => client.setFee(newFee),
+    const setPermission = useMutation({
+        mutationFn: async ({ contractAddress }) => client.setPermission(connectedWallet, chainInfo, contractAddress),
         onSuccess: () => {
-            queryClient.invalidateQueries({ queryKey: mailerQueryKeys.sendFee() });
+            queryClient.invalidateQueries({ queryKey: mailerQueryKeys.permissions() });
         },
-        ...options,
+        ...options?.setPermission,
     });
-}
-/**
- * Hook to set delegation fee (owner only)
- */
-export function useSetDelegationFee(options) {
-    const client = useMailerClient();
-    const queryClient = useQueryClient();
-    return useMutation({
-        mutationFn: async ({ newFee }) => client.setDelegationFee(newFee),
+    const removePermission = useMutation({
+        mutationFn: async ({ contractAddress }) => client.removePermission(connectedWallet, chainInfo, contractAddress),
         onSuccess: () => {
-            queryClient.invalidateQueries({ queryKey: mailerQueryKeys.delegationFee() });
+            queryClient.invalidateQueries({ queryKey: mailerQueryKeys.permissions() });
         },
-        ...options,
+        ...options?.removePermission,
     });
+    return {
+        setPermission,
+        removePermission,
+    };
 }
 /**
- * Hook to pause the contract (owner only)
+ * Hook for contract control operations (owner only)
  *
  * @example
  * ```tsx
- * function PauseButton() {
- *   const pause = usePause();
+ * function ContractControls() {
+ *   const { pause, unpause, emergencyUnpause } = useContractControl(client, wallet, chainInfo);
  *
  *   return (
- *     <button
- *       onClick={() => pause.mutate()}
- *       disabled={pause.isPending}
- *     >
- *       Pause Contract
- *     </button>
+ *     <>
+ *       <button onClick={() => pause.mutate()}>Pause</button>
+ *       <button onClick={() => unpause.mutate()}>Unpause</button>
+ *       <button onClick={() => emergencyUnpause.mutate()}>Emergency Unpause</button>
+ *     </>
  *   );
  * }
  * ```
  */
-export function usePause(options) {
-    const client = useMailerClient();
+export function useContractControl(client, connectedWallet, chainInfo, options) {
     const queryClient = useQueryClient();
-    return useMutation({
-        mutationFn: () => client.pause(),
+    const pause = useMutation({
+        mutationFn: () => client.pause(connectedWallet, chainInfo),
         onSuccess: () => {
             queryClient.invalidateQueries({ queryKey: mailerQueryKeys.isPaused() });
             queryClient.invalidateQueries({ queryKey: mailerQueryKeys.ownerClaimable() });
         },
-        ...options,
+        ...options?.pause,
     });
-}
-/**
- * Hook to unpause the contract (owner only)
- *
- * @example
- * ```tsx
- * function UnpauseButton() {
- *   const unpause = useUnpause();
- *
- *   return (
- *     <button onClick={() => unpause.mutate()}>
- *       Unpause Contract
- *     </button>
- *   );
- * }
- * ```
- */
-export function useUnpause(options) {
-    const client = useMailerClient();
-    const queryClient = useQueryClient();
-    return useMutation({
-        mutationFn: () => client.unpause(),
+    const unpause = useMutation({
+        mutationFn: () => client.unpause(connectedWallet, chainInfo),
         onSuccess: () => {
             queryClient.invalidateQueries({ queryKey: mailerQueryKeys.isPaused() });
         },
-        ...options,
+        ...options?.unpause,
     });
-}
-/**
- * Hook to emergency unpause (owner only)
- */
-export function useEmergencyUnpause(options) {
-    const client = useMailerClient();
-    const queryClient = useQueryClient();
-    return useMutation({
-        mutationFn: () => client.emergencyUnpause(),
+    const emergencyUnpause = useMutation({
+        mutationFn: () => client.emergencyUnpause(connectedWallet, chainInfo),
         onSuccess: () => {
             queryClient.invalidateQueries({ queryKey: mailerQueryKeys.isPaused() });
         },
-        ...options,
+        ...options?.emergencyUnpause,
     });
+    return {
+        pause,
+        unpause,
+        emergencyUnpause,
+    };
 }
 /**
- * Hook to distribute claimable funds (anyone can call when paused)
+ * Hook for owner-specific operations
  *
  * @example
  * ```tsx
- * function DistributeFundsButton({ recipient }: { recipient: string }) {
- *   const distribute = useDistributeClaimableFunds();
+ * function OwnerPanel() {
+ *   const { setFees, distributeClaimableFunds } = useOwnerOperations(client, wallet, chainInfo);
  *
  *   return (
- *     <button onClick={() => distribute.mutate({ recipient })}>
- *       Distribute Funds to {recipient}
- *     </button>
+ *     <>
+ *       <button onClick={() => setFees.mutate({ sendFee: 200000n, delegationFee: 10000000n })}>
+ *         Update Fees
+ *       </button>
+ *       <button onClick={() => distributeClaimableFunds.mutate({ recipient: '0xABC...' })}>
+ *         Distribute Funds
+ *       </button>
+ *     </>
  *   );
  * }
  * ```
  */
-export function useDistributeClaimableFunds(options) {
-    const client = useMailerClient();
+export function useOwnerOperations(client, connectedWallet, chainInfo, options) {
     const queryClient = useQueryClient();
-    return useMutation({
-        mutationFn: async ({ recipient }) => client.distributeClaimableFunds(recipient),
+    const setFees = useMutation({
+        mutationFn: async ({ sendFee, delegationFee }) => client.setFees(connectedWallet, chainInfo, sendFee, delegationFee),
+        onSuccess: () => {
+            queryClient.invalidateQueries({ queryKey: mailerQueryKeys.sendFee() });
+            queryClient.invalidateQueries({ queryKey: mailerQueryKeys.delegationFee() });
+        },
+        ...options?.setFees,
+    });
+    const distributeClaimableFunds = useMutation({
+        mutationFn: async ({ recipient }) => client.distributeClaimableFunds(connectedWallet, chainInfo, recipient),
         onSuccess: (_, variables) => {
             queryClient.invalidateQueries({ queryKey: mailerQueryKeys.claimableAmount(variables.recipient) });
         },
-        ...options,
+        ...options?.distributeClaimableFunds,
     });
+    return {
+        setFees,
+        distributeClaimableFunds,
+    };
+}
+// ========== Legacy individual hooks for backward compatibility ==========
+// These use context for convenience but the grouped hooks above are preferred
+import { useMailerContext } from '../context/MailerProvider.js';
+/**
+ * @deprecated Use useMessaging() instead
+ */
+export function useSendMessage(options) {
+    const { client, wallet, chainInfo } = useMailerContext();
+    const { sendMessage } = useMessaging(client, wallet, chainInfo, { sendMessage: options });
+    return sendMessage;
+}
+/**
+ * @deprecated Use useMessaging() instead
+ */
+export function useSendPrepared(options) {
+    const { client, wallet, chainInfo } = useMailerContext();
+    const { sendPrepared } = useMessaging(client, wallet, chainInfo, { sendPrepared: options });
+    return sendPrepared;
+}
+/**
+ * @deprecated Use useClaims() instead
+ */
+export function useClaimRevenue(options) {
+    const { client, wallet, chainInfo } = useMailerContext();
+    const { claimRevenue } = useClaims(client, wallet, chainInfo, { claimRevenue: options });
+    return claimRevenue;
+}
+/**
+ * @deprecated Use useClaims() instead
+ */
+export function useClaimOwnerShare(options) {
+    const { client, wallet, chainInfo } = useMailerContext();
+    const { claimOwnerShare } = useClaims(client, wallet, chainInfo, { claimOwnerShare: options });
+    return claimOwnerShare;
+}
+/**
+ * @deprecated Use useClaims() instead
+ */
+export function useClaimExpiredShares(options) {
+    const { client, wallet, chainInfo } = useMailerContext();
+    const { claimExpiredShares } = useClaims(client, wallet, chainInfo, { claimExpiredShares: options });
+    return claimExpiredShares;
+}
+/**
+ * @deprecated Use useDelegation() instead
+ */
+export function useDelegateTo(options) {
+    const { client, wallet, chainInfo } = useMailerContext();
+    const { delegateTo } = useDelegation(client, wallet, chainInfo, { delegateTo: options });
+    return delegateTo;
+}
+/**
+ * @deprecated Use useDelegation() instead
+ */
+export function useRejectDelegation(options) {
+    const { client, wallet, chainInfo } = useMailerContext();
+    const { rejectDelegation } = useDelegation(client, wallet, chainInfo, { rejectDelegation: options });
+    return rejectDelegation;
+}
+/**
+ * @deprecated Use usePermissions() instead
+ */
+export function useSetPermission(options) {
+    const { client, wallet, chainInfo } = useMailerContext();
+    const { setPermission } = usePermissions(client, wallet, chainInfo, { setPermission: options });
+    return setPermission;
+}
+/**
+ * @deprecated Use usePermissions() instead
+ */
+export function useRemovePermission(options) {
+    const { client, wallet, chainInfo } = useMailerContext();
+    const { removePermission } = usePermissions(client, wallet, chainInfo, { removePermission: options });
+    return removePermission;
+}
+/**
+ * @deprecated Use useOwnerOperations() instead
+ */
+export function useSetFees(options) {
+    const { client, wallet, chainInfo } = useMailerContext();
+    const { setFees } = useOwnerOperations(client, wallet, chainInfo, { setFees: options });
+    return setFees;
+}
+/**
+ * @deprecated Use useContractControl() instead
+ */
+export function usePause(options) {
+    const { client, wallet, chainInfo } = useMailerContext();
+    const { pause } = useContractControl(client, wallet, chainInfo, { pause: options });
+    return pause;
+}
+/**
+ * @deprecated Use useContractControl() instead
+ */
+export function useUnpause(options) {
+    const { client, wallet, chainInfo } = useMailerContext();
+    const { unpause } = useContractControl(client, wallet, chainInfo, { unpause: options });
+    return unpause;
+}
+/**
+ * @deprecated Use useContractControl() instead
+ */
+export function useEmergencyUnpause(options) {
+    const { client, wallet, chainInfo } = useMailerContext();
+    const { emergencyUnpause } = useContractControl(client, wallet, chainInfo, { emergencyUnpause: options });
+    return emergencyUnpause;
+}
+/**
+ * @deprecated Use useOwnerOperations() instead
+ */
+export function useDistributeClaimableFunds(options) {
+    const { client, wallet, chainInfo } = useMailerContext();
+    const { distributeClaimableFunds } = useOwnerOperations(client, wallet, chainInfo, { distributeClaimableFunds: options });
+    return distributeClaimableFunds;
 }
 //# sourceMappingURL=useMailerMutations.js.map