@sudobility/contracts 0.15.1 → 1.9.0

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

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