@pear-protocol/symmio-client 0.2.40 → 0.2.43

package/dist/react/index.js

@@ -6,6 +6,7 @@ var symmCore = require('@pear-protocol/symm-core');
 var zustand = require('zustand');
 var jsxRuntime = require('react/jsx-runtime');
 var reactQuery = require('@tanstack/react-query');
+var siwe = require('siwe');
 var viem = require('viem');
 
 var SymmContext = react.createContext(null);
@@ -492,6 +493,7 @@ function useBinanceWs(params) {
 function SymmProvider({
   chainId = 42161,
   address,
+  walletClient,
   symmCoreConfig = {
     apiUrl: "https://nginx-server-staging.up.railway.app",
     wsUrl: "wss://nginx-server-staging.up.railway.app"
@@ -511,9 +513,10 @@ function SymmProvider({
       symmCoreClient,
       chainId,
       address,
+      walletClient,
       symmioConfig
     }),
-    [symmCoreClient, chainId, address, symmioConfig]
+    [symmCoreClient, chainId, address, walletClient, symmioConfig]
   );
   useBinanceWs({
     symmCoreClient,
@@ -556,19 +559,17 @@ function createSiweMessage(params) {
   const expirationTime = new Date(
     Date.now() + 30 * 24 * 60 * 60 * 1e3
   ).toISOString();
-  const message = [
-    `${params.domain} wants you to sign in with your Ethereum account:`,
-    params.address,
-    "",
-    params.statement,
-    "",
-    `URI: ${params.uri}`,
-    `Version: ${version}`,
-    `Chain ID: ${params.chainId}`,
-    `Nonce: ${params.nonce}`,
-    `Issued At: ${issuedAt}`,
-    `Expiration Time: ${expirationTime}`
-  ].join("\n");
+  const message = new siwe.SiweMessage({
+    domain: params.domain,
+    address: params.address,
+    statement: params.statement,
+    chainId: params.chainId,
+    nonce: params.nonce,
+    version,
+    uri: params.uri,
+    issuedAt,
+    expirationTime
+  }).prepareMessage();
   return { message, issuedAt, expirationTime };
 }
 async function getNonce(chainId, subAccount) {
@@ -636,7 +637,7 @@ function cacheKey(address, chainId) {
 function storageKey(address, chainId) {
   return `${TOKEN_STORAGE_PREFIX}:${TOKEN_STORAGE_VERSION}:${cacheKey(address, chainId)}`;
 }
-function readStoredToken(address, chainId) {
+function getCachedTokenEntry(address, chainId) {
   if (typeof window === "undefined") return null;
   try {
     const raw = window.localStorage.getItem(storageKey(address, chainId));
@@ -666,17 +667,12 @@ function writeStoredToken(address, chainId, cached) {
   } catch {
   }
 }
-function getCachedToken(address, chainId) {
-  const stored = readStoredToken(address, chainId);
-  if (!stored) return null;
-  return stored.token;
-}
 function clearCachedToken(address, chainId) {
   if (typeof window !== "undefined") {
     window.localStorage.removeItem(storageKey(address, chainId));
   }
 }
-async function fetchAccessToken(walletClient, signerAddress, accountAddress, chainId, domain) {
+async function fetchAccessTokenEntry(walletClient, signerAddress, accountAddress, chainId, domain) {
   const resolvedDomain = domain ?? (typeof window !== "undefined" ? window.location.host : "localhost");
   const hedgerLoginUrl = new URL("login", getHedgerBaseUrl(chainId)).href;
   const nonce = await getNonce(chainId, accountAddress);
@@ -705,39 +701,114 @@ async function fetchAccessToken(walletClient, signerAddress, accountAddress, cha
     expiresAt: expiresAt - 6e4
   };
   writeStoredToken(accountAddress, chainId, cachedToken);
-  return accessToken;
+  return cachedToken;
 }
-function symmAuthTokenKey(address, chainId) {
-  return `${address.toLowerCase()}:${chainId}`;
+
+// src/react/query-keys.ts
+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, upnl) => ["symm", "accountData", address, chainId, upnl],
+  signature: (address, chainId) => ["symm", "signature", address, chainId],
+  auth: (accountAddress, chainId) => ["symm", "auth", accountAddress, chainId],
+  approval: (owner, spender, chainId, token) => ["symm", "approval", owner, spender, chainId, token],
+  balances: (address, chainId) => ["symm", "balances", address, chainId],
+  positions: (params) => ["symm", "positions", params],
+  openOrders: (params) => ["symm", "openOrders", params],
+  tradeHistory: (params) => ["symm", "tradeHistory", params],
+  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: (params) => ["symm", "portfolio", params],
+  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]
+};
+
+// src/react/auth-cache.ts
+function getAuthQueryData(queryClient, accountAddress, chainId) {
+  return queryClient.getQueryData(symmKeys.auth(accountAddress, chainId)) ?? null;
 }
-var useSymmAuthStore = zustand.create((set, get) => ({
-  tokensByKey: {},
-  setToken: (address, chainId, token) => {
-    const key = symmAuthTokenKey(address, chainId);
-    set((state) => ({
-      tokensByKey: {
-        ...state.tokensByKey,
-        [key]: token
-      }
-    }));
-  },
-  getToken: (address, chainId) => {
-    const key = symmAuthTokenKey(address, chainId);
-    return get().tokensByKey[key] ?? null;
-  },
-  clearToken: (address, chainId) => {
-    const key = symmAuthTokenKey(address, chainId);
-    set((state) => {
-      if (!(key in state.tokensByKey)) return state;
-      const next = { ...state.tokensByKey };
-      delete next[key];
-      return { tokensByKey: next };
-    });
-  },
-  clearAll: () => {
-    set({ tokensByKey: {} });
+function setAuthQueryData(queryClient, accountAddress, chainId, entry) {
+  queryClient.setQueryData(symmKeys.auth(accountAddress, chainId), entry);
+}
+function clearAuthQueryData(queryClient, accountAddress, chainId) {
+  queryClient.removeQueries({
+    queryKey: symmKeys.auth(accountAddress, chainId),
+    exact: true
+  });
+}
+function clearPersistedAuthState(accountAddress, chainId) {
+  clearCachedToken(accountAddress, chainId);
+}
+function getAuthTokenFromRuntimeCache(queryClient, accountAddress, chainId) {
+  const inQuery = getAuthQueryData(queryClient, accountAddress, chainId);
+  if (inQuery && inQuery.expiresAt > Date.now()) {
+    return inQuery.token;
   }
-}));
+  const persisted = getCachedTokenEntry(accountAddress, chainId);
+  if (!persisted) {
+    return null;
+  }
+  setAuthQueryData(queryClient, accountAddress, chainId, persisted);
+  return persisted.token;
+}
+async function resolveAuthTokenEntry({
+  queryClient,
+  walletClient,
+  signerAddress,
+  accountAddress,
+  chainId,
+  siweDomain,
+  force = false
+}) {
+  if (!walletClient || !signerAddress || !accountAddress) {
+    return null;
+  }
+  if (!force) {
+    const inQuery = getAuthQueryData(queryClient, accountAddress, chainId);
+    if (inQuery && inQuery.expiresAt > Date.now()) {
+      return inQuery;
+    }
+    const persisted = getCachedTokenEntry(accountAddress, chainId);
+    if (persisted) {
+      setAuthQueryData(queryClient, accountAddress, chainId, persisted);
+      return persisted;
+    }
+  }
+  const fresh = await fetchAccessTokenEntry(
+    walletClient,
+    signerAddress,
+    accountAddress,
+    chainId,
+    siweDomain
+  );
+  setAuthQueryData(queryClient, accountAddress, chainId, fresh);
+  return fresh;
+}
+function clearAuthState(queryClient, accountAddress, chainId) {
+  clearPersistedAuthState(accountAddress, chainId);
+  clearAuthQueryData(queryClient, accountAddress, chainId);
+}
 
 // src/react/hooks/use-symm-auth.ts
 function logSymmAuth(event, details) {
@@ -746,59 +817,26 @@ function logSymmAuth(event, details) {
   }
   console.log("[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 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 queryClient = reactQuery.useQueryClient();
+  const address = params?.address ?? context.address;
+  const chainId = params?.chainId ?? context.chainId ?? 42161;
+  const walletClient = params?.walletClient ?? context.walletClient;
   const siweDomain = params?.siweDomain;
-  const token = useSymmAuthStore((state) => {
-    if (address) {
-      return state.tokensByKey[symmAuthTokenKey(address, chainId)] ?? null;
-    }
-    return ctx.accessToken ?? ctx.authToken ?? null;
-  });
-  const setToken = useSymmAuthStore((state) => state.setToken);
-  const getToken = useSymmAuthStore((state) => state.getToken);
-  const clearToken = useSymmAuthStore((state) => state.clearToken);
-  const previousAddressRef = react.useRef(address);
-  const previousChainIdRef = react.useRef(chainId);
-  const refreshAuthRef = react.useRef(async () => null);
+  const activeAccountAddress = params?.activeAccountAddress;
+  const canBootstrap = !!walletClient && !!address && !!activeAccountAddress;
   const refreshAuth = react.useCallback(
     async (accountAddress, options) => {
-      if (!walletClient || !address) return null;
-      const resolvedAccountAddress = accountAddress ?? address;
-      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;
-        }
+      const resolvedAccountAddress = accountAddress ?? activeAccountAddress;
+      if (!resolvedAccountAddress) {
+        logSymmAuth("refresh:skip-no-active-account", {
+          signerAddress: address,
+          chainId
+        });
+        return null;
       }
+      if (!walletClient || !address) return null;
       try {
         logSymmAuth("refresh:fetch-start", {
           signerAddress: address,
@@ -806,14 +844,16 @@ function useSymmAuth(params) {
           chainId,
           force: options?.force ?? false
         });
-        const token2 = await fetchAccessToken(
+        const tokenEntry = await resolveAuthTokenEntry({
+          queryClient,
           walletClient,
-          address,
-          resolvedAccountAddress,
+          signerAddress: address,
+          accountAddress: resolvedAccountAddress,
           chainId,
-          siweDomain
-        );
-        setToken(resolvedAccountAddress, chainId, token2);
+          siweDomain,
+          force: options?.force
+        });
+        const token2 = tokenEntry?.token ?? null;
         logSymmAuth("refresh:fetch-success", {
           signerAddress: address,
           accountAddress: resolvedAccountAddress,
@@ -821,7 +861,7 @@ function useSymmAuth(params) {
         });
         return token2;
       } catch (error) {
-        clearToken(resolvedAccountAddress, chainId);
+        clearPersistedAuthState(resolvedAccountAddress, chainId);
         logSymmAuth("refresh:fetch-failed", {
           signerAddress: address,
           accountAddress: resolvedAccountAddress,
@@ -831,104 +871,49 @@ function useSymmAuth(params) {
         return null;
       }
     },
-    [walletClient, address, chainId, siweDomain, getToken, setToken, clearToken]
-  );
-  refreshAuthRef.current = refreshAuth;
-  const clearAuth = react.useCallback(() => {
-    if (address) {
-      clearCachedToken(address, chainId);
-      clearToken(address, chainId);
-    }
-  }, [address, chainId, clearToken]);
-  react.useEffect(() => {
-    const previousAddress = previousAddressRef.current;
-    const previousChainId = previousChainIdRef.current;
-    const addressChanged = previousAddress !== address;
-    const chainChanged = previousChainId !== chainId;
-    let cancelled = false;
-    previousAddressRef.current = address;
-    previousChainIdRef.current = chainId;
-    logSymmAuth("bootstrap:dependencies", {
+    [
+      walletClient,
       address,
+      activeAccountAddress,
       chainId,
-      hasWalletClient: !!walletClient,
-      hasSymmCoreClient: !!symmCoreClient,
-      hasRefreshAuth: !!refreshAuthRef.current,
-      addressChanged,
-      chainChanged,
-      previousAddress,
-      previousChainId
-    });
-    if (!address) {
-      logSymmAuth("bootstrap:skip-no-address", {
-        chainId,
-        hasWalletClient: !!walletClient,
-        hasSymmCoreClient: !!symmCoreClient
-      });
-      return;
-    }
-    const userAddress = address;
-    if (previousAddress && (addressChanged || chainChanged)) {
-      clearCachedToken(previousAddress, previousChainId);
-      clearToken(previousAddress, previousChainId);
-    }
-    async function bootstrapAuth() {
-      logSymmAuth("bootstrap:run", {
-        userAddress,
-        chainId,
-        hasWalletClient: !!walletClient,
-        hasSymmCoreClient: !!symmCoreClient,
-        hasRefreshAuth: !!refreshAuthRef.current
-      });
-      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,
+      siweDomain,
+      queryClient
+    ]
+  );
+  const authQuery = reactQuery.useQuery({
+    queryKey: symmKeys.auth(activeAccountAddress, chainId),
+    queryFn: async () => {
+      const tokenEntry = await resolveAuthTokenEntry({
+        queryClient,
+        walletClient,
+        signerAddress: address,
+        accountAddress: activeAccountAddress,
         chainId,
-        targets: uniqueTargets,
-        walletReady: !!walletClient
+        siweDomain
       });
-      for (const accountAddress of uniqueTargets) {
-        if (cancelled) {
-          return;
-        }
-        await refreshAuthRef.current(accountAddress);
+      if (!tokenEntry) {
+        return null;
       }
+      return tokenEntry;
+    },
+    enabled: canBootstrap,
+    retry: false,
+    refetchOnWindowFocus: false,
+    refetchOnReconnect: false
+  });
+  const clearAuth = react.useCallback(() => {
+    if (activeAccountAddress) {
+      clearAuthState(queryClient, activeAccountAddress, chainId);
     }
-    bootstrapAuth();
-    return () => {
-      cancelled = true;
-    };
-  }, [address, walletClient, chainId, symmCoreClient]);
+  }, [activeAccountAddress, chainId, queryClient]);
+  const token = authQuery.data?.token ?? null;
   return {
     accessToken: token,
     authToken: token,
     isAuthenticated: !!token,
+    isLoading: authQuery.isLoading,
+    isFetching: authQuery.isFetching,
+    error: authQuery.error,
     refresh: refreshAuth,
     refreshAuth,
     clear: clearAuth
@@ -1420,6 +1405,30 @@ function prepareDelegateAccess(multiAccount, account, params) {
     config: { account, to: multiAccount, data, value: 0n }
   };
 }
+function prepareProposeRevoke(multiAccount, account, params) {
+  const data = viem.encodeFunctionData({
+    abi: MultiAccountABI,
+    functionName: "proposeToRevokeAccesses",
+    args: [params.account, params.target, params.selectors]
+  });
+  return {
+    functionName: "proposeToRevokeAccesses",
+    args: [params.account, params.target, params.selectors],
+    config: { account, to: multiAccount, data, value: 0n }
+  };
+}
+function prepareRevokeAccess(multiAccount, account, params) {
+  const data = viem.encodeFunctionData({
+    abi: MultiAccountABI,
+    functionName: "revokeAccesses",
+    args: [params.account, params.target, params.selectors]
+  });
+  return {
+    functionName: "revokeAccesses",
+    args: [params.account, params.target, params.selectors],
+    config: { account, to: multiAccount, data, value: 0n }
+  };
+}
 async function delegateAccess(walletClient, publicClient, multiAccount, params) {
   const account = walletClient.account?.address;
   if (!account) throw new Error("Wallet client has no account");
@@ -1431,6 +1440,28 @@ async function delegateAccess(walletClient, publicClient, multiAccount, params)
     chain: walletClient.chain
   });
 }
+async function proposeRevoke(walletClient, publicClient, multiAccount, params) {
+  const account = walletClient.account?.address;
+  if (!account) throw new Error("Wallet client has no account");
+  const prepared = prepareProposeRevoke(multiAccount, account, params);
+  const gas = await publicClient.estimateGas(prepared.config);
+  return walletClient.sendTransaction({
+    ...prepared.config,
+    gas: calculateGasMargin(gas),
+    chain: walletClient.chain
+  });
+}
+async function revokeAccess(walletClient, publicClient, multiAccount, params) {
+  const account = walletClient.account?.address;
+  if (!account) throw new Error("Wallet client has no account");
+  const prepared = prepareRevokeAccess(multiAccount, account, params);
+  const gas = await publicClient.estimateGas(prepared.config);
+  return walletClient.sendTransaction({
+    ...prepared.config,
+    gas: calculateGasMargin(gas),
+    chain: walletClient.chain
+  });
+}
 async function hasDelegatedAccess(publicClient, multiAccount, params) {
   validateAddress(params.account, "subAccount");
   validateAddress(params.target, "target");
@@ -1443,52 +1474,61 @@ async function hasDelegatedAccess(publicClient, multiAccount, params) {
   return Boolean(result);
 }
 
-// src/react/query-keys.ts
-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, upnl) => ["symm", "accountData", address, chainId, upnl],
-  signature: (address, chainId) => ["symm", "signature", address, chainId],
-  approval: (owner, spender, chainId, token) => ["symm", "approval", owner, spender, chainId, token],
-  balances: (address, chainId) => ["symm", "balances", address, chainId],
-  positions: (params) => ["symm", "positions", params],
-  openOrders: (params) => ["symm", "openOrders", params],
-  tradeHistory: (params) => ["symm", "tradeHistory", params],
-  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: (params) => ["symm", "portfolio", params],
-  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]
-};
+// src/react/mutation-config.ts
+function withSymmMutationConfig(config, internal) {
+  const {
+    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-delegation.ts
-function useSymmDelegation(params) {
+function useResolvedDelegationConfig() {
   const { chainId, address, symmioConfig } = useSymmContext();
   const multiAccount = symmioConfig?.multiAccountAddress ?? getAddress(MULTI_ACCOUNT_ADDRESS, chainId, "MultiAccount");
+  const target = DEFAULT_PARTY_B_ADDRESS[chainId];
+  return {
+    address,
+    chainId,
+    defaultTarget: target,
+    multiAccount
+  };
+}
+function resolveDelegationRequest(variables, defaultTarget, defaultSelectors) {
+  const target = variables.target ?? defaultTarget;
+  const selectors = variables.selectors ?? defaultSelectors ?? ALL_TRADING_SELECTORS;
+  if (!target) throw new Error("delegation target is not configured");
+  if (selectors.length === 0) {
+    throw new Error("at least one delegation selector is required");
+  }
+  return {
+    account: variables.account,
+    selectors: [...selectors],
+    target
+  };
+}
+function useSymmDelegation(params) {
+  const { chainId, address, multiAccount, defaultTarget } = useResolvedDelegationConfig();
   const publicClient = params?.publicClient;
   const accountAddress = params?.accountAddress ?? address;
-  const target = params?.target ?? DEFAULT_PARTY_B_ADDRESS[chainId];
+  const target = params?.target ?? defaultTarget;
   const selectors = params?.selectors ?? ALL_TRADING_SELECTORS;
   const consumerEnabled = params?.query?.enabled ?? params?.enabled ?? true;
   const internalEnabled = !!publicClient && !!accountAddress && !!target && selectors.length > 0;
@@ -1523,6 +1563,110 @@ function useSymmDelegation(params) {
     }
   });
 }
+function useSymmDelegateAccessMutation(params = {}, options) {
+  const queryClient = reactQuery.useQueryClient();
+  const { chainId, multiAccount, defaultTarget } = useResolvedDelegationConfig();
+  const { publicClient, walletClient } = params;
+  return reactQuery.useMutation({
+    ...withSymmMutationConfig(options?.mutation, {
+      onSuccess: async (_data, variables) => {
+        const request = resolveDelegationRequest(
+          variables,
+          params.target ?? defaultTarget,
+          params.selectors
+        );
+        await queryClient.invalidateQueries({
+          queryKey: symmKeys.delegation(
+            request.account,
+            request.target,
+            request.selectors,
+            chainId
+          )
+        });
+      }
+    }),
+    mutationFn: async (variables) => {
+      if (!walletClient || !publicClient) throw new Error("Clients not available");
+      const request = resolveDelegationRequest(
+        variables,
+        params.target ?? defaultTarget,
+        params.selectors
+      );
+      return delegateAccess(walletClient, publicClient, multiAccount, {
+        account: request.account,
+        target: request.target,
+        selectors: request.selectors,
+        activate: true
+      });
+    }
+  });
+}
+function useSymmProposeRevokeDelegationMutation(params = {}, options) {
+  const queryClient = reactQuery.useQueryClient();
+  const { chainId, multiAccount, defaultTarget } = useResolvedDelegationConfig();
+  const { publicClient, walletClient } = params;
+  return reactQuery.useMutation({
+    ...withSymmMutationConfig(options?.mutation, {
+      onSuccess: async (_data, variables) => {
+        const request = resolveDelegationRequest(
+          variables,
+          params.target ?? defaultTarget,
+          params.selectors
+        );
+        await queryClient.invalidateQueries({
+          queryKey: symmKeys.delegation(
+            request.account,
+            request.target,
+            request.selectors,
+            chainId
+          )
+        });
+      }
+    }),
+    mutationFn: async (variables) => {
+      if (!walletClient || !publicClient) throw new Error("Clients not available");
+      const request = resolveDelegationRequest(
+        variables,
+        params.target ?? defaultTarget,
+        params.selectors
+      );
+      return proposeRevoke(walletClient, publicClient, multiAccount, request);
+    }
+  });
+}
+function useSymmRevokeDelegationMutation(params = {}, options) {
+  const queryClient = reactQuery.useQueryClient();
+  const { chainId, multiAccount, defaultTarget } = useResolvedDelegationConfig();
+  const { publicClient, walletClient } = params;
+  return reactQuery.useMutation({
+    ...withSymmMutationConfig(options?.mutation, {
+      onSuccess: async (_data, variables) => {
+        const request = resolveDelegationRequest(
+          variables,
+          params.target ?? defaultTarget,
+          params.selectors
+        );
+        await queryClient.invalidateQueries({
+          queryKey: symmKeys.delegation(
+            request.account,
+            request.target,
+            request.selectors,
+            chainId
+          )
+        });
+      }
+    }),
+    mutationFn: async (variables) => {
+      if (!walletClient || !publicClient) throw new Error("Clients not available");
+      const request = resolveDelegationRequest(
+        variables,
+        params.target ?? defaultTarget,
+        params.selectors
+      );
+      return revokeAccess(walletClient, publicClient, multiAccount, request);
+    }
+  });
+}
 
 // src/react/cache.ts
 function invalidateBalances(qc) {
@@ -1544,31 +1688,6 @@ function invalidateOrders(qc) {
   qc.invalidateQueries({ queryKey: ["symm", "triggerOrders"] });
 }
 
-// src/react/mutation-config.ts
-function withSymmMutationConfig(config, internal) {
-  const {
-    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();
@@ -1598,7 +1717,7 @@ async function ensureInstantTradeReady(deps, queryClient, request) {
   if (selectors.length === 0) {
     throw new Error("at least one delegation selector is required");
   }
-  const accessToken = useSymmAuthStore.getState().getToken(accountAddress, chainId);
+  const accessToken = getAuthTokenFromRuntimeCache(queryClient, accountAddress, chainId);
   if (!accessToken) {
     throw new Error("auth token is required for instant trading");
   }
@@ -2011,7 +2130,7 @@ function useSymmCancelClose(options) {
       }
       const resolvedAccountAddress = accountAddress ?? address;
       const resolvedChainId = overrideChainId ?? chainId;
-      const resolvedAuthToken = authToken ?? (resolvedAccountAddress ? useSymmAuthStore.getState().getToken(resolvedAccountAddress, resolvedChainId) : null);
+      const resolvedAuthToken = authToken ?? (resolvedAccountAddress ? getAuthTokenFromRuntimeCache(queryClient, resolvedAccountAddress, resolvedChainId) : null);
       if (!resolvedAuthToken) {
         throw new Error("auth token is required to cancel a pending close");
       }
@@ -2042,7 +2161,7 @@ function useSymmCloseOrder(options) {
       return symmCoreClient.orders.close(request.id, {
         kind: request.kind,
         type: request.type,
-        authToken: request.authToken ?? (resolvedAccountAddress ? useSymmAuthStore.getState().getToken(resolvedAccountAddress, chainId) ?? void 0 : void 0)
+        authToken: request.authToken ?? (resolvedAccountAddress ? getAuthTokenFromRuntimeCache(queryClient, resolvedAccountAddress, chainId) ?? void 0 : void 0)
       });
     }
   });
@@ -25172,6 +25291,7 @@ function splitTradeHookArgs(paramsOrOptions, options) {
 }
 function useResolveTradeAuthToken(params = {}) {
   const context = useSymmContext();
+  const queryClient = reactQuery.useQueryClient();
   const address = params.address ?? context.address;
   const chainId = params.chainId ?? context.chainId;
   const { refreshAuth } = useSymmAuth({
@@ -25194,7 +25314,11 @@ function useResolveTradeAuthToken(params = {}) {
       if (!resolvedAccountAddress) {
         return null;
       }
-      const inMemoryToken = useSymmAuthStore.getState().getToken(resolvedAccountAddress, chainId);
+      const inMemoryToken = getAuthTokenFromRuntimeCache(
+        queryClient,
+        resolvedAccountAddress,
+        chainId
+      );
       if (inMemoryToken) {
         logTradeAuth("resolve-auth:store-hit", {
           accountAddress: resolvedAccountAddress,
@@ -25215,7 +25339,7 @@ function useResolveTradeAuthToken(params = {}) {
       });
       return refreshAuth(resolvedAccountAddress);
     },
-    [address, chainId, refreshAuth, refreshAuthFromContext]
+    [address, chainId, queryClient, refreshAuth, refreshAuthFromContext]
   );
 }
 function useSymmOpenBasketMutation(options) {
@@ -25954,6 +26078,7 @@ function useSymmPendingInstantOpens(params) {
     symmCoreClient,
     chainId: ctxChainId
   } = useSymmContext();
+  const queryClient = reactQuery.useQueryClient();
   const { accountAddress, authToken: providedAuthToken } = params;
   const chainId = params.chainId ?? ctxChainId;
   const internalEnabled = !!symmCoreClient && !!accountAddress;
@@ -25961,7 +26086,7 @@ function useSymmPendingInstantOpens(params) {
     ...params.query,
     queryKey: symmKeys.pendingInstantOpens(accountAddress, chainId),
     queryFn: async () => {
-      const authToken = providedAuthToken ?? useSymmAuthStore.getState().getToken(accountAddress, chainId);
+      const authToken = providedAuthToken ?? getAuthTokenFromRuntimeCache(queryClient, accountAddress, chainId);
       if (!authToken) {
         throw new Error("failed to acquire auth token for pending instant opens");
       }
@@ -26856,7 +26981,6 @@ exports.useSymmAllocateCollateralMutation = useSymmAllocateCollateralMutation;
 exports.useSymmApprovalQuery = useSymmApprovalQuery;
 exports.useSymmApproveMutation = useSymmApproveMutation;
 exports.useSymmAuth = useSymmAuth;
-exports.useSymmAuthStore = useSymmAuthStore;
 exports.useSymmAvailableMargin = useSymmAvailableMargin;
 exports.useSymmBalances = useSymmBalances;
 exports.useSymmCancelClose = useSymmCancelClose;
@@ -26873,6 +26997,7 @@ exports.useSymmContext = useSymmContext;
 exports.useSymmCoreClient = useSymmCoreClient;
 exports.useSymmCreateAccountMutation = useSymmCreateAccountMutation;
 exports.useSymmDeallocateCollateralMutation = useSymmDeallocateCollateralMutation;
+exports.useSymmDelegateAccessMutation = useSymmDelegateAccessMutation;
 exports.useSymmDelegation = useSymmDelegation;
 exports.useSymmDepositAndAllocateMutation = useSymmDepositAndAllocateMutation;
 exports.useSymmDepositMutation = useSymmDepositMutation;
@@ -26897,6 +27022,8 @@ exports.useSymmPendingInstantOpens = useSymmPendingInstantOpens;
 exports.useSymmPerformanceOverlays = useSymmPerformanceOverlays;
 exports.useSymmPortfolio = useSymmPortfolio;
 exports.useSymmPositions = useSymmPositions;
+exports.useSymmProposeRevokeDelegationMutation = useSymmProposeRevokeDelegationMutation;
+exports.useSymmRevokeDelegationMutation = useSymmRevokeDelegationMutation;
 exports.useSymmSetTpslMutation = useSymmSetTpslMutation;
 exports.useSymmSetTriggerConfigMutation = useSymmSetTriggerConfigMutation;
 exports.useSymmSignTermsMutation = useSymmSignTermsMutation;