@pear-protocol/symmio-client 0.1.11 → 0.2.1

package/dist/react/index.js

@@ -1,3 +1,4 @@
+'use client';
 'use strict';
 
 var react = require('react');
@@ -7,8 +8,6 @@ var viem = require('viem');
 var jsxRuntime = require('react/jsx-runtime');
 var reactQuery = require('@tanstack/react-query');
 
-// src/react/provider.tsx
-
 // src/constants/addresses.ts
 var MULTI_ACCOUNT_ADDRESS = {
   [42161 /* ARBITRUM */]: "0x6273242a7E88b3De90822b31648C212215caaFE4",
@@ -24525,6 +24524,9 @@ var ALL_TRADING_SELECTORS = [
 var symmKeys = {
   all: ["symm"],
   accounts: (address, chainId) => ["symm", "accounts", address, chainId],
+  accountsApi: (address, chainId) => ["symm", "accountsApi", address, chainId],
+  accountsLength: (address, chainId) => ["symm", "accountsLength", address, chainId],
+  accountsWithPositions: (address, chainId) => ["symm", "accountsWithPositions", address, chainId],
   accountSummary: (address, chainId) => ["symm", "accountSummary", address, chainId],
   accountData: (address, chainId) => ["symm", "accountData", address, chainId],
   signature: (address, chainId) => ["symm", "signature", address, chainId],
@@ -24534,14 +24536,25 @@ var symmKeys = {
   openOrders: (address, chainId) => ["symm", "openOrders", address, chainId],
   tradeHistory: (address, chainId) => ["symm", "tradeHistory", address, chainId],
   tpslOrders: (address, chainId) => ["symm", "tpslOrders", address, chainId],
+  tpslOrdersList: (params) => ["symm", "tpslOrders", params],
   twapOrders: (address, chainId) => ["symm", "twapOrders", address, chainId],
+  triggerOrders: (params) => ["symm", "triggerOrders", params],
+  triggerConfig: (orderId) => ["symm", "triggerConfig", orderId],
   markets: (chainId, search) => ["symm", "markets", chainId, search],
+  hedgerMarketById: (id, chainId) => ["symm", "hedgerMarketById", id, chainId],
+  hedgerMarketBySymbol: (symbol, chainId) => ["symm", "hedgerMarketBySymbol", symbol, chainId],
+  lockedParams: (marketName, leverage, chainId) => ["symm", "lockedParams", marketName, leverage, chainId],
   hedgerMarkets: (request) => ["symm", "hedgerMarkets", request],
   fundingRates: (chainId) => ["symm", "fundingRates", chainId],
+  fundingPayments: (params) => ["symm", "fundingPayments", params],
+  fundingHistory: (params) => ["symm", "fundingHistory", params],
   portfolio: (address, chainId) => ["symm", "portfolio", address, chainId],
   notifications: (address, chainId) => ["symm", "notifications", address, chainId],
   unreadCount: (address, chainId) => ["symm", "unreadCount", address, chainId],
   availableMargin: (address, chainId) => ["symm", "availableMargin", address, chainId],
+  pendingIds: (address, chainId) => ["symm", "pendingIds", address, chainId],
+  pendingInstantOpens: (accountAddress, chainId) => ["symm", "pendingInstantOpens", accountAddress, chainId],
+  twapOrder: (orderId) => ["symm", "twapOrder", orderId],
   delegation: (account, target, selectors, chainId) => ["symm", "delegation", account, target, selectors, chainId],
   chartMetadata: (symbolsKey, positionKey) => ["symm", "chartMetadata", symbolsKey, positionKey]
 };
@@ -24603,6 +24616,7 @@ function invalidateOrders(qc) {
   qc.invalidateQueries({ queryKey: ["symm", "openOrders"] });
   qc.invalidateQueries({ queryKey: ["symm", "tpslOrders"] });
   qc.invalidateQueries({ queryKey: ["symm", "twapOrders"] });
+  qc.invalidateQueries({ queryKey: ["symm", "triggerOrders"] });
 }
 
 // src/react/hooks/use-symm-instant-trade.ts
@@ -24735,6 +24749,72 @@ function useSymmAccounts(userAddress, options) {
     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({
+    ...params.query,
+    queryKey: symmKeys.accountsApi(userAddress, chainId),
+    queryFn: () => symmCoreClient.accounts.list({
+      userAddress,
+      chainId
+    }),
+    enabled: internalEnabled && (params.query?.enabled ?? true),
+    staleTime: params.query?.staleTime ?? 1e4
+  });
+  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({
+    ...params.query,
+    queryKey: symmKeys.accountsLength(userAddress, chainId),
+    queryFn: () => symmCoreClient.accounts.getLength({
+      userAddress,
+      chainId
+    }),
+    enabled: internalEnabled && (params.query?.enabled ?? true),
+    staleTime: params.query?.staleTime ?? 1e4
+  });
+  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({
+    ...params.query,
+    queryKey: symmKeys.accountsWithPositions(userAddress, chainId),
+    queryFn: () => symmCoreClient.accounts.getWithPositions({
+      userAddress,
+      chainId
+    }),
+    enabled: internalEnabled && (params.query?.enabled ?? true),
+    staleTime: params.query?.staleTime ?? 1e4
+  });
+  return {
+    accounts: query.data?.data?.accounts ?? [],
+    total: query.data?.data?.total ?? 0,
+    isLoading: query.isLoading,
+    refetch: query.refetch
+  };
+}
 function useSymmApproval(params) {
   const { symmioClient, chainId } = useSymmContext();
   const queryClient = reactQuery.useQueryClient();
@@ -24781,6 +24861,57 @@ function useSymmApproval(params) {
     approve: approve2
   };
 }
+function useSymmCancelClose() {
+  const { symmCoreClient, authToken: ctxAuthToken, refreshAuth, chainId } = useSymmContext();
+  const queryClient = reactQuery.useQueryClient();
+  const cancelClose = reactQuery.useMutation({
+    mutationFn: async ({
+      quoteId,
+      authToken,
+      accountAddress,
+      overrideChainId
+    }) => {
+      if (!symmCoreClient) {
+        throw new Error("symm-core client not available");
+      }
+      const resolvedAuthToken = authToken ?? ctxAuthToken ?? (accountAddress ? await refreshAuth(accountAddress) : null);
+      if (!resolvedAuthToken) {
+        throw new Error("auth token is required to cancel a pending close");
+      }
+      return symmCoreClient.orders.cancelClose({
+        quoteId,
+        authToken: resolvedAuthToken,
+        chainId: overrideChainId ?? chainId
+      });
+    },
+    onSuccess: () => {
+      invalidateOrders(queryClient);
+      invalidatePositions(queryClient);
+    }
+  });
+  return { cancelClose };
+}
+function useSymmCloseOrder() {
+  const { symmCoreClient, authToken: ctxAuthToken } = useSymmContext();
+  const queryClient = reactQuery.useQueryClient();
+  const closeOrder = reactQuery.useMutation({
+    mutationFn: async (request) => {
+      if (!symmCoreClient) {
+        throw new Error("symm-core client not available");
+      }
+      return symmCoreClient.orders.close(request.id, {
+        kind: request.kind,
+        type: request.type,
+        authToken: request.authToken ?? ctxAuthToken ?? void 0
+      });
+    },
+    onSuccess: () => {
+      invalidateOrders(queryClient);
+      invalidatePositions(queryClient);
+    }
+  });
+  return { closeOrder };
+}
 function useSymmDeposit() {
   const { symmioClient } = useSymmContext();
   const queryClient = reactQuery.useQueryClient();
@@ -25140,6 +25271,40 @@ function useSymmTpsl() {
   });
   return { setTpsl, cancelTpsl };
 }
+function useSymmTpslOrders(params) {
+  const { symmCoreClient, chainId: ctxChainId } = useSymmContext();
+  const { accountAddress, mainAddress, positionId, type, status } = params;
+  const chainId = params.chainId ?? ctxChainId;
+  const internalEnabled = !!symmCoreClient && !!(accountAddress || mainAddress || positionId);
+  const request = {
+    address: accountAddress,
+    mainAddress,
+    positionId,
+    type,
+    status,
+    chainId
+  };
+  const query = reactQuery.useQuery({
+    ...params.query,
+    queryKey: symmKeys.tpslOrdersList({
+      accountAddress,
+      mainAddress,
+      positionId,
+      type,
+      status,
+      chainId
+    }),
+    queryFn: () => symmCoreClient.orders.getTpslOrders(request),
+    enabled: internalEnabled && (params.query?.enabled ?? true),
+    staleTime: params.query?.staleTime ?? 5e3
+  });
+  return {
+    tpslOrders: query.data?.data?.tpslOrders ?? [],
+    total: query.data?.data?.total ?? 0,
+    isLoading: query.isLoading,
+    refetch: query.refetch
+  };
+}
 function useSymmTwap(params) {
   const { symmCoreClient, chainId: ctxChainId } = useSymmContext();
   const queryClient = reactQuery.useQueryClient();
@@ -25172,6 +25337,90 @@ function useSymmTwap(params) {
     cancelTwap
   };
 }
+function useSymmTriggerConfig(params) {
+  const { symmCoreClient } = useSymmContext();
+  const queryClient = reactQuery.useQueryClient();
+  const { orderId } = params;
+  const internalEnabled = !!symmCoreClient && !!orderId;
+  const query = reactQuery.useQuery({
+    ...params.query,
+    queryKey: symmKeys.triggerConfig(orderId),
+    queryFn: () => symmCoreClient.orders.getTriggerConfig(orderId),
+    enabled: internalEnabled && (params.query?.enabled ?? true),
+    staleTime: params.query?.staleTime ?? 5e3
+  });
+  const setTriggerConfig = reactQuery.useMutation({
+    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({
+    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();
+  const { accountAddress, mainAddress, status, limit, offset } = params;
+  const chainId = params.chainId ?? ctxChainId;
+  const internalEnabled = !!symmCoreClient && !!(accountAddress || mainAddress);
+  const request = {
+    address: accountAddress,
+    mainAddress,
+    chainId,
+    status,
+    limit,
+    offset
+  };
+  const query = reactQuery.useQuery({
+    ...params.query,
+    queryKey: symmKeys.triggerOrders({
+      accountAddress,
+      mainAddress,
+      chainId,
+      status,
+      limit,
+      offset
+    }),
+    queryFn: () => symmCoreClient.orders.listTriggerOrders(request),
+    enabled: internalEnabled && (params.query?.enabled ?? true),
+    staleTime: params.query?.staleTime ?? 5e3
+  });
+  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;
@@ -25195,6 +25444,66 @@ function useSymmMarkets(params) {
     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({
+    ...params.query,
+    queryKey: symmKeys.hedgerMarketById(id, chainId),
+    queryFn: () => symmCoreClient.markets.getById(id, chainId),
+    enabled: internalEnabled && (params.query?.enabled ?? true),
+    staleTime: params.query?.staleTime ?? 3e4
+  });
+  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({
+    ...params.query,
+    queryKey: symmKeys.hedgerMarketBySymbol(symbol, chainId),
+    queryFn: () => symmCoreClient.markets.getBySymbol(symbol, chainId),
+    enabled: internalEnabled && (params.query?.enabled ?? true),
+    staleTime: params.query?.staleTime ?? 3e4
+  });
+  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({
+    ...params.query,
+    queryKey: symmKeys.lockedParams(marketName, leverage, chainId),
+    queryFn: () => symmCoreClient.markets.getLockedParams({
+      marketName,
+      leverage,
+      chainId
+    }),
+    enabled: internalEnabled && (params.query?.enabled ?? true),
+    staleTime: params.query?.staleTime ?? 3e4
+  });
+  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();
@@ -25251,6 +25560,72 @@ function useSymmFunding(params) {
     isLoading: query.isLoading
   };
 }
+function useSymmFundingHistory(params) {
+  const { symmCoreClient, chainId: ctxChainId } = useSymmContext();
+  const chainId = params.chainId ?? ctxChainId;
+  const {
+    period,
+    longSymbols,
+    shortSymbols,
+    interval,
+    weightMode,
+    includeContributions
+  } = params;
+  const internalEnabled = !!symmCoreClient;
+  const request = {
+    chainId,
+    period,
+    longSymbols,
+    shortSymbols,
+    interval,
+    weightMode,
+    includeContributions
+  };
+  const query = reactQuery.useQuery({
+    ...params.query,
+    queryKey: symmKeys.fundingHistory(request),
+    queryFn: () => symmCoreClient.funding.getHistory(request),
+    enabled: internalEnabled && (params.query?.enabled ?? true),
+    staleTime: params.query?.staleTime ?? 3e4
+  });
+  return {
+    history: query.data?.data ?? null,
+    isLoading: query.isLoading,
+    refetch: query.refetch
+  };
+}
+function useSymmFundingPayments(params) {
+  const { symmCoreClient, chainId: ctxChainId } = useSymmContext();
+  const { address, positionId, limit, offset } = params;
+  const chainId = params.chainId ?? ctxChainId;
+  const internalEnabled = !!symmCoreClient && !!(address || positionId);
+  const request = {
+    address,
+    positionId,
+    chainId,
+    limit,
+    offset
+  };
+  const query = reactQuery.useQuery({
+    ...params.query,
+    queryKey: symmKeys.fundingPayments({
+      address,
+      positionId,
+      chainId,
+      limit,
+      offset
+    }),
+    queryFn: () => symmCoreClient.funding.getPayments(request),
+    enabled: internalEnabled && (params.query?.enabled ?? true),
+    staleTime: params.query?.staleTime ?? 3e4
+  });
+  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();
   const { accountAddress, mainAddress } = params;
@@ -25300,11 +25675,12 @@ function useSymmNotifications(params) {
     staleTime: params.query?.staleTime ?? 1e4
   });
   const markRead = reactQuery.useMutation({
-    mutationFn: async ({ id }) => {
+    mutationFn: async ({ id, timestamp }) => {
       if (!symmCoreClient || !userAddress)
         throw new Error("symm-core client not available");
       return symmCoreClient.notifications.markRead({
         id,
+        timestamp,
         userAddress,
         chainId
       });
@@ -25326,6 +25702,78 @@ function useSymmNotifications(params) {
     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({
+    ...params.query,
+    queryKey: symmKeys.pendingIds(accountAddress, chainId),
+    queryFn: () => symmCoreClient.positions.getPendingIds({
+      address: accountAddress,
+      chainId
+    }),
+    enabled: internalEnabled && (params.query?.enabled ?? true),
+    staleTime: params.query?.staleTime ?? 5e3
+  });
+  return {
+    pendingIds: query.data?.data?.pendingIds ?? [],
+    isLoading: query.isLoading,
+    refetch: query.refetch
+  };
+}
+function useSymmPendingInstantOpens(params) {
+  const {
+    symmCoreClient,
+    chainId: ctxChainId,
+    authToken: ctxAuthToken,
+    refreshAuth
+  } = useSymmContext();
+  const { accountAddress, authToken: providedAuthToken } = params;
+  const chainId = params.chainId ?? ctxChainId;
+  const internalEnabled = !!symmCoreClient && !!accountAddress;
+  const query = reactQuery.useQuery({
+    ...params.query,
+    queryKey: symmKeys.pendingInstantOpens(accountAddress, chainId),
+    queryFn: async () => {
+      const authToken = providedAuthToken ?? ctxAuthToken ?? await refreshAuth(accountAddress);
+      if (!authToken) {
+        throw new Error("failed to acquire auth token for pending instant opens");
+      }
+      return symmCoreClient.positions.getPendingInstantOpens({
+        accountAddress,
+        chainId,
+        authToken
+      });
+    },
+    enabled: internalEnabled && (params.query?.enabled ?? true),
+    staleTime: params.query?.staleTime ?? 5e3
+  });
+  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({
+    ...params.query,
+    queryKey: symmKeys.twapOrder(orderId),
+    queryFn: () => symmCoreClient.orders.getTwapOrder(orderId),
+    enabled: internalEnabled && (params.query?.enabled ?? true),
+    staleTime: params.query?.staleTime ?? 5e3
+  });
+  return {
+    order: query.data?.data ?? null,
+    isLoading: query.isLoading,
+    refetch: query.refetch
+  };
+}
 function asUnsubscribeFn(value) {
   return typeof value === "function" ? value : null;
 }
@@ -25383,17 +25831,20 @@ function useSymmWs(params) {
     }));
     if (notificationsUnsub) unsubscribers.push(notificationsUnsub);
     const tpslUnsub = asUnsubscribeFn(ws.subscribeToTpsl(addr, chainId, () => {
-      queryClient.invalidateQueries({
-        queryKey: symmKeys.tpslOrders(accountAddress, chainId)
-      });
+      queryClient.invalidateQueries({ queryKey: ["symm", "tpslOrders"] });
+      queryClient.invalidateQueries({ queryKey: ["symm", "openOrders"] });
     }));
     if (tpslUnsub) unsubscribers.push(tpslUnsub);
     const twapUnsub = asUnsubscribeFn(ws.subscribeToTwapOrders(addr, chainId, () => {
-      queryClient.invalidateQueries({
-        queryKey: symmKeys.twapOrders(accountAddress, chainId)
-      });
+      queryClient.invalidateQueries({ queryKey: ["symm", "twapOrders"] });
+      queryClient.invalidateQueries({ queryKey: ["symm", "openOrders"] });
     }));
     if (twapUnsub) unsubscribers.push(twapUnsub);
+    const triggerOrdersUnsub = asUnsubscribeFn(ws.subscribeToTriggerOrders(addr, chainId, () => {
+      queryClient.invalidateQueries({ queryKey: ["symm", "triggerOrders"] });
+      queryClient.invalidateQueries({ queryKey: ["symm", "openOrders"] });
+    }));
+    if (triggerOrdersUnsub) unsubscribers.push(triggerOrdersUnsub);
     const executionsUnsub = asUnsubscribeFn(ws.subscribeToExecutions(addr, chainId, () => {
       queryClient.invalidateQueries({
         queryKey: symmKeys.positions(accountAddress, chainId)
@@ -26439,32 +26890,48 @@ exports.symmKeys = symmKeys;
 exports.useSymmAccountData = useSymmAccountData;
 exports.useSymmAccountSummary = useSymmAccountSummary;
 exports.useSymmAccounts = useSymmAccounts;
+exports.useSymmAccountsApi = useSymmAccountsApi;
+exports.useSymmAccountsLength = useSymmAccountsLength;
+exports.useSymmAccountsWithPositions = useSymmAccountsWithPositions;
 exports.useSymmApproval = useSymmApproval;
 exports.useSymmAuth = useSymmAuth;
 exports.useSymmAvailableMargin = useSymmAvailableMargin;
 exports.useSymmBalances = useSymmBalances;
+exports.useSymmCancelClose = useSymmCancelClose;
 exports.useSymmChartCandles = useSymmChartCandles;
 exports.useSymmChartSelection = useSymmChartSelection;
+exports.useSymmCloseOrder = useSymmCloseOrder;
 exports.useSymmCollateral = useSymmCollateral;
 exports.useSymmContext = useSymmContext;
 exports.useSymmCoreClient = useSymmCoreClient;
 exports.useSymmDelegation = useSymmDelegation;
 exports.useSymmDeposit = useSymmDeposit;
 exports.useSymmFunding = useSymmFunding;
+exports.useSymmFundingHistory = useSymmFundingHistory;
+exports.useSymmFundingPayments = useSymmFundingPayments;
+exports.useSymmHedgerMarketById = useSymmHedgerMarketById;
+exports.useSymmHedgerMarketBySymbol = useSymmHedgerMarketBySymbol;
 exports.useSymmHedgerMarkets = useSymmHedgerMarkets;
 exports.useSymmInstantTrade = useSymmInstantTrade;
+exports.useSymmLockedParams = useSymmLockedParams;
 exports.useSymmMarkets = useSymmMarkets;
 exports.useSymmNotifications = useSymmNotifications;
 exports.useSymmOpenOrders = useSymmOpenOrders;
+exports.useSymmPendingIds = useSymmPendingIds;
+exports.useSymmPendingInstantOpens = useSymmPendingInstantOpens;
 exports.useSymmPerformanceOverlays = useSymmPerformanceOverlays;
 exports.useSymmPortfolio = useSymmPortfolio;
 exports.useSymmPositions = useSymmPositions;
 exports.useSymmSignature = useSymmSignature;
 exports.useSymmTokenSelectionMetadata = useSymmTokenSelectionMetadata;
 exports.useSymmTpsl = useSymmTpsl;
+exports.useSymmTpslOrders = useSymmTpslOrders;
 exports.useSymmTrade = useSymmTrade;
 exports.useSymmTradeHistory = useSymmTradeHistory;
+exports.useSymmTriggerConfig = useSymmTriggerConfig;
+exports.useSymmTriggerOrders = useSymmTriggerOrders;
 exports.useSymmTwap = useSymmTwap;
+exports.useSymmTwapOrder = useSymmTwapOrder;
 exports.useSymmWithdraw = useSymmWithdraw;
 exports.useSymmWs = useSymmWs;
 exports.useSymmioClient = useSymmioClient;