@pear-protocol/symmio-client 0.2.13 → 0.2.14

package/dist/react/index.mjs

@@ -948,95 +948,124 @@ function invalidateOrders(qc) {
   qc.invalidateQueries({ queryKey: ["symm", "triggerOrders"] });
 }
 
-// src/react/hooks/use-symm-instant-trade.ts
-function useSymmInstantTrade(params) {
+// src/react/mutation-config.ts
+function withSymmMutationConfig(config, internal) {
   const {
-    symmCoreClient,
-    chainId,
-    address,
-    symmioConfig
-  } = useSymmContext();
-  const { publicClient, walletClient } = params;
-  const queryClient = useQueryClient();
+    onSuccess: configOnSuccess,
+    onError: configOnError,
+    onSettled: configOnSettled,
+    ...rest
+  } = config ?? {};
+  return {
+    ...rest,
+    onSuccess: async (...args) => {
+      await internal?.onSuccess?.(...args);
+      await configOnSuccess?.(...args);
+    },
+    onError: async (...args) => {
+      await internal?.onError?.(...args);
+      await configOnError?.(...args);
+    },
+    onSettled: async (...args) => {
+      await internal?.onSettled?.(...args);
+      await configOnSettled?.(...args);
+    }
+  };
+}
+
+// src/react/hooks/use-symm-instant-trade.ts
+function useInstantTradeDeps(params) {
+  const { symmCoreClient, chainId, address, symmioConfig } = useSymmContext();
   const multiAccount = symmioConfig?.multiAccountAddress ?? getAddress(MULTI_ACCOUNT_ADDRESS, chainId, "MultiAccount");
   const defaultAccountAddress = params.accountAddress ?? address;
   const defaultTarget = params.target ?? DEFAULT_PARTY_B_ADDRESS[chainId];
   const defaultSelectors = params.selectors ?? ALL_TRADING_SELECTORS;
-  const delegation = useSymmDelegation({
-    accountAddress: defaultAccountAddress,
-    publicClient,
-    target: defaultTarget,
-    selectors: defaultSelectors,
-    enabled: params.enabled
-  });
-  const ensureReady = useMutation({
-    mutationFn: async (request) => {
-      if (!publicClient || !walletClient) throw new Error("Clients not available");
-      const accountAddress = request?.accountAddress ?? defaultAccountAddress;
-      const target = request?.target ?? defaultTarget;
-      const selectors = request?.selectors ?? defaultSelectors;
-      if (!accountAddress) throw new Error("account address is required");
-      if (!target) throw new Error("delegation target is not configured");
-      if (selectors.length === 0) {
-        throw new Error("at least one delegation selector is required");
-      }
-      const accessToken = useSymmAuthStore.getState().getToken(accountAddress, chainId);
-      if (!accessToken) {
-        throw new Error("auth token is required for instant trading");
-      }
-      const accessStates = await Promise.all(
-        selectors.map(
-          (selector) => hasDelegatedAccess(publicClient, multiAccount, {
-            account: accountAddress,
-            target,
-            selector
-          })
-        )
-      );
-      if (!accessStates.every(Boolean)) {
-        await delegateAccess(walletClient, publicClient, multiAccount, {
-          account: accountAddress,
-          target,
-          selectors: [...selectors],
-          activate: true
-        });
-        await queryClient.invalidateQueries({
-          queryKey: symmKeys.delegation(accountAddress, target, selectors, chainId)
-        });
-      }
-      return {
-        accessToken,
-        accountAddress,
+  return {
+    chainId,
+    defaultAccountAddress,
+    defaultSelectors,
+    defaultTarget,
+    multiAccount,
+    publicClient: params.publicClient,
+    symmCoreClient,
+    walletClient: params.walletClient
+  };
+}
+async function ensureInstantTradeReady(deps, queryClient, request) {
+  const { chainId, defaultAccountAddress, defaultSelectors, defaultTarget, multiAccount, publicClient, walletClient } = deps;
+  if (!publicClient || !walletClient) throw new Error("Clients not available");
+  const accountAddress = request?.accountAddress ?? defaultAccountAddress;
+  const target = request?.target ?? defaultTarget;
+  const selectors = request?.selectors ?? defaultSelectors;
+  if (!accountAddress) throw new Error("account address is required");
+  if (!target) throw new Error("delegation target is not configured");
+  if (selectors.length === 0) {
+    throw new Error("at least one delegation selector is required");
+  }
+  const accessToken = useSymmAuthStore.getState().getToken(accountAddress, chainId);
+  if (!accessToken) {
+    throw new Error("auth token is required for instant trading");
+  }
+  const accessStates = await Promise.all(
+    selectors.map(
+      (selector) => hasDelegatedAccess(publicClient, multiAccount, {
+        account: accountAddress,
         target,
-        selectors
-      };
-    }
+        selector
+      })
+    )
+  );
+  if (!accessStates.every(Boolean)) {
+    await delegateAccess(walletClient, publicClient, multiAccount, {
+      account: accountAddress,
+      target,
+      selectors: [...selectors],
+      activate: true
+    });
+    await queryClient.invalidateQueries({
+      queryKey: symmKeys.delegation(accountAddress, target, selectors, chainId)
+    });
+  }
+  return {
+    accessToken,
+    accountAddress,
+    target,
+    selectors
+  };
+}
+function useSymmInstantTradeEnsureReadyMutation(params, options) {
+  const queryClient = useQueryClient();
+  const deps = useInstantTradeDeps(params);
+  return useMutation({
+    ...withSymmMutationConfig(options?.mutation),
+    mutationFn: async (request) => ensureInstantTradeReady(deps, queryClient, request)
   });
-  const execute = useMutation({
+}
+function useSymmInstantTradeExecuteMutation(params, options) {
+  const queryClient = useQueryClient();
+  const deps = useInstantTradeDeps(params);
+  return useMutation({
+    ...withSymmMutationConfig(options?.mutation, {
+      onSuccess: (_data, variables) => {
+        if (variables.invalidatePositionsOnSuccess !== false) {
+          invalidatePositions(queryClient);
+        }
+      }
+    }),
     mutationFn: async (request) => {
-      if (!symmCoreClient) throw new Error("symm-core client not available");
-      const setup = await ensureReady.mutateAsync({
+      if (!deps.symmCoreClient) throw new Error("symm-core client not available");
+      const setup = await ensureInstantTradeReady(deps, queryClient, {
         accountAddress: request.accountAddress,
         target: request.target,
         selectors: request.selectors
       });
       return request.action({
-        symmCoreClient,
+        symmCoreClient: deps.symmCoreClient,
         accessToken: setup.accessToken,
         accountAddress: setup.accountAddress
       });
-    },
-    onSuccess: (_data, variables) => {
-      if (variables.invalidatePositionsOnSuccess !== false) {
-        invalidatePositions(queryClient);
-      }
     }
   });
-  return {
-    delegation,
-    ensureReady,
-    execute
-  };
 }
 function prepareAddAccount(multiAccount, account, name) {
   const data = encodeFunctionData({
@@ -1095,51 +1124,65 @@ async function getAccounts(publicClient, multiAccount, user, start = 0, size = 1
 }
 
 // src/react/hooks/use-symm-accounts.ts
-function useSymmAccounts(params = {}, options) {
+function useResolvedMultiAccount() {
   const { chainId, symmioConfig } = useSymmContext();
-  const { userAddress, publicClient, walletClient } = params;
-  const queryClient = useQueryClient();
-  const multiAccount = symmioConfig?.multiAccountAddress ?? getAddress(MULTI_ACCOUNT_ADDRESS, chainId, "MultiAccount");
+  return symmioConfig?.multiAccountAddress ?? getAddress(MULTI_ACCOUNT_ADDRESS, chainId, "MultiAccount");
+}
+function useSymmAccountsQuery(params = {}, options) {
+  const { chainId } = useSymmContext();
+  const multiAccount = useResolvedMultiAccount();
+  const { userAddress, publicClient } = params;
   const internalEnabled = !!publicClient && !!userAddress;
-  const accountsQuery = useQuery({
+  return useQuery({
     ...options?.query,
     queryKey: symmKeys.accounts(userAddress, chainId),
     queryFn: () => getAccounts(publicClient, multiAccount, userAddress),
     enabled: internalEnabled && (options?.query?.enabled ?? true)
   });
-  const createAccount = useMutation({
+}
+function useSymmCreateAccountMutation(params = {}, options) {
+  const { chainId } = useSymmContext();
+  const queryClient = useQueryClient();
+  const multiAccount = useResolvedMultiAccount();
+  const { userAddress, publicClient, walletClient } = params;
+  return useMutation({
+    ...withSymmMutationConfig(options?.mutation, {
+      onSuccess: () => {
+        queryClient.invalidateQueries({ queryKey: symmKeys.accounts(userAddress, chainId) });
+      }
+    }),
     mutationFn: async ({ name }) => {
       if (!walletClient || !publicClient) throw new Error("Clients not available");
       return addAccount(walletClient, publicClient, multiAccount, name);
-    },
-    onSuccess: () => {
-      queryClient.invalidateQueries({ queryKey: symmKeys.accounts(userAddress, chainId) });
     }
   });
-  const editName = useMutation({
+}
+function useSymmEditAccountNameMutation(params = {}, options) {
+  const { chainId } = useSymmContext();
+  const queryClient = useQueryClient();
+  const multiAccount = useResolvedMultiAccount();
+  const { userAddress, publicClient, walletClient } = params;
+  return useMutation({
+    ...withSymmMutationConfig(options?.mutation, {
+      onSuccess: () => {
+        queryClient.invalidateQueries({ queryKey: symmKeys.accounts(userAddress, chainId) });
+      }
+    }),
     mutationFn: async ({
       accountAddress,
       name
     }) => {
       if (!walletClient || !publicClient) throw new Error("Clients not available");
       return editAccountName(walletClient, publicClient, multiAccount, accountAddress, name);
-    },
-    onSuccess: () => {
-      queryClient.invalidateQueries({ queryKey: symmKeys.accounts(userAddress, chainId) });
     }
   });
-  return {
-    query: accountsQuery,
-    createAccount,
-    editName
-  };
 }
 function useSymmAccountsApi(params) {
   const { symmCoreClient, chainId: ctxChainId } = useSymmContext();
   const { userAddress } = params;
   const chainId = params.chainId ?? ctxChainId;
   const internalEnabled = !!symmCoreClient && !!userAddress;
-  const query = useQuery({
+  return useQuery({
     ...params.query,
     queryKey: symmKeys.accountsApi(userAddress, chainId),
     queryFn: () => symmCoreClient.accounts.list({
@@ -1148,16 +1191,13 @@ function useSymmAccountsApi(params) {
     }),
     enabled: internalEnabled && (params.query?.enabled ?? true)
   });
-  return {
-    query
-  };
 }
 function useSymmAccountsLength(params) {
   const { symmCoreClient, chainId: ctxChainId } = useSymmContext();
   const { userAddress } = params;
   const chainId = params.chainId ?? ctxChainId;
   const internalEnabled = !!symmCoreClient && !!userAddress;
-  const query = useQuery({
+  return useQuery({
     ...params.query,
     queryKey: symmKeys.accountsLength(userAddress, chainId),
     queryFn: () => symmCoreClient.accounts.getLength({
@@ -1166,16 +1206,13 @@ function useSymmAccountsLength(params) {
     }),
     enabled: internalEnabled && (params.query?.enabled ?? true)
   });
-  return {
-    query
-  };
 }
 function useSymmAccountsWithPositions(params) {
   const { symmCoreClient, chainId: ctxChainId } = useSymmContext();
   const { userAddress } = params;
   const chainId = params.chainId ?? ctxChainId;
   const internalEnabled = !!symmCoreClient && !!userAddress;
-  const query = useQuery({
+  return useQuery({
     ...params.query,
     queryKey: symmKeys.accountsWithPositions(userAddress, chainId),
     queryFn: () => symmCoreClient.accounts.getWithPositions({
@@ -1184,9 +1221,6 @@ function useSymmAccountsWithPositions(params) {
     }),
     enabled: internalEnabled && (params.query?.enabled ?? true)
   });
-  return {
-    query
-  };
 }
 
 // src/abis/ERC20.ts
@@ -1304,14 +1338,22 @@ async function getBalance(publicClient, tokenAddress, account) {
 }
 
 // src/react/hooks/use-symm-approval.ts
-function useSymmApproval(params) {
+function useResolvedApprovalConfig(params) {
   const { chainId, symmioConfig } = useSymmContext();
-  const queryClient = useQueryClient();
-  const { owner, amount, publicClient, walletClient, spender, collateralToken } = params;
   const multiAccount = symmioConfig?.multiAccountAddress ?? getAddress(MULTI_ACCOUNT_ADDRESS, chainId, "MultiAccount");
   const collateral = symmioConfig?.collateralAddress ?? getAddress(COLLATERAL_ADDRESS, chainId, "Collateral");
-  const resolvedSpender = spender ?? multiAccount;
-  const resolvedToken = collateralToken ?? collateral;
+  const resolvedSpender = params.spender ?? multiAccount;
+  const resolvedToken = params.collateralToken ?? collateral;
+  return {
+    chainId,
+    multiAccount,
+    resolvedSpender,
+    resolvedToken
+  };
+}
+function useSymmApprovalQuery(params) {
+  const { owner, amount, publicClient } = params;
+  const { chainId, resolvedSpender, resolvedToken } = useResolvedApprovalConfig(params);
   const selectWithAmount = useCallback(
     (data) => ({
       ...data,
@@ -1320,7 +1362,7 @@ function useSymmApproval(params) {
     [amount]
   );
   const internalEnabled = !!publicClient && !!owner && !!resolvedSpender && !!resolvedToken;
-  const approvalQuery = useQuery({
+  return useQuery({
     ...params.query,
     queryKey: symmKeys.approval(owner, resolvedSpender, chainId, resolvedToken),
     queryFn: async () => {
@@ -1333,26 +1375,35 @@ function useSymmApproval(params) {
     select: selectWithAmount,
     enabled: internalEnabled && (params.query?.enabled ?? true)
   });
-  const approveMutation = useMutation({
+}
+function useSymmApproveMutation(params, options) {
+  const { owner, publicClient, walletClient } = params;
+  const { chainId, multiAccount, resolvedSpender, resolvedToken } = useResolvedApprovalConfig(params);
+  const queryClient = useQueryClient();
+  return useMutation({
+    ...withSymmMutationConfig(options?.mutation, {
+      onSuccess: () => {
+        queryClient.invalidateQueries({
+          queryKey: symmKeys.approval(owner, resolvedSpender, chainId, resolvedToken)
+        });
+      }
+    }),
     mutationFn: async (approveAmount) => {
       if (!walletClient || !publicClient) throw new Error("Clients not available");
       return approve(walletClient, publicClient, resolvedToken, multiAccount, approveAmount);
-    },
-    onSuccess: () => {
-      queryClient.invalidateQueries({
-        queryKey: symmKeys.approval(owner, resolvedSpender, chainId, resolvedToken)
-      });
     }
   });
-  return {
-    query: approvalQuery,
-    approve: approveMutation
-  };
 }
-function useSymmCancelClose() {
+function useSymmCancelClose(options) {
   const { symmCoreClient, chainId, address } = useSymmContext();
   const queryClient = useQueryClient();
-  const cancelClose = useMutation({
+  return useMutation({
+    ...withSymmMutationConfig(options?.mutation, {
+      onSuccess: () => {
+        invalidateOrders(queryClient);
+        invalidatePositions(queryClient);
+      }
+    }),
     mutationFn: async ({
       quoteId,
       authToken,
@@ -1373,18 +1424,19 @@ function useSymmCancelClose() {
         authToken: resolvedAuthToken,
         chainId: resolvedChainId
       });
-    },
-    onSuccess: () => {
-      invalidateOrders(queryClient);
-      invalidatePositions(queryClient);
     }
   });
-  return { cancelClose };
 }
-function useSymmCloseOrder() {
+function useSymmCloseOrder(options) {
   const { symmCoreClient, address, chainId } = useSymmContext();
   const queryClient = useQueryClient();
-  const closeOrder = useMutation({
+  return useMutation({
+    ...withSymmMutationConfig(options?.mutation, {
+      onSuccess: () => {
+        invalidateOrders(queryClient);
+        invalidatePositions(queryClient);
+      }
+    }),
     mutationFn: async (request) => {
       if (!symmCoreClient) {
         throw new Error("symm-core client not available");
@@ -1394,13 +1446,8 @@ function useSymmCloseOrder() {
         type: request.type,
         authToken: request.authToken ?? (address ? useSymmAuthStore.getState().getToken(address, chainId) ?? void 0 : void 0)
       });
-    },
-    onSuccess: () => {
-      invalidateOrders(queryClient);
-      invalidatePositions(queryClient);
     }
   });
-  return { closeOrder };
 }
 function prepareDeposit(multiAccount, account, params) {
   validateAmount(params.amount, "deposit amount");
@@ -1454,38 +1501,52 @@ async function depositAndAllocate(walletClient, publicClient, multiAccount, para
 }
 
 // src/react/hooks/use-symm-deposit.ts
-function useSymmDeposit(params = {}) {
+function useResolvedDepositParams(params = {}) {
   const { chainId, symmioConfig } = useSymmContext();
-  const { publicClient, walletClient } = params;
-  const queryClient = useQueryClient();
   const multiAccount = symmioConfig?.multiAccountAddress ?? getAddress(MULTI_ACCOUNT_ADDRESS, chainId, "MultiAccount");
-  const depositMutation = useMutation({
+  return {
+    multiAccount,
+    publicClient: params.publicClient,
+    walletClient: params.walletClient
+  };
+}
+function useSymmDepositMutation(params = {}, options) {
+  const queryClient = useQueryClient();
+  const { multiAccount, publicClient, walletClient } = useResolvedDepositParams(params);
+  return useMutation({
+    ...withSymmMutationConfig(options?.mutation, {
+      onSuccess: () => {
+        invalidateBalances(queryClient);
+        queryClient.invalidateQueries({ queryKey: ["symm", "approval"] });
+      }
+    }),
     mutationFn: async ({
       account,
       amount
     }) => {
       if (!walletClient || !publicClient) throw new Error("Clients not available");
       return deposit(walletClient, publicClient, multiAccount, { account, amount });
-    },
-    onSuccess: () => {
-      invalidateBalances(queryClient);
-      queryClient.invalidateQueries({ queryKey: ["symm", "approval"] });
     }
   });
-  const depositAndAllocateMutation = useMutation({
+}
+function useSymmDepositAndAllocateMutation(params = {}, options) {
+  const queryClient = useQueryClient();
+  const { multiAccount, publicClient, walletClient } = useResolvedDepositParams(params);
+  return useMutation({
+    ...withSymmMutationConfig(options?.mutation, {
+      onSuccess: () => {
+        invalidateBalances(queryClient);
+        queryClient.invalidateQueries({ queryKey: ["symm", "approval"] });
+      }
+    }),
     mutationFn: async ({
       account,
       amount
     }) => {
       if (!walletClient || !publicClient) throw new Error("Clients not available");
       return depositAndAllocate(walletClient, publicClient, multiAccount, { account, amount });
-    },
-    onSuccess: () => {
-      invalidateBalances(queryClient);
-      queryClient.invalidateQueries({ queryKey: ["symm", "approval"] });
     }
   });
-  return { deposit: depositMutation, depositAndAllocate: depositAndAllocateMutation };
 }
 function prepareWithdraw(multiAccount, account, params) {
   validateAmount(params.amount, "withdraw amount");
@@ -1514,24 +1575,25 @@ async function withdraw(walletClient, publicClient, multiAccount, params) {
 }
 
 // src/react/hooks/use-symm-withdraw.ts
-function useSymmWithdraw(params = {}) {
+function useSymmWithdraw(params = {}, options) {
   const { chainId, symmioConfig } = useSymmContext();
   const { publicClient, walletClient } = params;
   const queryClient = useQueryClient();
   const multiAccount = symmioConfig?.multiAccountAddress ?? getAddress(MULTI_ACCOUNT_ADDRESS, chainId, "MultiAccount");
-  const withdrawMutation = useMutation({
+  return useMutation({
+    ...withSymmMutationConfig(options?.mutation, {
+      onSuccess: () => {
+        invalidateBalances(queryClient);
+      }
+    }),
     mutationFn: async ({
       account,
       amount
     }) => {
       if (!walletClient || !publicClient) throw new Error("Clients not available");
       return withdraw(walletClient, publicClient, multiAccount, { account, amount });
-    },
-    onSuccess: () => {
-      invalidateBalances(queryClient);
     }
   });
-  return { withdraw: withdrawMutation };
 }
 
 // src/abis/SymmioDiamond.ts
@@ -24182,10 +24244,8 @@ var MuonClient = class {
 };
 
 // src/react/hooks/use-symm-collateral.ts
-function useSymmCollateral(params = {}) {
+function useResolvedCollateralDeps(params = {}) {
   const { chainId, symmioConfig } = useSymmContext();
-  const { publicClient, walletClient } = params;
-  const queryClient = useQueryClient();
   const multiAccount = symmioConfig?.multiAccountAddress ?? getAddress(MULTI_ACCOUNT_ADDRESS, chainId, "MultiAccount");
   const symmioDiamond = symmioConfig?.symmioDiamondAddress ?? getAddress(SYMMIO_DIAMOND_ADDRESS, chainId, "SymmioDiamond");
   const muon = useMemo(
@@ -24195,19 +24255,42 @@ function useSymmCollateral(params = {}) {
     }),
     [symmioConfig?.muonBaseUrls, symmioConfig?.muonAppName]
   );
-  const allocateMutation = useMutation({
+  return {
+    chainId,
+    muon,
+    multiAccount,
+    publicClient: params.publicClient,
+    symmioDiamond,
+    walletClient: params.walletClient
+  };
+}
+function useSymmAllocateCollateralMutation(params = {}, options) {
+  const queryClient = useQueryClient();
+  const { multiAccount, publicClient, walletClient } = useResolvedCollateralDeps(params);
+  return useMutation({
+    ...withSymmMutationConfig(options?.mutation, {
+      onSuccess: () => {
+        invalidateBalances(queryClient);
+      }
+    }),
     mutationFn: async ({
       subAccount,
       amount
     }) => {
       if (!walletClient || !publicClient) throw new Error("Clients not available");
       return allocate(walletClient, publicClient, multiAccount, subAccount, { amount });
-    },
-    onSuccess: () => {
-      invalidateBalances(queryClient);
     }
   });
-  const deallocateMutation = useMutation({
+}
+function useSymmDeallocateCollateralMutation(params = {}, options) {
+  const queryClient = useQueryClient();
+  const { chainId, muon, multiAccount, publicClient, symmioDiamond, walletClient } = useResolvedCollateralDeps(params);
+  return useMutation({
+    ...withSymmMutationConfig(options?.mutation, {
+      onSuccess: () => {
+        invalidateBalances(queryClient);
+      }
+    }),
     mutationFn: async ({
       subAccount,
       amount
@@ -24222,28 +24305,26 @@ function useSymmCollateral(params = {}) {
         amount,
         upnlSig
       });
-    },
-    onSuccess: () => {
-      invalidateBalances(queryClient);
     }
   });
-  const internalTransferMutation = useMutation({
+}
+function useSymmInternalTransferCollateralMutation(params = {}, options) {
+  const queryClient = useQueryClient();
+  const { multiAccount, publicClient, walletClient } = useResolvedCollateralDeps(params);
+  return useMutation({
+    ...withSymmMutationConfig(options?.mutation, {
+      onSuccess: () => {
+        invalidateBalances(queryClient);
+      }
+    }),
     mutationFn: async ({
       subAccount,
       params: transferParams
     }) => {
       if (!walletClient || !publicClient) throw new Error("Clients not available");
       return internalTransfer(walletClient, publicClient, multiAccount, subAccount, transferParams);
-    },
-    onSuccess: () => {
-      invalidateBalances(queryClient);
     }
   });
-  return {
-    allocate: allocateMutation,
-    deallocate: deallocateMutation,
-    internalTransfer: internalTransferMutation
-  };
 }
 
 // src/abis/SignatureStore.ts
@@ -24335,40 +24416,47 @@ async function hasSignedCurrentVersion(publicClient, signatureStore, user) {
 }
 
 // src/react/hooks/use-symm-signature.ts
-function useSymmSignature(params = {}, options) {
+function useResolvedSignatureStore() {
   const { chainId, symmioConfig } = useSymmContext();
-  const { userAddress, publicClient, walletClient } = params;
-  const queryClient = useQueryClient();
   let signatureStore;
   try {
     signatureStore = symmioConfig?.signatureStoreAddress ?? getAddress(SIGNATURE_STORE_ADDRESS, chainId, "SignatureStore");
   } catch {
+    signatureStore = void 0;
   }
+  return { chainId, signatureStore };
+}
+function useSymmSignatureQuery(params = {}, options) {
+  const { userAddress, publicClient } = params;
+  const { chainId, signatureStore } = useResolvedSignatureStore();
   const internalEnabled = !!publicClient && !!userAddress && !!signatureStore;
-  const signedQuery = useQuery({
+  return useQuery({
     ...options?.query,
     queryKey: symmKeys.signature(userAddress, chainId),
     queryFn: () => hasSignedCurrentVersion(publicClient, signatureStore, userAddress),
     enabled: internalEnabled && (options?.query?.enabled ?? true)
   });
-  const signTerms = useMutation({
+}
+function useSymmSignTermsMutation(params = {}, options) {
+  const { userAddress, publicClient, walletClient } = params;
+  const { chainId, signatureStore } = useResolvedSignatureStore();
+  const queryClient = useQueryClient();
+  return useMutation({
+    ...withSymmMutationConfig(options?.mutation, {
+      onSuccess: () => {
+        queryClient.invalidateQueries({
+          queryKey: symmKeys.signature(userAddress, chainId)
+        });
+      }
+    }),
     mutationFn: async () => {
       if (!walletClient || !publicClient || !signatureStore) {
         throw new Error("Clients or SignatureStore not available");
       }
       const sig = await signTermsMessage(walletClient, publicClient, signatureStore);
       await storeSignature(walletClient, publicClient, signatureStore, sig);
-    },
-    onSuccess: () => {
-      queryClient.invalidateQueries({
-        queryKey: symmKeys.signature(userAddress, chainId)
-      });
     }
   });
-  return {
-    query: signedQuery,
-    signTerms
-  };
 }
 
 // src/actions/stats.ts
@@ -24411,23 +24499,20 @@ function useSymmAvailableMargin(params) {
     [resolvedUpnl]
   );
   const internalEnabled = !!publicClient && !!accountAddress;
-  const query = useQuery({
+  return useQuery({
     ...params.query,
     queryKey: symmKeys.availableMargin(accountAddress, chainId),
     queryFn: () => getPartyAStats(publicClient, symmioDiamond, accountAddress),
     select: selectWithUpnl,
     enabled: internalEnabled && (params.query?.enabled ?? true)
   });
-  return {
-    query
-  };
 }
 function useSymmAccountSummary(params) {
   const { symmCoreClient, chainId: ctxChainId } = useSymmContext();
   const { userAddress } = params;
   const chainId = params.chainId ?? ctxChainId;
   const internalEnabled = !!symmCoreClient && !!userAddress;
-  const query = useQuery({
+  return useQuery({
     ...params.query,
     queryKey: symmKeys.accountSummary(userAddress, chainId),
     queryFn: () => symmCoreClient.accounts.getSummary({
@@ -24436,16 +24521,13 @@ function useSymmAccountSummary(params) {
     }),
     enabled: internalEnabled && (params.query?.enabled ?? true)
   });
-  return {
-    query
-  };
 }
 function useSymmAccountData(params) {
   const { symmCoreClient, chainId: ctxChainId } = useSymmContext();
   const { address, upnl } = params;
   const chainId = params.chainId ?? ctxChainId;
   const internalEnabled = !!symmCoreClient && !!address;
-  const query = useQuery({
+  return useQuery({
     ...params.query,
     queryKey: symmKeys.accountData(address, chainId, upnl),
     queryFn: () => symmCoreClient.accounts.getData({
@@ -24455,16 +24537,13 @@ function useSymmAccountData(params) {
     }),
     enabled: internalEnabled && (params.query?.enabled ?? true)
   });
-  return {
-    query
-  };
 }
 function useSymmBalances(params) {
   const { symmCoreClient, chainId: ctxChainId } = useSymmContext();
   const { userAddress, multiAccountAddress } = params;
   const chainId = params.chainId ?? ctxChainId;
   const internalEnabled = !!symmCoreClient && !!userAddress;
-  const query = useQuery({
+  return useQuery({
     ...params.query,
     queryKey: symmKeys.balances(userAddress, chainId),
     queryFn: () => symmCoreClient.accounts.getBalanceInfo({
@@ -24474,62 +24553,134 @@ function useSymmBalances(params) {
     }),
     enabled: internalEnabled && (params.query?.enabled ?? true)
   });
-  return {
-    query
-  };
 }
-function useSymmTrade() {
+function useResolveTradeAuthToken() {
+  const context = useSymmContext();
+  const { address, chainId } = context;
+  const { refreshAuth } = useSymmAuth({ address, chainId });
+  const refreshAuthFromContext = context.refreshAuth;
+  return useCallback(
+    async (providedAuthToken, accountAddress) => {
+      if (providedAuthToken) {
+        return providedAuthToken;
+      }
+      const resolvedAccountAddress = accountAddress ?? address;
+      if (!resolvedAccountAddress) {
+        return null;
+      }
+      const inMemoryToken = useSymmAuthStore.getState().getToken(resolvedAccountAddress, chainId);
+      if (inMemoryToken) {
+        return inMemoryToken;
+      }
+      if (refreshAuthFromContext) {
+        return refreshAuthFromContext(resolvedAccountAddress);
+      }
+      return refreshAuth(resolvedAccountAddress);
+    },
+    [address, chainId, refreshAuth, refreshAuthFromContext]
+  );
+}
+function useSymmOpenBasketMutation(options) {
   const { symmCoreClient } = useSymmContext();
   const queryClient = useQueryClient();
-  const openBasket = useMutation({
+  return useMutation({
+    ...withSymmMutationConfig(options?.mutation, {
+      onSuccess: () => {
+        invalidatePositions(queryClient);
+      }
+    }),
     mutationFn: async (request) => {
       if (!symmCoreClient) throw new Error("symm-core client not available");
       return symmCoreClient.positions.openBasket(request);
-    },
-    onSuccess: () => {
-      invalidatePositions(queryClient);
     }
   });
-  const closePosition = useMutation({
+}
+function useSymmClosePositionMutation(options) {
+  const { symmCoreClient } = useSymmContext();
+  const queryClient = useQueryClient();
+  const resolveAuthToken = useResolveTradeAuthToken();
+  return useMutation({
+    ...withSymmMutationConfig(options?.mutation, {
+      onSuccess: () => {
+        invalidatePositions(queryClient);
+      }
+    }),
     mutationFn: async (request) => {
       if (!symmCoreClient) throw new Error("symm-core client not available");
-      return symmCoreClient.positions.close(request);
-    },
-    onSuccess: () => {
-      invalidatePositions(queryClient);
+      const typedRequest = request;
+      const authToken = await resolveAuthToken(
+        typedRequest.authToken,
+        typedRequest.accountAddress
+      );
+      if (!authToken) {
+        throw new Error("auth token is required to close a position");
+      }
+      return symmCoreClient.positions.close({
+        ...request,
+        authToken
+      });
     }
   });
-  const closeAll = useMutation({
+}
+function useSymmCloseAllPositionsMutation(options) {
+  const { symmCoreClient } = useSymmContext();
+  const queryClient = useQueryClient();
+  return useMutation({
+    ...withSymmMutationConfig(options?.mutation, {
+      onSuccess: () => {
+        invalidatePositions(queryClient);
+      }
+    }),
     mutationFn: async (request) => {
       if (!symmCoreClient) throw new Error("symm-core client not available");
       return symmCoreClient.positions.closeAll(request);
-    },
-    onSuccess: () => {
-      invalidatePositions(queryClient);
     }
   });
-  const cancelOpen = useMutation({
+}
+function useSymmCancelOpenMutation(options) {
+  const { symmCoreClient } = useSymmContext();
+  const queryClient = useQueryClient();
+  return useMutation({
+    ...withSymmMutationConfig(options?.mutation, {
+      onSuccess: () => {
+        invalidatePositions(queryClient);
+      }
+    }),
     mutationFn: async (request) => {
       if (!symmCoreClient) throw new Error("symm-core client not available");
       return symmCoreClient.positions.cancelOpen(request);
-    },
-    onSuccess: () => {
-      invalidatePositions(queryClient);
     }
   });
-  const updatePosition = useMutation({
+}
+function useSymmUpdatePositionMutation(options) {
+  const { symmCoreClient } = useSymmContext();
+  const queryClient = useQueryClient();
+  const resolveAuthToken = useResolveTradeAuthToken();
+  return useMutation({
+    ...withSymmMutationConfig(options?.mutation, {
+      onSuccess: () => {
+        invalidatePositions(queryClient);
+      }
+    }),
     mutationFn: async ({
       positionId,
       request
     }) => {
       if (!symmCoreClient) throw new Error("symm-core client not available");
-      return symmCoreClient.positions.update(positionId, request);
-    },
-    onSuccess: () => {
-      invalidatePositions(queryClient);
+      const typedRequest = request;
+      const authToken = await resolveAuthToken(
+        typedRequest.authToken,
+        typedRequest.accountAddress
+      );
+      if (!authToken) {
+        throw new Error("auth token is required to update a position");
+      }
+      return symmCoreClient.positions.update(positionId, {
+        ...request,
+        authToken
+      });
     }
   });
-  return { openBasket, closePosition, closeAll, cancelOpen, updatePosition };
 }
 function useSymmPositions(params) {
   const { symmCoreClient, chainId: ctxChainId } = useSymmContext();
@@ -24537,14 +24688,7 @@ function useSymmPositions(params) {
   const resolvedAddress = accountAddress ? void 0 : address;
   const chainId = params.chainId ?? ctxChainId;
   const internalEnabled = !!symmCoreClient && !!(accountAddress || resolvedAddress);
-  console.log({
-    symmCoreClient,
-    accountAddress,
-    resolvedAddress,
-    chainId,
-    internalEnabled
-  });
-  const query = useQuery({
+  return useQuery({
     ...params.query,
     queryKey: symmKeys.positions({
       accountAddress,
@@ -24558,10 +24702,6 @@ function useSymmPositions(params) {
     }),
     enabled: internalEnabled && (params.query?.enabled ?? true)
   });
-  console.log("positions query", { data: query.data });
-  return {
-    query
-  };
 }
 function useSymmOpenOrders(params) {
   const { symmCoreClient, chainId: ctxChainId } = useSymmContext();
@@ -24569,7 +24709,7 @@ function useSymmOpenOrders(params) {
   const resolvedAddress = accountAddress ? void 0 : address;
   const chainId = params.chainId ?? ctxChainId;
   const internalEnabled = !!symmCoreClient && !!(accountAddress || resolvedAddress);
-  const query = useQuery({
+  return useQuery({
     ...params.query,
     queryKey: symmKeys.openOrders({
       accountAddress,
@@ -24582,9 +24722,6 @@ function useSymmOpenOrders(params) {
     }),
     enabled: internalEnabled && (params.query?.enabled ?? true)
   });
-  return {
-    query
-  };
 }
 function useSymmTradeHistory(params) {
   const { symmCoreClient, chainId: ctxChainId } = useSymmContext();
@@ -24592,7 +24729,7 @@ function useSymmTradeHistory(params) {
   const resolvedAddress = accountAddress ? void 0 : address;
   const chainId = params.chainId ?? ctxChainId;
   const internalEnabled = !!symmCoreClient && !!(accountAddress || resolvedAddress);
-  const query = useQuery({
+  return useQuery({
     ...params.query,
     queryKey: symmKeys.tradeHistory({
       accountAddress,
@@ -24609,34 +24746,38 @@ function useSymmTradeHistory(params) {
     },
     enabled: internalEnabled && (params.query?.enabled ?? true)
   });
-  return {
-    query
-  };
 }
-function useSymmTpsl() {
+function useSymmSetTpslMutation(options) {
   const { symmCoreClient } = useSymmContext();
   const queryClient = useQueryClient();
-  const setTpsl = useMutation({
+  return useMutation({
+    ...withSymmMutationConfig(options?.mutation, {
+      onSuccess: () => {
+        invalidateOrders(queryClient);
+        invalidatePositions(queryClient);
+      }
+    }),
     mutationFn: async (request) => {
       if (!symmCoreClient) throw new Error("symm-core client not available");
       return symmCoreClient.orders.setTpsl(request);
-    },
-    onSuccess: () => {
-      invalidateOrders(queryClient);
-      invalidatePositions(queryClient);
     }
   });
-  const cancelTpsl = useMutation({
+}
+function useSymmCancelTpslMutation(options) {
+  const { symmCoreClient } = useSymmContext();
+  const queryClient = useQueryClient();
+  return useMutation({
+    ...withSymmMutationConfig(options?.mutation, {
+      onSuccess: () => {
+        invalidateOrders(queryClient);
+        invalidatePositions(queryClient);
+      }
+    }),
     mutationFn: async (request) => {
       if (!symmCoreClient) throw new Error("symm-core client not available");
       return symmCoreClient.orders.cancelTpsl(request);
-    },
-    onSuccess: () => {
-      invalidateOrders(queryClient);
-      invalidatePositions(queryClient);
     }
   });
-  return { setTpsl, cancelTpsl };
 }
 function useSymmTpslOrders(params) {
   const { symmCoreClient, chainId: ctxChainId } = useSymmContext();
@@ -24651,7 +24792,7 @@ function useSymmTpslOrders(params) {
     status,
     chainId
   };
-  const query = useQuery({
+  return useQuery({
     ...params.query,
     queryKey: symmKeys.tpslOrdersList({
       accountAddress,
@@ -24664,84 +24805,94 @@ function useSymmTpslOrders(params) {
     queryFn: () => symmCoreClient.orders.getTpslOrders(request),
     enabled: internalEnabled && (params.query?.enabled ?? true)
   });
-  return {
-    query
-  };
 }
-function useSymmTwap(params) {
+function useResolvedTwapParams(params) {
   const { symmCoreClient, chainId: ctxChainId } = useSymmContext();
-  const queryClient = useQueryClient();
   const { accountAddress, address } = params;
   const resolvedAddress = accountAddress ? void 0 : address;
   const chainId = params.chainId ?? ctxChainId;
+  return { symmCoreClient, accountAddress, resolvedAddress, chainId, query: params.query };
+}
+function useSymmTwapOrdersQuery(params) {
+  const { symmCoreClient, accountAddress, resolvedAddress, chainId, query } = useResolvedTwapParams(params);
   const internalEnabled = !!symmCoreClient && !!(accountAddress || resolvedAddress);
-  const query = useQuery({
-    ...params.query,
+  return useQuery({
+    ...query,
     queryKey: symmKeys.twapOrders(accountAddress ?? resolvedAddress, chainId),
     queryFn: () => symmCoreClient.orders.getTwapOrders({
       address: accountAddress ?? resolvedAddress,
       chainId
     }),
-    enabled: internalEnabled && (params.query?.enabled ?? true)
+    enabled: internalEnabled && (query?.enabled ?? true)
   });
-  const cancelTwap = useMutation({
+}
+function useSymmCancelTwapOrderMutation(options) {
+  const { symmCoreClient } = useSymmContext();
+  const queryClient = useQueryClient();
+  return useMutation({
+    ...withSymmMutationConfig(options?.mutation, {
+      onSuccess: () => {
+        invalidateOrders(queryClient);
+      }
+    }),
     mutationFn: async (orderId) => {
       if (!symmCoreClient) throw new Error("symm-core client not available");
       return symmCoreClient.orders.cancelTwapOrder(orderId);
-    },
-    onSuccess: () => {
-      invalidateOrders(queryClient);
     }
   });
-  return {
-    query,
-    cancelTwap
-  };
 }
-function useSymmTriggerConfig(params) {
+function useSymmTriggerConfigQuery(params) {
   const { symmCoreClient } = useSymmContext();
-  const queryClient = useQueryClient();
   const { orderId } = params;
   const internalEnabled = !!symmCoreClient && !!orderId;
-  const query = useQuery({
+  return useQuery({
     ...params.query,
     queryKey: symmKeys.triggerConfig(orderId),
     queryFn: () => symmCoreClient.orders.getTriggerConfig(orderId),
     enabled: internalEnabled && (params.query?.enabled ?? true)
   });
-  const setTriggerConfig = useMutation({
+}
+function useSymmSetTriggerConfigMutation(params, options) {
+  const { symmCoreClient } = useSymmContext();
+  const { orderId } = params;
+  const queryClient = useQueryClient();
+  return useMutation({
+    ...withSymmMutationConfig(options?.mutation, {
+      onSuccess: () => {
+        queryClient.invalidateQueries({
+          queryKey: symmKeys.triggerConfig(orderId)
+        });
+        invalidateOrders(queryClient);
+      }
+    }),
     mutationFn: async (request) => {
       if (!symmCoreClient || !orderId) {
         throw new Error("symm-core client or orderId not available");
       }
       return symmCoreClient.orders.setTriggerConfig(orderId, request);
-    },
-    onSuccess: () => {
-      queryClient.invalidateQueries({
-        queryKey: symmKeys.triggerConfig(orderId)
-      });
-      invalidateOrders(queryClient);
     }
   });
-  const clearTriggerConfig = useMutation({
+}
+function useSymmClearTriggerConfigMutation(params, options) {
+  const { symmCoreClient } = useSymmContext();
+  const { orderId } = params;
+  const queryClient = useQueryClient();
+  return useMutation({
+    ...withSymmMutationConfig(options?.mutation, {
+      onSuccess: () => {
+        queryClient.invalidateQueries({
+          queryKey: symmKeys.triggerConfig(orderId)
+        });
+        invalidateOrders(queryClient);
+      }
+    }),
     mutationFn: async () => {
       if (!symmCoreClient || !orderId) {
         throw new Error("symm-core client or orderId not available");
       }
       return symmCoreClient.orders.clearTriggerConfig(orderId);
-    },
-    onSuccess: () => {
-      queryClient.invalidateQueries({
-        queryKey: symmKeys.triggerConfig(orderId)
-      });
-      invalidateOrders(queryClient);
     }
   });
-  return {
-    query,
-    setTriggerConfig,
-    clearTriggerConfig
-  };
 }
 function useSymmTriggerOrders(params) {
   const { symmCoreClient, chainId: ctxChainId } = useSymmContext();
@@ -24756,7 +24907,7 @@ function useSymmTriggerOrders(params) {
     limit,
     offset
   };
-  const query = useQuery({
+  return useQuery({
     ...params.query,
     queryKey: symmKeys.triggerOrders({
       accountAddress,
@@ -24769,16 +24920,13 @@ function useSymmTriggerOrders(params) {
     queryFn: () => symmCoreClient.orders.listTriggerOrders(request),
     enabled: internalEnabled && (params.query?.enabled ?? true)
   });
-  return {
-    query
-  };
 }
 function useSymmMarkets(params) {
   const { symmCoreClient, chainId: ctxChainId } = useSymmContext();
   const chainId = params?.chainId ?? ctxChainId;
   const searchText = params?.searchText;
   const internalEnabled = !!symmCoreClient;
-  const query = useQuery({
+  return useQuery({
     ...params?.query,
     queryKey: symmKeys.markets(chainId, searchText),
     queryFn: () => {
@@ -24790,46 +24938,37 @@ function useSymmMarkets(params) {
     },
     enabled: internalEnabled && (params?.query?.enabled ?? true)
   });
-  return {
-    query
-  };
 }
 function useSymmHedgerMarketById(params) {
   const { symmCoreClient, chainId: ctxChainId } = useSymmContext();
   const { id } = params;
   const chainId = params.chainId ?? ctxChainId;
   const internalEnabled = !!symmCoreClient && id != null;
-  const query = useQuery({
+  return useQuery({
     ...params.query,
     queryKey: symmKeys.hedgerMarketById(id, chainId),
     queryFn: () => symmCoreClient.markets.getById(id, chainId),
     enabled: internalEnabled && (params.query?.enabled ?? true)
   });
-  return {
-    query
-  };
 }
 function useSymmHedgerMarketBySymbol(params) {
   const { symmCoreClient, chainId: ctxChainId } = useSymmContext();
   const { symbol } = params;
   const chainId = params.chainId ?? ctxChainId;
   const internalEnabled = !!symmCoreClient && !!symbol;
-  const query = useQuery({
+  return useQuery({
     ...params.query,
     queryKey: symmKeys.hedgerMarketBySymbol(symbol, chainId),
     queryFn: () => symmCoreClient.markets.getBySymbol(symbol, chainId),
     enabled: internalEnabled && (params.query?.enabled ?? true)
   });
-  return {
-    query
-  };
 }
 function useSymmLockedParams(params) {
   const { symmCoreClient, chainId: ctxChainId } = useSymmContext();
   const { marketName, leverage } = params;
   const chainId = params.chainId ?? ctxChainId;
   const internalEnabled = !!symmCoreClient && !!marketName && leverage != null;
-  const query = useQuery({
+  return useQuery({
     ...params.query,
     queryKey: symmKeys.lockedParams(marketName, leverage, chainId),
     queryFn: () => symmCoreClient.markets.getLockedParams({
@@ -24839,9 +24978,6 @@ function useSymmLockedParams(params) {
     }),
     enabled: internalEnabled && (params.query?.enabled ?? true)
   });
-  return {
-    query
-  };
 }
 function useSymmHedgerMarkets(params) {
   const { symmCoreClient, chainId: ctxChainId } = useSymmContext();
@@ -24855,29 +24991,23 @@ function useSymmHedgerMarkets(params) {
     searchText: searchText || void 0
   };
   const internalEnabled = !!symmCoreClient;
-  const query = useQuery({
+  return useQuery({
     ...params?.query,
     queryKey: symmKeys.hedgerMarkets(request),
     queryFn: () => symmCoreClient.markets.listSymmHedger(request),
     enabled: internalEnabled && consumerEnabled
   });
-  return {
-    query
-  };
 }
 function useSymmFunding(params) {
   const { symmCoreClient, chainId: ctxChainId } = useSymmContext();
   const chainId = params?.chainId ?? ctxChainId;
   const internalEnabled = !!symmCoreClient;
-  const query = useQuery({
+  return useQuery({
     ...params?.query,
     queryKey: symmKeys.fundingRates(chainId),
     queryFn: () => symmCoreClient.funding.getRates({ chainId }),
     enabled: internalEnabled && (params?.query?.enabled ?? true)
   });
-  return {
-    query
-  };
 }
 function useSymmFundingHistory(params) {
   const { symmCoreClient, chainId: ctxChainId } = useSymmContext();
@@ -24900,15 +25030,12 @@ function useSymmFundingHistory(params) {
     weightMode,
     includeContributions
   };
-  const query = useQuery({
+  return useQuery({
     ...params.query,
     queryKey: symmKeys.fundingHistory(request),
     queryFn: () => symmCoreClient.funding.getHistory(request),
     enabled: internalEnabled && (params.query?.enabled ?? true)
   });
-  return {
-    query
-  };
 }
 function useSymmFundingPayments(params) {
   const { symmCoreClient, chainId: ctxChainId } = useSymmContext();
@@ -24922,7 +25049,7 @@ function useSymmFundingPayments(params) {
     limit,
     offset
   };
-  const query = useQuery({
+  return useQuery({
     ...params.query,
     queryKey: symmKeys.fundingPayments({
       address,
@@ -24934,9 +25061,6 @@ function useSymmFundingPayments(params) {
     queryFn: () => symmCoreClient.funding.getPayments(request),
     enabled: internalEnabled && (params.query?.enabled ?? true)
   });
-  return {
-    query
-  };
 }
 function useSymmPortfolio(params) {
   const { symmCoreClient, chainId: ctxChainId } = useSymmContext();
@@ -24944,7 +25068,7 @@ function useSymmPortfolio(params) {
   const resolvedAddress = accountAddress ? void 0 : address;
   const chainId = params.chainId ?? ctxChainId;
   const internalEnabled = !!symmCoreClient && !!(accountAddress || resolvedAddress);
-  const query = useQuery({
+  return useQuery({
     ...params.query,
     queryKey: symmKeys.portfolio({
       accountAddress,
@@ -24961,66 +25085,76 @@ function useSymmPortfolio(params) {
     },
     enabled: internalEnabled && (params.query?.enabled ?? true)
   });
-  return {
-    query
-  };
 }
-function useSymmNotifications(params) {
+function useResolvedNotificationsParams(params) {
   const { symmCoreClient, chainId: ctxChainId } = useSymmContext();
-  const queryClient = useQueryClient();
-  const { userAddress } = params;
   const chainId = params.chainId ?? ctxChainId;
+  return {
+    symmCoreClient,
+    chainId,
+    userAddress: params.userAddress,
+    query: params.query
+  };
+}
+function useSymmNotificationsQuery(params) {
+  const { symmCoreClient, chainId, userAddress, query } = useResolvedNotificationsParams(params);
   const internalEnabled = !!symmCoreClient && !!userAddress;
-  const notificationsQuery = useQuery({
-    ...params.query,
+  return useQuery({
+    ...query,
     queryKey: symmKeys.notifications(userAddress, chainId),
     queryFn: () => symmCoreClient.notifications.list({
       userAddress,
       chainId
     }),
-    enabled: internalEnabled && (params.query?.enabled ?? true)
+    enabled: internalEnabled && (query?.enabled ?? true)
   });
-  const unreadQuery = useQuery({
-    ...params.query,
+}
+function useSymmUnreadCountQuery(params) {
+  const { symmCoreClient, chainId, userAddress, query } = useResolvedNotificationsParams(params);
+  const internalEnabled = !!symmCoreClient && !!userAddress;
+  return useQuery({
+    ...query,
     queryKey: symmKeys.unreadCount(userAddress, chainId),
     queryFn: () => symmCoreClient.notifications.getUnreadCount({
       userAddress,
       chainId
     }),
-    enabled: internalEnabled && (params.query?.enabled ?? true)
+    enabled: internalEnabled && (query?.enabled ?? true)
   });
-  const markRead = useMutation({
+}
+function useSymmMarkReadNotificationMutation(params, options) {
+  const { symmCoreClient, chainId, userAddress } = useResolvedNotificationsParams(params);
+  const queryClient = useQueryClient();
+  return useMutation({
+    ...withSymmMutationConfig(options?.mutation, {
+      onSuccess: () => {
+        queryClient.invalidateQueries({
+          queryKey: symmKeys.notifications(userAddress, chainId)
+        });
+        queryClient.invalidateQueries({
+          queryKey: symmKeys.unreadCount(userAddress, chainId)
+        });
+      }
+    }),
     mutationFn: async ({ id, timestamp }) => {
-      if (!symmCoreClient || !userAddress)
+      if (!symmCoreClient || !userAddress) {
         throw new Error("symm-core client not available");
+      }
       return symmCoreClient.notifications.markRead({
         id,
         timestamp,
         userAddress,
         chainId
       });
-    },
-    onSuccess: () => {
-      queryClient.invalidateQueries({
-        queryKey: symmKeys.notifications(userAddress, chainId)
-      });
-      queryClient.invalidateQueries({
-        queryKey: symmKeys.unreadCount(userAddress, chainId)
-      });
     }
   });
-  return {
-    query: notificationsQuery,
-    unreadQuery,
-    markRead
-  };
 }
 function useSymmPendingIds(params) {
   const { symmCoreClient, chainId: ctxChainId } = useSymmContext();
   const { accountAddress } = params;
   const chainId = params.chainId ?? ctxChainId;
   const internalEnabled = !!symmCoreClient && !!accountAddress;
-  const query = useQuery({
+  return useQuery({
     ...params.query,
     queryKey: symmKeys.pendingIds(accountAddress, chainId),
     queryFn: () => symmCoreClient.positions.getPendingIds({
@@ -25029,9 +25163,6 @@ function useSymmPendingIds(params) {
     }),
     enabled: internalEnabled && (params.query?.enabled ?? true)
   });
-  return {
-    query
-  };
 }
 function useSymmPendingInstantOpens(params) {
   const {
@@ -25041,7 +25172,7 @@ function useSymmPendingInstantOpens(params) {
   const { accountAddress, authToken: providedAuthToken } = params;
   const chainId = params.chainId ?? ctxChainId;
   const internalEnabled = !!symmCoreClient && !!accountAddress;
-  const query = useQuery({
+  return useQuery({
     ...params.query,
     queryKey: symmKeys.pendingInstantOpens(accountAddress, chainId),
     queryFn: async () => {
@@ -25057,23 +25188,17 @@ function useSymmPendingInstantOpens(params) {
     },
     enabled: internalEnabled && (params.query?.enabled ?? true)
   });
-  return {
-    query
-  };
 }
 function useSymmTwapOrder(params) {
   const { symmCoreClient } = useSymmContext();
   const { orderId } = params;
   const internalEnabled = !!symmCoreClient && !!orderId;
-  const query = useQuery({
+  return useQuery({
     ...params.query,
     queryKey: symmKeys.twapOrder(orderId),
     queryFn: () => symmCoreClient.orders.getTwapOrder(orderId),
     enabled: internalEnabled && (params.query?.enabled ?? true)
   });
-  return {
-    query
-  };
 }
 var useSymmWsStore = create((set) => ({
   isConnected: false,
@@ -26272,6 +26397,6 @@ function getSymmErrorMessage(error) {
   return "An unexpected error occurred.";
 }
 
-export { SymmProvider, getSymmErrorMessage, symmKeys, useBinanceMarkPriceStore, useSymmAccountData, useSymmAccountSummary, useSymmAccounts, useSymmAccountsApi, useSymmAccountsLength, useSymmAccountsWithPositions, useSymmApproval, useSymmAuth, useSymmAuthStore, useSymmAvailableMargin, useSymmBalances, useSymmCancelClose, useSymmChartCandles, useSymmChartSelection, useSymmCloseOrder, useSymmCollateral, useSymmContext, useSymmCoreClient, useSymmDelegation, useSymmDeposit, useSymmFunding, useSymmFundingHistory, useSymmFundingPayments, useSymmHedgerMarketById, useSymmHedgerMarketBySymbol, useSymmHedgerMarkets, useSymmInstantTrade, useSymmLockedParams, useSymmMarkets, useSymmNotifications, useSymmOpenOrders, useSymmPendingIds, useSymmPendingInstantOpens, useSymmPerformanceOverlays, useSymmPortfolio, useSymmPositions, useSymmSignature, useSymmTokenSelectionMetadata, useSymmTpsl, useSymmTpslOrders, useSymmTrade, useSymmTradeHistory, useSymmTriggerConfig, useSymmTriggerOrders, useSymmTwap, useSymmTwapOrder, useSymmWithdraw, useSymmWs, useSymmWsStore };
+export { SymmProvider, getSymmErrorMessage, symmKeys, useBinanceMarkPriceStore, useSymmAccountData, useSymmAccountSummary, useSymmAccountsApi, useSymmAccountsLength, useSymmAccountsQuery, useSymmAccountsWithPositions, useSymmAllocateCollateralMutation, useSymmApprovalQuery, useSymmApproveMutation, useSymmAuth, useSymmAuthStore, useSymmAvailableMargin, useSymmBalances, useSymmCancelClose, useSymmCancelOpenMutation, useSymmCancelTpslMutation, useSymmCancelTwapOrderMutation, useSymmChartCandles, useSymmChartSelection, useSymmClearTriggerConfigMutation, useSymmCloseAllPositionsMutation, useSymmCloseOrder, useSymmClosePositionMutation, useSymmContext, useSymmCoreClient, useSymmCreateAccountMutation, useSymmDeallocateCollateralMutation, useSymmDelegation, useSymmDepositAndAllocateMutation, useSymmDepositMutation, useSymmEditAccountNameMutation, useSymmFunding, useSymmFundingHistory, useSymmFundingPayments, useSymmHedgerMarketById, useSymmHedgerMarketBySymbol, useSymmHedgerMarkets, useSymmInstantTradeEnsureReadyMutation, useSymmInstantTradeExecuteMutation, useSymmInternalTransferCollateralMutation, useSymmLockedParams, useSymmMarkReadNotificationMutation, useSymmMarkets, useSymmNotificationsQuery, useSymmOpenBasketMutation, useSymmOpenOrders, useSymmPendingIds, useSymmPendingInstantOpens, useSymmPerformanceOverlays, useSymmPortfolio, useSymmPositions, useSymmSetTpslMutation, useSymmSetTriggerConfigMutation, useSymmSignTermsMutation, useSymmSignatureQuery, useSymmTokenSelectionMetadata, useSymmTpslOrders, useSymmTradeHistory, useSymmTriggerConfigQuery, useSymmTriggerOrders, useSymmTwapOrder, useSymmTwapOrdersQuery, useSymmUnreadCountQuery, useSymmUpdatePositionMutation, useSymmWithdraw, useSymmWs, useSymmWsStore };
 //# sourceMappingURL=index.mjs.map
 //# sourceMappingURL=index.mjs.map