@pear-protocol/symmio-client 0.1.4 → 0.1.6

package/dist/react/index.mjs

@@ -3,7 +3,7 @@ import { useAccount, usePublicClient, useWalletClient } from 'wagmi';
 import { createSymmSDK, isAuthExpiredError, isNetworkError, isInsufficientMarginError, isRateLimitedError, isTimeoutError } from '@pear-protocol/symm-core';
 import { encodeFunctionData, isAddress } from 'viem';
 import { jsx } from 'react/jsx-runtime';
-import { useQueryClient, useQuery, useMutation } from '@tanstack/react-query';
+import { useQuery, useQueryClient, useMutation } from '@tanstack/react-query';
 
 // src/react/provider.tsx
 
@@ -27,6 +27,10 @@ var CLEARING_HOUSE_ADDRESS = {
 var SIGNATURE_STORE_ADDRESS = {
   [42161 /* ARBITRUM */]: "0x94eEa58De1C8945c342dB4bE9670301638E403e2"
 };
+var DEFAULT_PARTY_B_ADDRESS = {
+  [42161 /* ARBITRUM */]: "0x00c069d68bc7420740460DBC3cc3fFF9b3742421",
+  [8453 /* BASE */]: "0x1EcAbF0Eba136920677C9575FAccee36f30592cf"
+};
 function getAddress(addressMap, chainId, name) {
   const addr = addressMap[chainId];
   if (!addr || addr === "0x0000000000000000000000000000000000000000") {
@@ -23650,6 +23654,17 @@ async function revokeAccess(walletClient, publicClient, multiAccount, params) {
     chain: walletClient.chain
   });
 }
+async function hasDelegatedAccess(publicClient, multiAccount, params) {
+  validateAddress(params.account, "subAccount");
+  validateAddress(params.target, "target");
+  const result = await publicClient.readContract({
+    address: multiAccount,
+    abi: MultiAccountABI,
+    functionName: "delegatedAccesses",
+    args: [params.account, params.target, params.selector]
+  });
+  return Boolean(result);
+}
 
 // src/abis/SignatureStore.ts
 var SignatureStoreABI = [
@@ -23954,6 +23969,51 @@ async function getOpenInstantCloses(chainId, account, accessToken) {
   return response.json();
 }
 
+// src/actions/stats.ts
+async function getPartyAStats(publicClient, symmioDiamond, partyA) {
+  const result = await publicClient.readContract({
+    address: symmioDiamond,
+    abi: SymmioDiamondABI,
+    functionName: "partyAStats",
+    args: [partyA]
+  });
+  return {
+    collateralBalance: result[1],
+    allocatedBalance: result[2],
+    availableBalance: result[3],
+    lockedCVA: result[4],
+    lockedLF: result[5],
+    lockedPartyAMM: result[6],
+    lockedPartyBMM: result[7],
+    pendingLockedCVA: result[8],
+    pendingLockedLF: result[9],
+    pendingLockedPartyAMM: result[10],
+    pendingLockedPartyBMM: result[11],
+    positionsCount: Number(result[12]),
+    pendingCount: Number(result[13]),
+    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/client.ts
 var SymmioSDK = class {
   chainId;
@@ -24100,7 +24160,9 @@ var SymmioSDK = class {
       /** Propose to revoke delegated access (starts cooldown). */
       proposeRevoke: (params) => proposeRevoke(wc, pc, ma, params),
       /** Revoke delegated access (after cooldown). */
-      revokeAccess: (params) => revokeAccess(wc, pc, ma, params)
+      revokeAccess: (params) => revokeAccess(wc, pc, ma, params),
+      /** Reads whether a selector is delegated to a target for a sub-account. */
+      hasAccess: (params) => hasDelegatedAccess(pc, ma, params)
     };
   }
   // ─── Signature Module ──────────────────────────────────────────
@@ -24156,6 +24218,17 @@ var SymmioSDK = class {
       getOpenCloses: (account, accessToken) => getOpenInstantCloses(this.chainId, account, accessToken)
     };
   }
+  // ─── Stats Module ───────────────────────────────────────────
+  get stats() {
+    const pc = this._publicClient;
+    const sd = this._symmioDiamond;
+    return {
+      /** Reads partyA statistics (balances, locks) from the Diamond contract. */
+      getPartyAStats: (partyA) => getPartyAStats(pc, sd, partyA),
+      /** Calculates available margin for placing orders given uPNL. */
+      calculateAvailableForOrder: (stats, upnl) => calculateAvailableForOrder(stats, upnl)
+    };
+  }
   // ─── Muon Signatures ──────────────────────────────────────────
   async getQuoteSig(partyA, symbolId) {
     return this.muon.getQuoteSig({
@@ -24386,6 +24459,14 @@ function useSymmAuth() {
   };
 }
 
+// src/constants/selectors.ts
+var SEND_QUOTE_WITH_AFFILIATE_SELECTOR = "0x40f1310c";
+var CLOSE_QUOTE_SELECTOR = "0x501e891f";
+var ALL_TRADING_SELECTORS = [
+  SEND_QUOTE_WITH_AFFILIATE_SELECTOR,
+  CLOSE_QUOTE_SELECTOR
+];
+
 // src/react/query-keys.ts
 var symmKeys = {
   all: ["symm"],
@@ -24400,14 +24481,159 @@ var symmKeys = {
   tpslOrders: (address, chainId) => ["symm", "tpslOrders", address, chainId],
   twapOrders: (address, chainId) => ["symm", "twapOrders", address, chainId],
   markets: (chainId, search) => ["symm", "markets", chainId, search],
-  hedgerMarkets: (chainId, search) => ["symm", "hedgerMarkets", chainId, search],
+  hedgerMarkets: (request) => ["symm", "hedgerMarkets", request],
   fundingRates: (chainId) => ["symm", "fundingRates", chainId],
   portfolio: (address, chainId) => ["symm", "portfolio", address, chainId],
   notifications: (address, chainId) => ["symm", "notifications", address, chainId],
-  unreadCount: (address, chainId) => ["symm", "unreadCount", address, chainId]
+  unreadCount: (address, chainId) => ["symm", "unreadCount", address, chainId],
+  availableMargin: (address, chainId) => ["symm", "availableMargin", address, chainId],
+  delegation: (account, target, selectors, chainId) => ["symm", "delegation", account, target, selectors, chainId]
 };
 
-// src/react/hooks/use-symm-accounts.ts
+// src/react/hooks/use-symm-delegation.ts
+function useSymmDelegation(params) {
+  const { symmioClient, chainId, address } = useSymmContext();
+  const accountAddress = params?.accountAddress ?? address;
+  const target = params?.target ?? DEFAULT_PARTY_B_ADDRESS[chainId];
+  const selectors = params?.selectors ?? ALL_TRADING_SELECTORS;
+  const enabled = (params?.enabled ?? true) && !!symmioClient && !!accountAddress && !!target && selectors.length > 0;
+  return useQuery({
+    queryKey: symmKeys.delegation(accountAddress, target, selectors, chainId),
+    enabled,
+    queryFn: async () => {
+      if (!symmioClient) throw new Error("symmio client not available");
+      if (!accountAddress) throw new Error("account address is required");
+      if (!target) throw new Error("delegation target is not configured");
+      const entries = await Promise.all(
+        selectors.map(async (selector) => [
+          selector,
+          await symmioClient.delegation.hasAccess({
+            account: accountAddress,
+            target,
+            selector
+          })
+        ])
+      );
+      const accessBySelector = Object.fromEntries(entries);
+      return {
+        hasAccess: selectors.every((selector) => accessBySelector[selector] === true),
+        account: accountAddress,
+        target,
+        selectors,
+        accessBySelector,
+        openAccess: accessBySelector[SEND_QUOTE_WITH_AFFILIATE_SELECTOR] ?? void 0,
+        closeAccess: accessBySelector[CLOSE_QUOTE_SELECTOR] ?? void 0
+      };
+    }
+  });
+}
+
+// src/react/cache.ts
+function invalidateBalances(qc) {
+  qc.invalidateQueries({ queryKey: ["symm", "balances"] });
+  qc.invalidateQueries({ queryKey: ["symm", "accountSummary"] });
+  qc.invalidateQueries({ queryKey: ["symm", "portfolio"] });
+}
+function invalidatePositions(qc) {
+  qc.invalidateQueries({ queryKey: ["symm", "positions"] });
+  qc.invalidateQueries({ queryKey: ["symm", "openOrders"] });
+  qc.invalidateQueries({ queryKey: ["symm", "tradeHistory"] });
+  qc.invalidateQueries({ queryKey: ["symm", "portfolio"] });
+}
+function invalidateOrders(qc) {
+  qc.invalidateQueries({ queryKey: ["symm", "openOrders"] });
+  qc.invalidateQueries({ queryKey: ["symm", "tpslOrders"] });
+  qc.invalidateQueries({ queryKey: ["symm", "twapOrders"] });
+}
+
+// src/react/hooks/use-symm-instant-trade.ts
+function useSymmInstantTrade(params) {
+  const {
+    symmioClient,
+    symmCoreClient,
+    chainId,
+    address,
+    refreshAuth
+  } = useSymmContext();
+  const queryClient = useQueryClient();
+  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,
+    target: defaultTarget,
+    selectors: defaultSelectors,
+    enabled: params?.enabled
+  });
+  const ensureReady = useMutation({
+    mutationFn: async (request) => {
+      if (!symmioClient) throw new Error("symmio client 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 = await refreshAuth(accountAddress);
+      if (!accessToken) {
+        throw new Error("failed to refresh instant-trading auth");
+      }
+      const accessStates = await Promise.all(
+        selectors.map(
+          (selector) => symmioClient.delegation.hasAccess({
+            account: accountAddress,
+            target,
+            selector
+          })
+        )
+      );
+      if (!accessStates.every(Boolean)) {
+        await symmioClient.delegation.delegateAccess({
+          account: accountAddress,
+          target,
+          selectors: [...selectors],
+          activate: true
+        });
+        await queryClient.invalidateQueries({
+          queryKey: symmKeys.delegation(accountAddress, target, selectors, chainId)
+        });
+      }
+      return {
+        accessToken,
+        accountAddress,
+        target,
+        selectors
+      };
+    }
+  });
+  const execute = useMutation({
+    mutationFn: async (request) => {
+      if (!symmCoreClient) throw new Error("symm-core client not available");
+      const setup = await ensureReady.mutateAsync({
+        accountAddress: request.accountAddress,
+        target: request.target,
+        selectors: request.selectors
+      });
+      return request.action({
+        symmCoreClient,
+        accessToken: setup.accessToken,
+        accountAddress: setup.accountAddress
+      });
+    },
+    onSuccess: (_data, variables) => {
+      if (variables.invalidatePositionsOnSuccess !== false) {
+        invalidatePositions(queryClient);
+      }
+    }
+  });
+  return {
+    delegation,
+    ensureReady,
+    execute
+  };
+}
 function useSymmAccounts(userAddress) {
   const { symmioClient } = useSymmContext();
   const queryClient = useQueryClient();
@@ -24489,26 +24715,6 @@ function useSymmApproval(params) {
     approve: approve2
   };
 }
-
-// src/react/cache.ts
-function invalidateBalances(qc) {
-  qc.invalidateQueries({ queryKey: ["symm", "balances"] });
-  qc.invalidateQueries({ queryKey: ["symm", "accountSummary"] });
-  qc.invalidateQueries({ queryKey: ["symm", "portfolio"] });
-}
-function invalidatePositions(qc) {
-  qc.invalidateQueries({ queryKey: ["symm", "positions"] });
-  qc.invalidateQueries({ queryKey: ["symm", "openOrders"] });
-  qc.invalidateQueries({ queryKey: ["symm", "tradeHistory"] });
-  qc.invalidateQueries({ queryKey: ["symm", "portfolio"] });
-}
-function invalidateOrders(qc) {
-  qc.invalidateQueries({ queryKey: ["symm", "openOrders"] });
-  qc.invalidateQueries({ queryKey: ["symm", "tpslOrders"] });
-  qc.invalidateQueries({ queryKey: ["symm", "twapOrders"] });
-}
-
-// src/react/hooks/use-symm-deposit.ts
 function useSymmDeposit() {
   const { symmioClient } = useSymmContext();
   const queryClient = useQueryClient();
@@ -24628,6 +24834,31 @@ function useSymmSignature(userAddress) {
     signTerms
   };
 }
+function useSymmAvailableMargin(params) {
+  const { symmioClient } = useSymmContext();
+  const { accountAddress, upnl } = params;
+  const query = useQuery({
+    queryKey: symmKeys.availableMargin(accountAddress, symmioClient?.chainId),
+    queryFn: async () => {
+      const stats = await symmioClient.stats.getPartyAStats(accountAddress);
+      const resolvedUpnl = upnl ?? 0n;
+      const availableForOrder = calculateAvailableForOrder(stats, resolvedUpnl);
+      return {
+        ...stats,
+        upnl: resolvedUpnl,
+        availableForOrder
+      };
+    },
+    enabled: !!symmioClient && !!accountAddress,
+    staleTime: 1e4
+  });
+  return {
+    availableForOrder: query.data?.availableForOrder ?? null,
+    stats: query.data ?? null,
+    isLoading: query.isLoading,
+    refetch: query.refetch
+  };
+}
 function useSymmBalances(params) {
   const { symmCoreClient, chainId: ctxChainId } = useSymmContext();
   const { userAddress, multiAccountAddress } = params;
@@ -24842,19 +25073,34 @@ function useSymmHedgerMarkets(params) {
   const chainId = params?.chainId ?? ctxChainId;
   const searchText = params?.searchText?.trim();
   const isEnabled = params?.enabled ?? true;
+  const request = {
+    ...params,
+    chainId,
+    searchText: searchText || void 0
+  };
   const query = useQuery({
-    queryKey: symmKeys.hedgerMarkets(chainId, searchText),
+    queryKey: symmKeys.hedgerMarkets(request),
     queryFn: async () => {
-      return symmCoreClient.markets.listHedger({
-        chainId,
-        searchText: searchText || void 0
-      });
+      const { enabled: _enabled, ...queryRequest } = request;
+      return symmCoreClient.markets.listSymmHedger(queryRequest);
     },
     enabled: !!symmCoreClient && isEnabled,
     staleTime: 3e4
   });
+  const data = query.data ?? null;
+  const emptyMap = /* @__PURE__ */ new Map();
+  const emptySymbolMap = /* @__PURE__ */ new Map();
   return {
-    markets: query.data?.data?.markets ?? [],
+    data,
+    markets: data?.markets ?? [],
+    rawMarkets: data?.rawMarkets ?? [],
+    filteredMarkets: data?.filteredMarkets ?? [],
+    allSymbols: data?.allSymbols ?? [],
+    filteredSymbols: data?.filteredSymbols ?? [],
+    marketsById: data?.marketsById ?? emptyMap,
+    marketsBySymbol: data?.marketsBySymbol ?? emptySymbolMap,
+    category: data?.category ?? params?.category ?? "all",
+    resolvedSearchText: data?.searchText ?? searchText ?? "",
     isLoading: query.isLoading,
     isFetching: query.isFetching,
     refetch: query.refetch
@@ -25987,6 +26233,6 @@ function getSymmErrorMessage(error) {
   return "An unexpected error occurred.";
 }
 
-export { SymmProvider, getSymmErrorMessage, symmKeys, useSymmAccounts, useSymmApproval, useSymmAuth, useSymmBalances, useSymmChartCandles, useSymmChartSelection, useSymmCollateral, useSymmContext, useSymmCoreClient, useSymmDeposit, useSymmFunding, useSymmHedgerMarkets, useSymmMarkets, useSymmNotifications, useSymmOpenOrders, useSymmPerformanceOverlays, useSymmPortfolio, useSymmPositions, useSymmSignature, useSymmTokenSelectionMetadata, useSymmTpsl, useSymmTrade, useSymmTradeHistory, useSymmTwap, useSymmWithdraw, useSymmWs, useSymmioClient };
+export { SymmProvider, getSymmErrorMessage, symmKeys, useSymmAccounts, useSymmApproval, useSymmAuth, useSymmAvailableMargin, useSymmBalances, useSymmChartCandles, useSymmChartSelection, useSymmCollateral, useSymmContext, useSymmCoreClient, useSymmDelegation, useSymmDeposit, useSymmFunding, useSymmHedgerMarkets, useSymmInstantTrade, useSymmMarkets, useSymmNotifications, useSymmOpenOrders, useSymmPerformanceOverlays, useSymmPortfolio, useSymmPositions, useSymmSignature, useSymmTokenSelectionMetadata, useSymmTpsl, useSymmTrade, useSymmTradeHistory, useSymmTwap, useSymmWithdraw, useSymmWs, useSymmioClient };
 //# sourceMappingURL=index.mjs.map
 //# sourceMappingURL=index.mjs.map