@pear-protocol/symmio-client 0.2.32 → 0.2.34

package/dist/react/index.mjs

@@ -614,7 +614,6 @@ async function login(chainId, params) {
 // src/react/auth.ts
 var TOKEN_STORAGE_PREFIX = "symm_access_token";
 var TOKEN_STORAGE_VERSION = 1;
-var tokenCache = /* @__PURE__ */ new Map();
 function cacheKey(address, chainId) {
   return `${address}:${chainId}`;
 }
@@ -652,20 +651,11 @@ function writeStoredToken(address, chainId, cached) {
   }
 }
 function getCachedToken(address, chainId) {
-  const cached = tokenCache.get(cacheKey(address, chainId));
-  if (cached && Date.now() < cached.expiresAt) {
-    return cached.token;
-  }
-  if (cached) {
-    tokenCache.delete(cacheKey(address, chainId));
-  }
   const stored = readStoredToken(address, chainId);
   if (!stored) return null;
-  tokenCache.set(cacheKey(address, chainId), stored);
   return stored.token;
 }
 function clearCachedToken(address, chainId) {
-  tokenCache.delete(cacheKey(address, chainId));
   if (typeof window !== "undefined") {
     window.localStorage.removeItem(storageKey(address, chainId));
   }
@@ -698,7 +688,6 @@ async function fetchAccessToken(walletClient, signerAddress, accountAddress, cha
     token: accessToken,
     expiresAt: expiresAt - 6e4
   };
-  tokenCache.set(cacheKey(accountAddress, chainId), cachedToken);
   writeStoredToken(accountAddress, chainId, cachedToken);
   return accessToken;
 }
@@ -735,13 +724,31 @@ var useSymmAuthStore = create((set, get) => ({
 }));
 
 // src/react/hooks/use-symm-auth.ts
