@pear-protocol/symmio-client 0.2.12 → 0.2.14

package/dist/react/index.js

@@ -950,95 +950,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 = reactQuery.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 = reactQuery.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 = reactQuery.useQueryClient();
+  const deps = useInstantTradeDeps(params);
+  return reactQuery.useMutation({
+    ...withSymmMutationConfig(options?.mutation),
+    mutationFn: async (request) => ensureInstantTradeReady(deps, queryClient, request)
   });
-  const execute = reactQuery.useMutation({
+}
+function useSymmInstantTradeExecuteMutation(params, options) {
+  const queryClient = reactQuery.useQueryClient();
+  const deps = useInstantTradeDeps(params);
+  return reactQuery.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 = viem.encodeFunctionData({
@@ -1097,56 +1126,65 @@ async function getAccounts(publicClient, multiAccount, user, start = 0, size = 1
 }
 
 // src/react/hooks/use-symm-accounts.ts
-var EMPTY_ACCOUNTS = [];
-function useSymmAccounts(params = {}, options) {
+function useResolvedMultiAccount() {
   const { chainId, symmioConfig } = useSymmContext();
-  const { userAddress, publicClient, walletClient } = params;
-  const queryClient = reactQuery.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 = reactQuery.useQuery({
+  return reactQuery.useQuery({
     ...options?.query,
     queryKey: symmKeys.accounts(userAddress, chainId),
     queryFn: () => getAccounts(publicClient, multiAccount, userAddress),
     enabled: internalEnabled && (options?.query?.enabled ?? true)
   });
-  const createAccount = reactQuery.useMutation({
+}
+function useSymmCreateAccountMutation(params = {}, options) {
+  const { chainId } = useSymmContext();
+  const queryClient = reactQuery.useQueryClient();
+  const multiAccount = useResolvedMultiAccount();
+  const { userAddress, publicClient, walletClient } = params;
+  return reactQuery.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 = reactQuery.useMutation({
+}
+function useSymmEditAccountNameMutation(params = {}, options) {
+  const { chainId } = useSymmContext();
+  const queryClient = reactQuery.useQueryClient();
+  const multiAccount = useResolvedMultiAccount();
+  const { userAddress, publicClient, walletClient } = params;
+  return reactQuery.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 {
-    accounts: accountsQuery.data ?? EMPTY_ACCOUNTS,
-    count: accountsQuery.data?.length ?? 0,
-    isLoading: accountsQuery.isLoading,
-    error: accountsQuery.error,
-    refetch: accountsQuery.refetch,
-    createAccount,
-    editName
-  };
 }
 function useSymmAccountsApi(params) {
   const { symmCoreClient, chainId: ctxChainId } = useSymmContext();
   const { userAddress } = params;
   const chainId = params.chainId ?? ctxChainId;
   const internalEnabled = !!symmCoreClient && !!userAddress;
-  const query = reactQuery.useQuery({
+  return reactQuery.useQuery({
     ...params.query,
     queryKey: symmKeys.accountsApi(userAddress, chainId),
     queryFn: () => symmCoreClient.accounts.list({
@@ -1155,19 +1193,13 @@ function useSymmAccountsApi(params) {
     }),
     enabled: internalEnabled && (params.query?.enabled ?? true)
   });
-  return {
-    accounts: query.data?.data?.accounts ?? [],
-    total: query.data?.data?.total ?? 0,
-    isLoading: query.isLoading,
-    refetch: query.refetch
-  };
 }
 function useSymmAccountsLength(params) {
   const { symmCoreClient, chainId: ctxChainId } = useSymmContext();
   const { userAddress } = params;
   const chainId = params.chainId ?? ctxChainId;
   const internalEnabled = !!symmCoreClient && !!userAddress;
-  const query = reactQuery.useQuery({
+  return reactQuery.useQuery({
     ...params.query,
     queryKey: symmKeys.accountsLength(userAddress, chainId),
     queryFn: () => symmCoreClient.accounts.getLength({
@@ -1176,19 +1208,13 @@ function useSymmAccountsLength(params) {
     }),
     enabled: internalEnabled && (params.query?.enabled ?? true)
   });
-  return {
-    chains: query.data?.data?.chains ?? [],
-    total: query.data?.data?.total ?? 0,
-    isLoading: query.isLoading,
-    refetch: query.refetch
-  };
 }
 function useSymmAccountsWithPositions(params) {
   const { symmCoreClient, chainId: ctxChainId } = useSymmContext();
   const { userAddress } = params;
   const chainId = params.chainId ?? ctxChainId;
   const internalEnabled = !!symmCoreClient && !!userAddress;
-  const query = reactQuery.useQuery({
+  return reactQuery.useQuery({
     ...params.query,
     queryKey: symmKeys.accountsWithPositions(userAddress, chainId),
     queryFn: () => symmCoreClient.accounts.getWithPositions({
@@ -1197,12 +1223,6 @@ function useSymmAccountsWithPositions(params) {
     }),
     enabled: internalEnabled && (params.query?.enabled ?? true)
   });
-  return {
-    accounts: query.data?.data?.accounts ?? [],
-    total: query.data?.data?.total ?? 0,
-    isLoading: query.isLoading,
-    refetch: query.refetch
-  };
 }
 
 // src/abis/ERC20.ts
@@ -1320,14 +1340,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 = reactQuery.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 = react.useCallback(
     (data) => ({
       ...data,
@@ -1336,7 +1364,7 @@ function useSymmApproval(params) {
     [amount]
   );
   const internalEnabled = !!publicClient && !!owner && !!resolvedSpender && !!resolvedToken;
-  const approvalQuery = reactQuery.useQuery({
+  return reactQuery.useQuery({
     ...params.query,
     queryKey: symmKeys.approval(owner, resolvedSpender, chainId, resolvedToken),
     queryFn: async () => {
@@ -1349,29 +1377,35 @@ function useSymmApproval(params) {
     select: selectWithAmount,
     enabled: internalEnabled && (params.query?.enabled ?? true)
   });
-  const approveMutation = reactQuery.useMutation({
+}
+function useSymmApproveMutation(params, options) {
+  const { owner, publicClient, walletClient } = params;
+  const { chainId, multiAccount, resolvedSpender, resolvedToken } = useResolvedApprovalConfig(params);
+  const queryClient = reactQuery.useQueryClient();
+  return reactQuery.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 {
-    approvalState: approvalQuery.data?.state ?? null,
-    allowance: approvalQuery.data?.allowance ?? 0n,
-    balance: approvalQuery.data?.balance ?? 0n,
-    isLoading: approvalQuery.isLoading,
-    approve: approveMutation
-  };
 }
-function useSymmCancelClose() {
+function useSymmCancelClose(options) {
   const { symmCoreClient, chainId, address } = useSymmContext();
   const queryClient = reactQuery.useQueryClient();
-  const cancelClose = reactQuery.useMutation({
+  return reactQuery.useMutation({
+    ...withSymmMutationConfig(options?.mutation, {
+      onSuccess: () => {
+        invalidateOrders(queryClient);
+        invalidatePositions(queryClient);
+      }
+    }),
     mutationFn: async ({
       quoteId,
       authToken,
@@ -1392,18 +1426,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 = reactQuery.useQueryClient();
-  const closeOrder = reactQuery.useMutation({
+  return reactQuery.useMutation({
+    ...withSymmMutationConfig(options?.mutation, {
+      onSuccess: () => {
+        invalidateOrders(queryClient);
+        invalidatePositions(queryClient);
+      }
+    }),
     mutationFn: async (request) => {
       if (!symmCoreClient) {
         throw new Error("symm-core client not available");
@@ -1413,13 +1448,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");
@@ -1473,38 +1503,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 = reactQuery.useQueryClient();
   const multiAccount = symmioConfig?.multiAccountAddress ?? getAddress(MULTI_ACCOUNT_ADDRESS, chainId, "MultiAccount");
-  const depositMutation = reactQuery.useMutation({
+  return {
+    multiAccount,
+    publicClient: params.publicClient,
+    walletClient: params.walletClient
+  };
+}
+function useSymmDepositMutation(params = {}, options) {
+  const queryClient = reactQuery.useQueryClient();
+  const { multiAccount, publicClient, walletClient } = useResolvedDepositParams(params);
+  return reactQuery.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 = reactQuery.useMutation({
+}
+function useSymmDepositAndAllocateMutation(params = {}, options) {
+  const queryClient = reactQuery.useQueryClient();
+  const { multiAccount, publicClient, walletClient } = useResolvedDepositParams(params);
+  return reactQuery.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");
@@ -1533,24 +1577,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 = reactQuery.useQueryClient();
   const multiAccount = symmioConfig?.multiAccountAddress ?? getAddress(MULTI_ACCOUNT_ADDRESS, chainId, "MultiAccount");
-  const withdrawMutation = reactQuery.useMutation({
+  return reactQuery.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
@@ -24201,10 +24246,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 = reactQuery.useQueryClient();
   const multiAccount = symmioConfig?.multiAccountAddress ?? getAddress(MULTI_ACCOUNT_ADDRESS, chainId, "MultiAccount");
   const symmioDiamond = symmioConfig?.symmioDiamondAddress ?? getAddress(SYMMIO_DIAMOND_ADDRESS, chainId, "SymmioDiamond");
   const muon = react.useMemo(
@@ -24214,19 +24257,42 @@ function useSymmCollateral(params = {}) {
     }),
     [symmioConfig?.muonBaseUrls, symmioConfig?.muonAppName]
   );
-  const allocateMutation = reactQuery.useMutation({
+  return {
+    chainId,
+    muon,
+    multiAccount,
+    publicClient: params.publicClient,
+    symmioDiamond,
+    walletClient: params.walletClient
+  };
+}
+function useSymmAllocateCollateralMutation(params = {}, options) {
+  const queryClient = reactQuery.useQueryClient();
+  const { multiAccount, publicClient, walletClient } = useResolvedCollateralDeps(params);
+  return reactQuery.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 = reactQuery.useMutation({
+}
+function useSymmDeallocateCollateralMutation(params = {}, options) {
+  const queryClient = reactQuery.useQueryClient();
+  const { chainId, muon, multiAccount, publicClient, symmioDiamond, walletClient } = useResolvedCollateralDeps(params);
+  return reactQuery.useMutation({
+    ...withSymmMutationConfig(options?.mutation, {
+      onSuccess: () => {
+        invalidateBalances(queryClient);
+      }
+    }),
     mutationFn: async ({
       subAccount,
       amount
@@ -24241,28 +24307,26 @@ function useSymmCollateral(params = {}) {
         amount,
         upnlSig
       });
-    },
-    onSuccess: () => {
-      invalidateBalances(queryClient);
     }
   });
-  const internalTransferMutation = reactQuery.useMutation({
+}
+function useSymmInternalTransferCollateralMutation(params = {}, options) {
+  const queryClient = reactQuery.useQueryClient();
+  const { multiAccount, publicClient, walletClient } = useResolvedCollateralDeps(params);
+  return reactQuery.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
@@ -24354,41 +24418,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 = reactQuery.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 = reactQuery.useQuery({
+  return reactQuery.useQuery({
     ...options?.query,
     queryKey: symmKeys.signature(userAddress, chainId),
     queryFn: () => hasSignedCurrentVersion(publicClient, signatureStore, userAddress),
     enabled: internalEnabled && (options?.query?.enabled ?? true)
   });
-  const signTerms = reactQuery.useMutation({
+}
+function useSymmSignTermsMutation(params = {}, options) {
+  const { userAddress, publicClient, walletClient } = params;
+  const { chainId, signatureStore } = useResolvedSignatureStore();
+  const queryClient = reactQuery.useQueryClient();
+  return reactQuery.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 {
-    hasSigned: signedQuery.data ?? false,
-    isLoading: signedQuery.isLoading,
-    signTerms
-  };
 }
 
 // src/actions/stats.ts
@@ -24416,25 +24486,6 @@ async function getPartyAStats(publicClient, symmioDiamond, partyA) {
     nonces: 0
   };
 }
-function calculateAvailableForOrder(stats, upnl) {
-  const {
-    allocatedBalance,
-    lockedCVA,
-    lockedLF,
-    lockedPartyAMM,
-    pendingLockedCVA,
-    pendingLockedLF,
-    pendingLockedPartyAMM
-  } = stats;
-  const totalPendingLocked = pendingLockedCVA + pendingLockedLF + pendingLockedPartyAMM;
-  if (upnl >= 0n) {
-    const totalLocked = lockedCVA + lockedLF + lockedPartyAMM;
-    return allocatedBalance + upnl - totalLocked - totalPendingLocked;
-  }
-  const absUpnl = -upnl;
-  const consideringMm = absUpnl > lockedPartyAMM ? absUpnl : lockedPartyAMM;
-  return allocatedBalance - lockedCVA - lockedLF - totalPendingLocked - consideringMm;
-}
 
 // src/react/hooks/use-symm-available-margin.ts
 function useSymmAvailableMargin(params) {
@@ -24445,32 +24496,25 @@ function useSymmAvailableMargin(params) {
   const selectWithUpnl = react.useCallback(
     (stats) => ({
       ...stats,
-      upnl: resolvedUpnl,
-      availableForOrder: calculateAvailableForOrder(stats, resolvedUpnl)
+      upnl: resolvedUpnl
     }),
     [resolvedUpnl]
   );
   const internalEnabled = !!publicClient && !!accountAddress;
-  const query = reactQuery.useQuery({
+  return reactQuery.useQuery({
     ...params.query,
     queryKey: symmKeys.availableMargin(accountAddress, chainId),
     queryFn: () => getPartyAStats(publicClient, symmioDiamond, accountAddress),
     select: selectWithUpnl,
     enabled: internalEnabled && (params.query?.enabled ?? true)
   });
-  return {
-    availableForOrder: query.data?.availableForOrder ?? null,
-    stats: query.data ?? null,
-    isLoading: query.isLoading,
-    refetch: query.refetch
-  };
 }
 function useSymmAccountSummary(params) {
   const { symmCoreClient, chainId: ctxChainId } = useSymmContext();
   const { userAddress } = params;
   const chainId = params.chainId ?? ctxChainId;
   const internalEnabled = !!symmCoreClient && !!userAddress;
-  const query = reactQuery.useQuery({
+  return reactQuery.useQuery({
     ...params.query,
     queryKey: symmKeys.accountSummary(userAddress, chainId),
     queryFn: () => symmCoreClient.accounts.getSummary({
@@ -24479,19 +24523,13 @@ function useSymmAccountSummary(params) {
     }),
     enabled: internalEnabled && (params.query?.enabled ?? true)
   });
-  return {
-    accounts: query.data?.data?.accounts ?? [],
-    total: query.data?.data?.total ?? 0,
-    isLoading: query.isLoading,
-    refetch: query.refetch
-  };
 }
 function useSymmAccountData(params) {
   const { symmCoreClient, chainId: ctxChainId } = useSymmContext();
   const { address, upnl } = params;
   const chainId = params.chainId ?? ctxChainId;
   const internalEnabled = !!symmCoreClient && !!address;
-  const query = reactQuery.useQuery({
+  return reactQuery.useQuery({
     ...params.query,
     queryKey: symmKeys.accountData(address, chainId, upnl),
     queryFn: () => symmCoreClient.accounts.getData({
@@ -24501,18 +24539,13 @@ function useSymmAccountData(params) {
     }),
     enabled: internalEnabled && (params.query?.enabled ?? true)
   });
-  return {
-    accountData: query.data?.data ?? null,
-    isLoading: query.isLoading,
-    refetch: query.refetch
-  };
 }
 function useSymmBalances(params) {
   const { symmCoreClient, chainId: ctxChainId } = useSymmContext();
   const { userAddress, multiAccountAddress } = params;
   const chainId = params.chainId ?? ctxChainId;
   const internalEnabled = !!symmCoreClient && !!userAddress;
-  const query = reactQuery.useQuery({
+  return reactQuery.useQuery({
     ...params.query,
     queryKey: symmKeys.balances(userAddress, chainId),
     queryFn: () => symmCoreClient.accounts.getBalanceInfo({
@@ -24522,64 +24555,134 @@ function useSymmBalances(params) {
     }),
     enabled: internalEnabled && (params.query?.enabled ?? true)
   });
-  return {
-    balanceInfo: query.data ?? null,
-    isLoading: query.isLoading,
-    refetch: query.refetch
-  };
 }
-function useSymmTrade() {
+function useResolveTradeAuthToken() {
+  const context = useSymmContext();
+  const { address, chainId } = context;
+  const { refreshAuth } = useSymmAuth({ address, chainId });
+  const refreshAuthFromContext = context.refreshAuth;
+  return react.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 = reactQuery.useQueryClient();
-  const openBasket = reactQuery.useMutation({
+  return reactQuery.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 = reactQuery.useMutation({
+}
+function useSymmClosePositionMutation(options) {
+  const { symmCoreClient } = useSymmContext();
+  const queryClient = reactQuery.useQueryClient();
+  const resolveAuthToken = useResolveTradeAuthToken();
+  return reactQuery.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 = reactQuery.useMutation({
+}
+function useSymmCloseAllPositionsMutation(options) {
+  const { symmCoreClient } = useSymmContext();
+  const queryClient = reactQuery.useQueryClient();
+  return reactQuery.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 = reactQuery.useMutation({
+}
+function useSymmCancelOpenMutation(options) {
+  const { symmCoreClient } = useSymmContext();
+  const queryClient = reactQuery.useQueryClient();
+  return reactQuery.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 = reactQuery.useMutation({
+}
+function useSymmUpdatePositionMutation(options) {
+  const { symmCoreClient } = useSymmContext();
+  const queryClient = reactQuery.useQueryClient();
+  const resolveAuthToken = useResolveTradeAuthToken();
+  return reactQuery.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();
@@ -24587,14 +24690,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 = reactQuery.useQuery({
+  return reactQuery.useQuery({
     ...params.query,
     queryKey: symmKeys.positions({
       accountAddress,
@@ -24608,12 +24704,6 @@ function useSymmPositions(params) {
     }),
     enabled: internalEnabled && (params.query?.enabled ?? true)
   });
-  console.log("positions query", { query });
-  return {
-    positions: query.data?.data?.positions ?? [],
-    isLoading: query.isLoading,
-    refetch: query.refetch
-  };
 }
 function useSymmOpenOrders(params) {
   const { symmCoreClient, chainId: ctxChainId } = useSymmContext();
@@ -24621,7 +24711,7 @@ function useSymmOpenOrders(params) {
   const resolvedAddress = accountAddress ? void 0 : address;
   const chainId = params.chainId ?? ctxChainId;
   const internalEnabled = !!symmCoreClient && !!(accountAddress || resolvedAddress);
-  const query = reactQuery.useQuery({
+  return reactQuery.useQuery({
     ...params.query,
     queryKey: symmKeys.openOrders({
       accountAddress,
@@ -24634,11 +24724,6 @@ function useSymmOpenOrders(params) {
     }),
     enabled: internalEnabled && (params.query?.enabled ?? true)
   });
-  return {
-    orders: query.data?.data?.orders ?? [],
-    isLoading: query.isLoading,
-    refetch: query.refetch
-  };
 }
 function useSymmTradeHistory(params) {
   const { symmCoreClient, chainId: ctxChainId } = useSymmContext();
@@ -24646,7 +24731,7 @@ function useSymmTradeHistory(params) {
   const resolvedAddress = accountAddress ? void 0 : address;
   const chainId = params.chainId ?? ctxChainId;
   const internalEnabled = !!symmCoreClient && !!(accountAddress || resolvedAddress);
-  const query = reactQuery.useQuery({
+  return reactQuery.useQuery({
     ...params.query,
     queryKey: symmKeys.tradeHistory({
       accountAddress,
@@ -24663,36 +24748,38 @@ function useSymmTradeHistory(params) {
     },
     enabled: internalEnabled && (params.query?.enabled ?? true)
   });
-  return {
-    trades: query.data ?? null,
-    isLoading: query.isLoading,
-    refetch: query.refetch
-  };
 }
-function useSymmTpsl() {
+function useSymmSetTpslMutation(options) {
   const { symmCoreClient } = useSymmContext();
   const queryClient = reactQuery.useQueryClient();
-  const setTpsl = reactQuery.useMutation({
+  return reactQuery.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 = reactQuery.useMutation({
+}
+function useSymmCancelTpslMutation(options) {
+  const { symmCoreClient } = useSymmContext();
+  const queryClient = reactQuery.useQueryClient();
+  return reactQuery.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();
@@ -24707,7 +24794,7 @@ function useSymmTpslOrders(params) {
     status,
     chainId
   };
-  const query = reactQuery.useQuery({
+  return reactQuery.useQuery({
     ...params.query,
     queryKey: symmKeys.tpslOrdersList({
       accountAddress,
@@ -24720,90 +24807,94 @@ function useSymmTpslOrders(params) {
     queryFn: () => symmCoreClient.orders.getTpslOrders(request),
     enabled: internalEnabled && (params.query?.enabled ?? true)
   });
-  return {
-    tpslOrders: query.data?.data?.tpslOrders ?? [],
-    total: query.data?.data?.total ?? 0,
-    isLoading: query.isLoading,
-    refetch: query.refetch
-  };
 }
-function useSymmTwap(params) {
+function useResolvedTwapParams(params) {
   const { symmCoreClient, chainId: ctxChainId } = useSymmContext();
-  const queryClient = reactQuery.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 = reactQuery.useQuery({
-    ...params.query,
+  return reactQuery.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 = reactQuery.useMutation({
+}
+function useSymmCancelTwapOrderMutation(options) {
+  const { symmCoreClient } = useSymmContext();
+  const queryClient = reactQuery.useQueryClient();
+  return reactQuery.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 {
-    twapOrders: query.data?.data?.orders ?? [],
-    isLoading: query.isLoading,
-    cancelTwap
-  };
 }
-function useSymmTriggerConfig(params) {
+function useSymmTriggerConfigQuery(params) {
   const { symmCoreClient } = useSymmContext();
-  const queryClient = reactQuery.useQueryClient();
   const { orderId } = params;
   const internalEnabled = !!symmCoreClient && !!orderId;
-  const query = reactQuery.useQuery({
+  return reactQuery.useQuery({
     ...params.query,
     queryKey: symmKeys.triggerConfig(orderId),
     queryFn: () => symmCoreClient.orders.getTriggerConfig(orderId),
     enabled: internalEnabled && (params.query?.enabled ?? true)
   });
-  const setTriggerConfig = reactQuery.useMutation({
+}
+function useSymmSetTriggerConfigMutation(params, options) {
+  const { symmCoreClient } = useSymmContext();
+  const { orderId } = params;
+  const queryClient = reactQuery.useQueryClient();
+  return reactQuery.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 = reactQuery.useMutation({
+}
+function useSymmClearTriggerConfigMutation(params, options) {
+  const { symmCoreClient } = useSymmContext();
+  const { orderId } = params;
+  const queryClient = reactQuery.useQueryClient();
+  return reactQuery.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 {
-    triggerConfig: query.data?.data?.triggerConfig ?? null,
-    isLoading: query.isLoading,
-    refetch: query.refetch,
-    setTriggerConfig,
-    clearTriggerConfig
-  };
 }
 function useSymmTriggerOrders(params) {
   const { symmCoreClient, chainId: ctxChainId } = useSymmContext();
@@ -24818,7 +24909,7 @@ function useSymmTriggerOrders(params) {
     limit,
     offset
   };
-  const query = reactQuery.useQuery({
+  return reactQuery.useQuery({
     ...params.query,
     queryKey: symmKeys.triggerOrders({
       accountAddress,
@@ -24831,21 +24922,13 @@ function useSymmTriggerOrders(params) {
     queryFn: () => symmCoreClient.orders.listTriggerOrders(request),
     enabled: internalEnabled && (params.query?.enabled ?? true)
   });
-  return {
-    orders: query.data?.data?.orders ?? [],
-    total: query.data?.data?.total ?? 0,
-    limit: query.data?.data?.limit ?? limit ?? 0,
-    offset: query.data?.data?.offset ?? offset ?? 0,
-    isLoading: query.isLoading,
-    refetch: query.refetch
-  };
 }
 function useSymmMarkets(params) {
   const { symmCoreClient, chainId: ctxChainId } = useSymmContext();
   const chainId = params?.chainId ?? ctxChainId;
   const searchText = params?.searchText;
   const internalEnabled = !!symmCoreClient;
-  const query = reactQuery.useQuery({
+  return reactQuery.useQuery({
     ...params?.query,
     queryKey: symmKeys.markets(chainId, searchText),
     queryFn: () => {
@@ -24857,54 +24940,37 @@ function useSymmMarkets(params) {
     },
     enabled: internalEnabled && (params?.query?.enabled ?? true)
   });
-  return {
-    markets: query.data?.markets ?? [],
-    isLoading: query.isLoading,
-    refetch: query.refetch
-  };
 }
 function useSymmHedgerMarketById(params) {
   const { symmCoreClient, chainId: ctxChainId } = useSymmContext();
   const { id } = params;
   const chainId = params.chainId ?? ctxChainId;
   const internalEnabled = !!symmCoreClient && id != null;
-  const query = reactQuery.useQuery({
+  return reactQuery.useQuery({
     ...params.query,
     queryKey: symmKeys.hedgerMarketById(id, chainId),
     queryFn: () => symmCoreClient.markets.getById(id, chainId),
     enabled: internalEnabled && (params.query?.enabled ?? true)
   });
-  return {
-    market: query.data?.data?.markets?.[0] ?? null,
-    markets: query.data?.data?.markets ?? [],
-    isLoading: query.isLoading,
-    refetch: query.refetch
-  };
 }
 function useSymmHedgerMarketBySymbol(params) {
   const { symmCoreClient, chainId: ctxChainId } = useSymmContext();
   const { symbol } = params;
   const chainId = params.chainId ?? ctxChainId;
   const internalEnabled = !!symmCoreClient && !!symbol;
-  const query = reactQuery.useQuery({
+  return reactQuery.useQuery({
     ...params.query,
     queryKey: symmKeys.hedgerMarketBySymbol(symbol, chainId),
     queryFn: () => symmCoreClient.markets.getBySymbol(symbol, chainId),
     enabled: internalEnabled && (params.query?.enabled ?? true)
   });
-  return {
-    market: query.data?.data?.markets?.[0] ?? null,
-    markets: query.data?.data?.markets ?? [],
-    isLoading: query.isLoading,
-    refetch: query.refetch
-  };
 }
 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 = reactQuery.useQuery({
+  return reactQuery.useQuery({
     ...params.query,
     queryKey: symmKeys.lockedParams(marketName, leverage, chainId),
     queryFn: () => symmCoreClient.markets.getLockedParams({
@@ -24914,16 +24980,7 @@ function useSymmLockedParams(params) {
     }),
     enabled: internalEnabled && (params.query?.enabled ?? true)
   });
-  return {
-    lockedParams: query.data?.data ?? null,
-    isLoading: query.isLoading,
-    refetch: query.refetch
-  };
 }
-var EMPTY_MARKETS = [];
-var EMPTY_SYMBOLS = [];
-var EMPTY_MAP_BY_ID = /* @__PURE__ */ new Map();
-var EMPTY_MAP_BY_SYMBOL = /* @__PURE__ */ new Map();
 function useSymmHedgerMarkets(params) {
   const { symmCoreClient, chainId: ctxChainId } = useSymmContext();
   const chainId = params?.chainId ?? ctxChainId;
@@ -24936,43 +24993,23 @@ function useSymmHedgerMarkets(params) {
     searchText: searchText || void 0
   };
   const internalEnabled = !!symmCoreClient;
-  const query = reactQuery.useQuery({
+  return reactQuery.useQuery({
     ...params?.query,
     queryKey: symmKeys.hedgerMarkets(request),
     queryFn: () => symmCoreClient.markets.listSymmHedger(request),
     enabled: internalEnabled && consumerEnabled
   });
-  const data = query.data ?? null;
-  return {
-    data,
-    markets: data?.markets ?? EMPTY_MARKETS,
-    rawMarkets: data?.rawMarkets ?? EMPTY_MARKETS,
-    filteredMarkets: data?.filteredMarkets ?? EMPTY_MARKETS,
-    allSymbols: data?.allSymbols ?? EMPTY_SYMBOLS,
-    filteredSymbols: data?.filteredSymbols ?? EMPTY_SYMBOLS,
-    marketsById: data?.marketsById ?? EMPTY_MAP_BY_ID,
-    marketsBySymbol: data?.marketsBySymbol ?? EMPTY_MAP_BY_SYMBOL,
-    category: data?.category ?? params?.category ?? "all",
-    resolvedSearchText: data?.searchText ?? searchText ?? "",
-    isLoading: query.isLoading,
-    isFetching: query.isFetching,
-    refetch: query.refetch
-  };
 }
 function useSymmFunding(params) {
   const { symmCoreClient, chainId: ctxChainId } = useSymmContext();
   const chainId = params?.chainId ?? ctxChainId;
   const internalEnabled = !!symmCoreClient;
-  const query = reactQuery.useQuery({
+  return reactQuery.useQuery({
     ...params?.query,
     queryKey: symmKeys.fundingRates(chainId),
     queryFn: () => symmCoreClient.funding.getRates({ chainId }),
     enabled: internalEnabled && (params?.query?.enabled ?? true)
   });
-  return {
-    rates: query.data?.data?.rates ?? [],
-    isLoading: query.isLoading
-  };
 }
 function useSymmFundingHistory(params) {
   const { symmCoreClient, chainId: ctxChainId } = useSymmContext();
@@ -24995,17 +25032,12 @@ function useSymmFundingHistory(params) {
     weightMode,
     includeContributions
   };
-  const query = reactQuery.useQuery({
+  return reactQuery.useQuery({
     ...params.query,
     queryKey: symmKeys.fundingHistory(request),
     queryFn: () => symmCoreClient.funding.getHistory(request),
     enabled: internalEnabled && (params.query?.enabled ?? true)
   });
-  return {
-    history: query.data?.data ?? null,
-    isLoading: query.isLoading,
-    refetch: query.refetch
-  };
 }
 function useSymmFundingPayments(params) {
   const { symmCoreClient, chainId: ctxChainId } = useSymmContext();
@@ -25019,7 +25051,7 @@ function useSymmFundingPayments(params) {
     limit,
     offset
   };
-  const query = reactQuery.useQuery({
+  return reactQuery.useQuery({
     ...params.query,
     queryKey: symmKeys.fundingPayments({
       address,
@@ -25031,12 +25063,6 @@ function useSymmFundingPayments(params) {
     queryFn: () => symmCoreClient.funding.getPayments(request),
     enabled: internalEnabled && (params.query?.enabled ?? true)
   });
-  return {
-    payments: query.data?.data?.payments ?? [],
-    total: query.data?.data?.total ?? 0,
-    isLoading: query.isLoading,
-    refetch: query.refetch
-  };
 }
 function useSymmPortfolio(params) {
   const { symmCoreClient, chainId: ctxChainId } = useSymmContext();
@@ -25044,7 +25070,7 @@ function useSymmPortfolio(params) {
   const resolvedAddress = accountAddress ? void 0 : address;
   const chainId = params.chainId ?? ctxChainId;
   const internalEnabled = !!symmCoreClient && !!(accountAddress || resolvedAddress);
-  const query = reactQuery.useQuery({
+  return reactQuery.useQuery({
     ...params.query,
     queryKey: symmKeys.portfolio({
       accountAddress,
@@ -25061,70 +25087,76 @@ function useSymmPortfolio(params) {
     },
     enabled: internalEnabled && (params.query?.enabled ?? true)
   });
-  return {
-    metrics: query.data ?? null,
-    isLoading: query.isLoading,
-    refetch: query.refetch
-  };
 }
-function useSymmNotifications(params) {
+function useResolvedNotificationsParams(params) {
   const { symmCoreClient, chainId: ctxChainId } = useSymmContext();
-  const queryClient = reactQuery.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 = reactQuery.useQuery({
-    ...params.query,
+  return reactQuery.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 = reactQuery.useQuery({
-    ...params.query,
+}
+function useSymmUnreadCountQuery(params) {
+  const { symmCoreClient, chainId, userAddress, query } = useResolvedNotificationsParams(params);
+  const internalEnabled = !!symmCoreClient && !!userAddress;
+  return reactQuery.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 = reactQuery.useMutation({
+}
+function useSymmMarkReadNotificationMutation(params, options) {
+  const { symmCoreClient, chainId, userAddress } = useResolvedNotificationsParams(params);
+  const queryClient = reactQuery.useQueryClient();
+  return reactQuery.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 {
-    notifications: notificationsQuery.data?.data?.notifications ?? [],
-    unreadCount: unreadQuery.data?.data?.unreadCount ?? 0,
-    isLoading: notificationsQuery.isLoading,
-    markRead,
-    refetch: notificationsQuery.refetch
-  };
 }
 function useSymmPendingIds(params) {
   const { symmCoreClient, chainId: ctxChainId } = useSymmContext();
   const { accountAddress } = params;
   const chainId = params.chainId ?? ctxChainId;
   const internalEnabled = !!symmCoreClient && !!accountAddress;
-  const query = reactQuery.useQuery({
+  return reactQuery.useQuery({
     ...params.query,
     queryKey: symmKeys.pendingIds(accountAddress, chainId),
     queryFn: () => symmCoreClient.positions.getPendingIds({
@@ -25133,11 +25165,6 @@ function useSymmPendingIds(params) {
     }),
     enabled: internalEnabled && (params.query?.enabled ?? true)
   });
-  return {
-    pendingIds: query.data?.data?.pendingIds ?? [],
-    isLoading: query.isLoading,
-    refetch: query.refetch
-  };
 }
 function useSymmPendingInstantOpens(params) {
   const {
@@ -25147,7 +25174,7 @@ function useSymmPendingInstantOpens(params) {
   const { accountAddress, authToken: providedAuthToken } = params;
   const chainId = params.chainId ?? ctxChainId;
   const internalEnabled = !!symmCoreClient && !!accountAddress;
-  const query = reactQuery.useQuery({
+  return reactQuery.useQuery({
     ...params.query,
     queryKey: symmKeys.pendingInstantOpens(accountAddress, chainId),
     queryFn: async () => {
@@ -25163,28 +25190,17 @@ function useSymmPendingInstantOpens(params) {
     },
     enabled: internalEnabled && (params.query?.enabled ?? true)
   });
-  return {
-    pendingOpens: query.data?.data?.pendingOpens ?? [],
-    total: query.data?.data?.total ?? 0,
-    isLoading: query.isLoading,
-    refetch: query.refetch
-  };
 }
 function useSymmTwapOrder(params) {
   const { symmCoreClient } = useSymmContext();
   const { orderId } = params;
   const internalEnabled = !!symmCoreClient && !!orderId;
-  const query = reactQuery.useQuery({
+  return reactQuery.useQuery({
     ...params.query,
     queryKey: symmKeys.twapOrder(orderId),
     queryFn: () => symmCoreClient.orders.getTwapOrder(orderId),
     enabled: internalEnabled && (params.query?.enabled ?? true)
   });
-  return {
-    order: query.data?.data ?? null,
-    isLoading: query.isLoading,
-    refetch: query.refetch
-  };
 }
 var useSymmWsStore = zustand.create((set) => ({
   isConnected: false,
@@ -25977,6 +25993,7 @@ function useSymmTokenSelectionMetadata(selection, options = {}) {
     const weightedRatio24h = computeWeightedRatio24h(metricInput) ?? 0;
     const sumNetFunding = computeNetFundingSum(metricInput);
     return {
+      query,
       isLoading,
       isPriceDataReady,
       isUnsupported,
@@ -26388,50 +26405,68 @@ exports.symmKeys = symmKeys;
 exports.useBinanceMarkPriceStore = useBinanceMarkPriceStore;
 exports.useSymmAccountData = useSymmAccountData;
 exports.useSymmAccountSummary = useSymmAccountSummary;
-exports.useSymmAccounts = useSymmAccounts;
 exports.useSymmAccountsApi = useSymmAccountsApi;
 exports.useSymmAccountsLength = useSymmAccountsLength;
+exports.useSymmAccountsQuery = useSymmAccountsQuery;
 exports.useSymmAccountsWithPositions = useSymmAccountsWithPositions;
-exports.useSymmApproval = useSymmApproval;
+exports.useSymmAllocateCollateralMutation = useSymmAllocateCollateralMutation;
+exports.useSymmApprovalQuery = useSymmApprovalQuery;
+exports.useSymmApproveMutation = useSymmApproveMutation;
 exports.useSymmAuth = useSymmAuth;
 exports.useSymmAuthStore = useSymmAuthStore;
 exports.useSymmAvailableMargin = useSymmAvailableMargin;
 exports.useSymmBalances = useSymmBalances;
 exports.useSymmCancelClose = useSymmCancelClose;
+exports.useSymmCancelOpenMutation = useSymmCancelOpenMutation;
+exports.useSymmCancelTpslMutation = useSymmCancelTpslMutation;
+exports.useSymmCancelTwapOrderMutation = useSymmCancelTwapOrderMutation;
 exports.useSymmChartCandles = useSymmChartCandles;
 exports.useSymmChartSelection = useSymmChartSelection;
+exports.useSymmClearTriggerConfigMutation = useSymmClearTriggerConfigMutation;
+exports.useSymmCloseAllPositionsMutation = useSymmCloseAllPositionsMutation;
 exports.useSymmCloseOrder = useSymmCloseOrder;
-exports.useSymmCollateral = useSymmCollateral;
+exports.useSymmClosePositionMutation = useSymmClosePositionMutation;
 exports.useSymmContext = useSymmContext;
 exports.useSymmCoreClient = useSymmCoreClient;
+exports.useSymmCreateAccountMutation = useSymmCreateAccountMutation;
+exports.useSymmDeallocateCollateralMutation = useSymmDeallocateCollateralMutation;
 exports.useSymmDelegation = useSymmDelegation;
-exports.useSymmDeposit = useSymmDeposit;
+exports.useSymmDepositAndAllocateMutation = useSymmDepositAndAllocateMutation;
+exports.useSymmDepositMutation = useSymmDepositMutation;
+exports.useSymmEditAccountNameMutation = useSymmEditAccountNameMutation;
 exports.useSymmFunding = useSymmFunding;
 exports.useSymmFundingHistory = useSymmFundingHistory;
 exports.useSymmFundingPayments = useSymmFundingPayments;
 exports.useSymmHedgerMarketById = useSymmHedgerMarketById;
 exports.useSymmHedgerMarketBySymbol = useSymmHedgerMarketBySymbol;
 exports.useSymmHedgerMarkets = useSymmHedgerMarkets;
-exports.useSymmInstantTrade = useSymmInstantTrade;
+exports.useSymmInstantTradeEnsureReadyMutation = useSymmInstantTradeEnsureReadyMutation;
+exports.useSymmInstantTradeExecuteMutation = useSymmInstantTradeExecuteMutation;
+exports.useSymmInternalTransferCollateralMutation = useSymmInternalTransferCollateralMutation;
 exports.useSymmLockedParams = useSymmLockedParams;
+exports.useSymmMarkReadNotificationMutation = useSymmMarkReadNotificationMutation;
 exports.useSymmMarkets = useSymmMarkets;
-exports.useSymmNotifications = useSymmNotifications;
+exports.useSymmNotificationsQuery = useSymmNotificationsQuery;
+exports.useSymmOpenBasketMutation = useSymmOpenBasketMutation;
 exports.useSymmOpenOrders = useSymmOpenOrders;
 exports.useSymmPendingIds = useSymmPendingIds;
 exports.useSymmPendingInstantOpens = useSymmPendingInstantOpens;
 exports.useSymmPerformanceOverlays = useSymmPerformanceOverlays;
 exports.useSymmPortfolio = useSymmPortfolio;
 exports.useSymmPositions = useSymmPositions;
-exports.useSymmSignature = useSymmSignature;
+exports.useSymmSetTpslMutation = useSymmSetTpslMutation;
+exports.useSymmSetTriggerConfigMutation = useSymmSetTriggerConfigMutation;
+exports.useSymmSignTermsMutation = useSymmSignTermsMutation;
+exports.useSymmSignatureQuery = useSymmSignatureQuery;
 exports.useSymmTokenSelectionMetadata = useSymmTokenSelectionMetadata;
-exports.useSymmTpsl = useSymmTpsl;
 exports.useSymmTpslOrders = useSymmTpslOrders;
-exports.useSymmTrade = useSymmTrade;
 exports.useSymmTradeHistory = useSymmTradeHistory;
-exports.useSymmTriggerConfig = useSymmTriggerConfig;
+exports.useSymmTriggerConfigQuery = useSymmTriggerConfigQuery;
 exports.useSymmTriggerOrders = useSymmTriggerOrders;
-exports.useSymmTwap = useSymmTwap;
 exports.useSymmTwapOrder = useSymmTwapOrder;
+exports.useSymmTwapOrdersQuery = useSymmTwapOrdersQuery;
+exports.useSymmUnreadCountQuery = useSymmUnreadCountQuery;
+exports.useSymmUpdatePositionMutation = useSymmUpdatePositionMutation;
 exports.useSymmWithdraw = useSymmWithdraw;
 exports.useSymmWs = useSymmWs;
 exports.useSymmWsStore = useSymmWsStore;