+function logSymmAuth(event, details) {
+  if (typeof window === "undefined") {
+    return;
+  }
+  console.debug("[symm-auth]", event, details ?? {});
+}
+function extractSubaccountAddresses(summary) {
+  const accounts = summary?.data?.accounts;
+  if (!Array.isArray(accounts)) {
+    return [];
+  }
+  return accounts.flatMap((account) => {
+    const accountAddress = account.accountAddress ?? account.address;
+    return accountAddress ? [accountAddress] : [];
+  });
+}
 function useSymmAuth(params) {
-  const ctx = useSymmContext();
+  const context = useSymmContext();
+  const ctx = context;
+  const { symmCoreClient } = context;
   const address = params?.address ?? ctx.address;
   const chainId = params?.chainId ?? ctx.chainId ?? 42161;
   const walletClient = params?.walletClient ?? ctx.walletClient;
   const siweDomain = params?.siweDomain;
-  const accessToken = useSymmAuthStore((state) => {
+  const token = useSymmAuthStore((state) => {
     if (address) {
       return state.tokensByKey[symmAuthTokenKey(address, chainId)] ?? null;
     }
@@ -752,36 +759,65 @@ function useSymmAuth(params) {
   const clearToken = useSymmAuthStore((state) => state.clearToken);
   const previousAddressRef = useRef(address);
   const previousChainIdRef = useRef(chainId);
+  const refreshAuthRef = useRef(async () => null);
   const refreshAuth = useCallback(
-    async (accountAddress) => {
+    async (accountAddress, options) => {
       if (!walletClient || !address) return null;
       const resolvedAccountAddress = accountAddress ?? address;
-      const inMemory = getToken(resolvedAccountAddress, chainId);
-      if (inMemory) {
-        return inMemory;
-      }
-      const cached = getCachedToken(resolvedAccountAddress, chainId);
-      if (cached) {
-        setToken(resolvedAccountAddress, chainId, cached);
-        return cached;
+      if (!options?.force) {
+        const inStore = getToken(resolvedAccountAddress, chainId);
+        if (inStore) {
+          logSymmAuth("refresh:store-hit", {
+            accountAddress: resolvedAccountAddress,
+            chainId
+          });
+          return inStore;
+        }
+        const cached = getCachedToken(resolvedAccountAddress, chainId);
+        if (cached) {
+          setToken(resolvedAccountAddress, chainId, cached);
+          logSymmAuth("refresh:local-storage-hit", {
+            accountAddress: resolvedAccountAddress,
+            chainId
+          });
+          return cached;
+        }
       }
       try {
-        const token = await fetchAccessToken(
+        logSymmAuth("refresh:fetch-start", {
+          signerAddress: address,
+          accountAddress: resolvedAccountAddress,
+          chainId,
+          force: options?.force ?? false
+        });
+        const token2 = await fetchAccessToken(
           walletClient,
           address,
           resolvedAccountAddress,
           chainId,
           siweDomain
         );
-        setToken(resolvedAccountAddress, chainId, token);
-        return token;
-      } catch {
+        setToken(resolvedAccountAddress, chainId, token2);
+        logSymmAuth("refresh:fetch-success", {
+          signerAddress: address,
+          accountAddress: resolvedAccountAddress,
+          chainId
+        });
+        return token2;
+      } catch (error) {
         clearToken(resolvedAccountAddress, chainId);
+        logSymmAuth("refresh:fetch-failed", {
+          signerAddress: address,
+          accountAddress: resolvedAccountAddress,
+          chainId,
+          error: error instanceof Error ? error.message : String(error)
+        });
         return null;
       }
     },
     [walletClient, address, chainId, siweDomain, getToken, setToken, clearToken]
   );
+  refreshAuthRef.current = refreshAuth;
   const clearAuth = useCallback(() => {
     if (address) {
       clearCachedToken(address, chainId);
@@ -793,26 +829,67 @@ function useSymmAuth(params) {
     const previousChainId = previousChainIdRef.current;
     const addressChanged = previousAddress !== address;
     const chainChanged = previousChainId !== chainId;
+    let cancelled = false;
     previousAddressRef.current = address;
     previousChainIdRef.current = chainId;
-    if (!address || !walletClient) {
+    if (!address) {
       return;
     }
+    const userAddress = address;
     if (previousAddress && (addressChanged || chainChanged)) {
       clearCachedToken(previousAddress, previousChainId);
       clearToken(previousAddress, previousChainId);
     }
-    const cached = getCachedToken(address, chainId);
-    if (cached) {
-      setToken(address, chainId, cached);
-    } else {
-      clearToken(address, chainId);
+    async function bootstrapAuth() {
+      let targets = [userAddress];
+      if (symmCoreClient) {
+        try {
+          const summary = await symmCoreClient.accounts.getSummary({
+            userAddress,
+            chainId
+          });
+          const subaccounts = extractSubaccountAddresses(summary);
+          if (subaccounts.length > 0) {
+            targets = subaccounts;
+          }
+          logSymmAuth("bootstrap:subaccounts-resolved", {
+            userAddress,
+            chainId,
+            subaccounts
+          });
+        } catch (error) {
+          logSymmAuth("bootstrap:subaccounts-failed", {
+            userAddress,
+            chainId,
+            error: error instanceof Error ? error.message : String(error)
+          });
+        }
+      }
+      const uniqueTargets = [...new Set(targets)].filter(
+        (accountAddress) => !!accountAddress
+      );
+      logSymmAuth("bootstrap:start", {
+        userAddress,
+        chainId,
+        targets: uniqueTargets,
+        walletReady: !!walletClient
+      });
+      for (const accountAddress of uniqueTargets) {
+        if (cancelled) {
+          return;
+        }
+        await refreshAuthRef.current(accountAddress);
+      }
     }
-  }, [address, walletClient, chainId, setToken, clearToken]);
+    void bootstrapAuth();
+    return () => {
+      cancelled = true;
+    };
+  }, [address, walletClient, chainId, clearToken, symmCoreClient]);
   return {
-    accessToken,
-    authToken: accessToken,
-    isAuthenticated: !!accessToken,
+    accessToken: token,
+    authToken: token,
+    isAuthenticated: !!token,
     refresh: refreshAuth,
     refreshAuth,
     clear: clearAuth
@@ -1921,10 +1998,12 @@ function useSymmCloseOrder(options) {
       if (!symmCoreClient) {
         throw new Error("symm-core client not available");
       }
+      const typedRequest = request;
+      const resolvedAccountAddress = typedRequest.accountAddress ?? address;
       return symmCoreClient.orders.close(request.id, {
         kind: request.kind,
         type: request.type,
-        authToken: request.authToken ?? (address ? useSymmAuthStore.getState().getToken(address, chainId) ?? void 0 : void 0)
+        authToken: request.authToken ?? (resolvedAccountAddress ? useSymmAuthStore.getState().getToken(resolvedAccountAddress, chainId) ?? void 0 : void 0)
       });
     }
   });
@@ -25034,14 +25113,42 @@ function useSymmBalances(params) {
     enabled: internalEnabled && (params.query?.enabled ?? true)
   });
 }
-function useResolveTradeAuthToken() {
+function logTradeAuth(event, details) {
+  if (typeof window === "undefined") {
+    return;
+  }
+  console.debug("[symm-trade]", event, details ?? {});
+}
+function splitTradeHookArgs(paramsOrOptions, options) {
+  if (paramsOrOptions && "mutation" in paramsOrOptions) {
+    return {
+      params: {},
+      options: paramsOrOptions
+    };
+  }
+  return {
+    params: paramsOrOptions ?? {},
+    options
+  };
+}
+function useResolveTradeAuthToken(params = {}) {
   const context = useSymmContext();
-  const { address, chainId } = context;
-  const { refreshAuth } = useSymmAuth({ address, chainId });
+  const address = params.address ?? context.address;
+  const chainId = params.chainId ?? context.chainId;
+  const { refreshAuth } = useSymmAuth({
+    address,
+    chainId,
+    walletClient: params.walletClient,
+    siweDomain: params.siweDomain
+  });
   const refreshAuthFromContext = context.refreshAuth;
   return useCallback(
     async (providedAuthToken, accountAddress) => {
       if (providedAuthToken) {
+        logTradeAuth("resolve-auth:provided", {
+          accountAddress,
+          chainId
+        });
         return providedAuthToken;
       }
       const resolvedAccountAddress = accountAddress ?? address;
@@ -25050,11 +25157,23 @@ function useResolveTradeAuthToken() {
       }
       const inMemoryToken = useSymmAuthStore.getState().getToken(resolvedAccountAddress, chainId);
       if (inMemoryToken) {
+        logTradeAuth("resolve-auth:store-hit", {
+          accountAddress: resolvedAccountAddress,
+          chainId
+        });
         return inMemoryToken;
       }
       if (refreshAuthFromContext) {
+        logTradeAuth("resolve-auth:context-refresh", {
+          accountAddress: resolvedAccountAddress,
+          chainId
+        });
         return refreshAuthFromContext(resolvedAccountAddress);
       }
+      logTradeAuth("resolve-auth:hook-refresh", {
+        accountAddress: resolvedAccountAddress,
+        chainId
+      });
       return refreshAuth(resolvedAccountAddress);
     },
     [address, chainId, refreshAuth, refreshAuthFromContext]
@@ -25075,10 +25194,11 @@ function useSymmOpenBasketMutation(options) {
     }
   });
 }
-function useSymmClosePositionMutation(options) {
+function useSymmClosePositionMutation(paramsOrOptions, maybeOptions) {
   const { symmCoreClient } = useSymmContext();
   const queryClient = useQueryClient();
-  const resolveAuthToken = useResolveTradeAuthToken();
+  const { params, options } = splitTradeHookArgs(paramsOrOptions, maybeOptions);
+  const resolveAuthToken = useResolveTradeAuthToken(params);
   return useMutation({
     ...withSymmMutationConfig(options?.mutation, {
       onSuccess: () => {
@@ -25132,10 +25252,11 @@ function useSymmCancelOpenMutation(options) {
     }
   });
 }
-function useSymmUpdatePositionMutation(options) {
+function useSymmUpdatePositionMutation(paramsOrOptions, maybeOptions) {
   const { symmCoreClient } = useSymmContext();
   const queryClient = useQueryClient();
-  const resolveAuthToken = useResolveTradeAuthToken();
+  const { params, options } = splitTradeHookArgs(paramsOrOptions, maybeOptions);
+  const resolveAuthToken = useResolveTradeAuthToken(params);
   return useMutation({
     ...withSymmMutationConfig(options?.mutation, {
       onSuccess: () => {