@pear-protocol/symmio-client 0.3.25 → 0.3.27

package/dist/react/index.js

@@ -615,6 +615,7 @@ var symmKeys = {
   tpslOrdersRoot: ["symm", "tpslOrders"],
   twapOrdersRoot: ["symm", "twapOrders"],
   triggerOrdersRoot: ["symm", "triggerOrders"],
+  bridgesRoot: ["symm", "bridges"],
   accounts: (address, chainId) => ["symm", "accounts", address, chainId],
   accountsApi: (address, chainId) => ["symm", "accountsApi", address, chainId],
   accountsLength: (address, chainId) => ["symm", "accountsLength", address, chainId],
@@ -651,7 +652,12 @@ var symmKeys = {
   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]
+  chartMetadata: (symbolsKey, positionKey) => ["symm", "chartMetadata", symbolsKey, positionKey],
+  instantWithdrawalAuth: (signerAddress, chainId) => ["symm", "instantWithdrawalAuth", signerAddress, chainId],
+  withdrawalConfig: (chainId) => ["symm", "withdrawalConfig", chainId],
+  maxInstantValue: (account, chainId) => ["symm", "maxInstantValue", account, chainId],
+  pendingFeePolicy: (account, chainId) => ["symm", "pendingFeePolicy", account, chainId],
+  bridges: (params) => ["symm", "bridges", params]
 };
 var useSymmWsStore = zustand.create((set) => ({
   isConnected: false,
@@ -846,6 +852,9 @@ var HEDGER_BASE_URLS = {
   [42161 /* ARBITRUM */]: "https://www.perps-streaming.com/v1/42161a/0x6273242a7E88b3De90822b31648C212215caaFE4/",
   [8453 /* BASE */]: "https://www.perps-streaming.com/v1/8453a/0xE43166cE17d3511B09438a359dAa53513225101D/"
 };
+var INSTANT_WITHDRAWAL_BASE_URLS = {
+  [8453 /* BASE */]: "https://instant-withdrawal-base.symmio.foundation/v1/"
+};
 
 // src/actions/instant.ts
 function getHedgerBaseUrl(chainId) {
@@ -1288,6 +1297,9 @@ var SIGNATURE_STORE_ADDRESS = {
   [42161 /* ARBITRUM */]: "0x94eEa58De1C8945c342dB4bE9670301638E403e2",
   [8453 /* BASE */]: "0xC19e66D08350Eb88A41377b16C8Ab93EE0FB4996"
 };
+var INSTANT_WITHDRAWAL_ADDRESS = {
+  [8453 /* BASE */]: "0xE0650873D8DadB54a6AC7c666BC98ab45f827b6D"
+};
 var DEFAULT_PARTY_B_ADDRESS = {
   [42161 /* ARBITRUM */]: "0x00c069d68bc7420740460DBC3cc3fFF9b3742421",
   [8453 /* BASE */]: "0x1EcAbF0Eba136920677C9575FAccee36f30592cf"
@@ -2032,6 +2044,10 @@ function invalidatePositions(qc) {
   qc.invalidateQueries({ queryKey: symmKeys.tradeHistoryRoot });
   qc.invalidateQueries({ queryKey: symmKeys.portfolioRoot });
 }
+function invalidateBridges(qc) {
+  qc.invalidateQueries({ queryKey: symmKeys.bridgesRoot });
+  qc.invalidateQueries({ queryKey: symmKeys.balancesRoot });
+}
 function invalidateOrders(qc) {
   qc.invalidateQueries({ queryKey: symmKeys.openOrdersRoot });
   qc.invalidateQueries({ queryKey: symmKeys.tpslOrdersRoot });
@@ -2673,53 +2689,6 @@ function useSymmDepositAndAllocateMutation(params = {}, options) {
     }
   });
 }
-function prepareWithdraw(multiAccount, account, params) {
-  validateAmount(params.amount, "withdraw amount");
-  validateAddress(params.account, "account");
-  const data = viem.encodeFunctionData({
-    abi: MultiAccountABI,
-    functionName: "withdrawFromAccount",
-    args: [params.account, params.amount]
-  });
-  return {
-    functionName: "withdrawFromAccount",
-    args: [params.account, params.amount],
-    config: { account, to: multiAccount, data, value: 0n }
-  };
-}
-async function withdraw(walletClient, publicClient, multiAccount, params) {
-  const account = walletClient.account?.address;
-  if (!account) throw new Error("Wallet client has no account");
-  const prepared = prepareWithdraw(multiAccount, account, params);
-  const gas = await publicClient.estimateGas(prepared.config);
-  return walletClient.sendTransaction({
-    ...prepared.config,
-    gas: calculateGasMargin(gas),
-    chain: walletClient.chain
-  });
-}
-
-// src/react/hooks/use-symm-withdraw.ts
-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");
-  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 });
-    }
-  });
-}
 
 // src/abis/SymmioDiamond.ts
 var SymmioDiamondABI = [
@@ -25105,6 +25074,17 @@ var SymmioDiamondABI = [
     type: "function"
   }
 ];
+
+// src/abis/InstantWithdrawal.ts
+var InstantWithdrawalABI = [
+  {
+    inputs: [{ internalType: "uint256", name: "bridgeId", type: "uint256" }],
+    name: "processWithdrawal",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  }
+];
 function wrapInProxyCall(accountDiamondAbi, subAccount, callDatas) {
   const data = viem.encodeFunctionData({
     abi: accountDiamondAbi,
@@ -25118,7 +25098,795 @@ function wrapInProxyCall(accountDiamondAbi, subAccount, callDatas) {
   };
 }
 
-// src/actions/allocate.ts
+// src/actions/withdraw.ts
+function prepareWithdraw(multiAccount, account, params) {
+  validateAmount(params.amount, "withdraw amount");
+  validateAddress(params.account, "account");
+  const data = viem.encodeFunctionData({
+    abi: MultiAccountABI,
+    functionName: "withdrawFromAccount",
+    args: [params.account, params.amount]
+  });
+  return {
+    functionName: "withdrawFromAccount",
+    args: [params.account, params.amount],
+    config: { account, to: multiAccount, data, value: 0n }
+  };
+}
+async function withdraw(walletClient, publicClient, multiAccount, params) {
+  const account = walletClient.account?.address;
+  if (!account) throw new Error("Wallet client has no account");
+  const prepared = prepareWithdraw(multiAccount, account, params);
+  const gas = await publicClient.estimateGas(prepared.config);
+  return walletClient.sendTransaction({
+    ...prepared.config,
+    gas: calculateGasMargin(gas),
+    chain: walletClient.chain
+  });
+}
+function encodeDeallocate(amount, upnlSig) {
+  validateAmount(amount, "deallocate amount");
+  const muonSig = {
+    reqId: upnlSig.reqId,
+    timestamp: upnlSig.timestamp,
+    upnl: upnlSig.upnl,
+    gatewaySignature: upnlSig.gatewaySignature,
+    sigs: {
+      signature: upnlSig.sigs.signature,
+      owner: upnlSig.sigs.owner,
+      nonce: upnlSig.sigs.nonce
+    }
+  };
+  return viem.encodeFunctionData({
+    abi: SymmioDiamondABI,
+    functionName: "deallocate",
+    args: [amount, muonSig]
+  });
+}
+function encodeTransferToBridge(amount, bridgeAddress) {
+  validateAmount(amount, "bridge amount");
+  validateAddress(bridgeAddress, "bridgeAddress");
+  return viem.encodeFunctionData({
+    abi: SymmioDiamondABI,
+    functionName: "transferToBridge",
+    args: [amount, bridgeAddress]
+  });
+}
+function prepareTransferToBridge(symmioDiamond, account, params) {
+  const data = encodeTransferToBridge(params.amount, params.bridgeAddress);
+  return {
+    functionName: "transferToBridge",
+    args: [params.amount, params.bridgeAddress],
+    config: { account, to: symmioDiamond, data, value: 0n }
+  };
+}
+function prepareBridgeWithdraw(multiAccount, account, subAccount, params) {
+  const callDatas = [];
+  if (params.deallocate) {
+    callDatas.push(
+      encodeDeallocate(params.deallocate.amount, params.deallocate.upnlSig)
+    );
+  }
+  callDatas.push(encodeTransferToBridge(params.amount, params.bridgeAddress));
+  const proxy = wrapInProxyCall(MultiAccountABI, subAccount, callDatas);
+  return {
+    functionName: "_call",
+    args: proxy.args,
+    config: { account, to: multiAccount, data: proxy.data, value: 0n }
+  };
+}
+async function transferToBridge(walletClient, publicClient, symmioDiamond, params) {
+  const account = walletClient.account?.address;
+  if (!account) throw new Error("Wallet client has no account");
+  const prepared = prepareTransferToBridge(symmioDiamond, account, params);
+  const gas = await publicClient.estimateGas(prepared.config);
+  return walletClient.sendTransaction({
+    ...prepared.config,
+    gas: calculateGasMargin(gas),
+    chain: walletClient.chain
+  });
+}
+async function bridgeWithdraw(walletClient, publicClient, multiAccount, subAccount, params) {
+  const account = walletClient.account?.address;
+  if (!account) throw new Error("Wallet client has no account");
+  const prepared = prepareBridgeWithdraw(multiAccount, account, subAccount, params);
+  const gas = await publicClient.estimateGas(prepared.config);
+  return walletClient.sendTransaction({
+    ...prepared.config,
+    gas: calculateGasMargin(gas),
+    chain: walletClient.chain
+  });
+}
+function prepareProcessWithdrawal(instantWithdrawal, account, params) {
+  const data = viem.encodeFunctionData({
+    abi: InstantWithdrawalABI,
+    functionName: "processWithdrawal",
+    args: [params.bridgeId]
+  });
+  return {
+    functionName: "processWithdrawal",
+    args: [params.bridgeId],
+    config: { account, to: instantWithdrawal, data, value: 0n }
+  };
+}
+async function processWithdrawal(walletClient, publicClient, instantWithdrawal, params) {
+  const account = walletClient.account?.address;
+  if (!account) throw new Error("Wallet client has no account");
+  const prepared = prepareProcessWithdrawal(instantWithdrawal, account, params);
+  const gas = await publicClient.estimateGas(prepared.config);
+  return walletClient.sendTransaction({
+    ...prepared.config,
+    gas: calculateGasMargin(gas),
+    chain: walletClient.chain
+  });
+}
+
+// src/react/hooks/use-symm-withdraw.ts
+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");
+  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 });
+    }
+  });
+}
+
+// src/types/instant-withdrawal.ts
+var InstantWithdrawalError = class extends Error {
+  code;
+  status;
+  detail;
+  constructor(message, options) {
+    super(message);
+    this.name = "InstantWithdrawalError";
+    this.code = options?.code;
+    this.status = options?.status;
+    this.detail = options?.detail;
+  }
+};
+
+// src/actions/instant-withdrawal.ts
+function getInstantWithdrawalBaseUrl(chainId) {
+  const baseUrl = INSTANT_WITHDRAWAL_BASE_URLS[chainId];
+  if (!baseUrl) {
+    throw new Error(
+      `Instant withdrawal is not available on chain ${chainId}.`
+    );
+  }
+  return baseUrl;
+}
+function buildUrl(chainId, path, query) {
+  const url = new URL(path, getInstantWithdrawalBaseUrl(chainId));
+  if (query) {
+    for (const [key, value] of Object.entries(query)) {
+      if (value !== void 0) url.searchParams.set(key, String(value));
+    }
+  }
+  return url.href;
+}
+async function iwFetch(url, options) {
+  const headers = {};
+  if (options?.body !== void 0) {
+    headers["Content-Type"] = "application/json";
+  }
+  if (options?.token) {
+    headers.Authorization = `Bearer ${options.token}`;
+  }
+  const response = await fetch(url, {
+    method: options?.method ?? "GET",
+    headers,
+    body: options?.body !== void 0 ? JSON.stringify(options.body) : void 0
+  });
+  if (!response.ok) {
+    const raw = await response.text().catch(() => "");
+    let code;
+    let message = "";
+    let detail;
+    if (raw) {
+      try {
+        const parsed = JSON.parse(raw);
+        code = parsed.error_code;
+        message = parsed.error_message ?? parsed.message ?? (typeof parsed.detail === "string" ? parsed.detail : "") ?? "";
+        detail = parsed.error_detail ?? parsed.detail;
+      } catch {
+        message = raw;
+      }
+    }
+    throw new InstantWithdrawalError(
+      message || response.statusText || "Instant withdrawal request failed",
+      { code, status: response.status, detail }
+    );
+  }
+  if (response.status === 204) return void 0;
+  return response.json();
+}
+async function getNonce2(chainId, address) {
+  const data = await iwFetch(
+    buildUrl(chainId, "auth/nonce"),
+    { method: "POST", body: { address } }
+  );
+  return data.nonce;
+}
+async function getSignInMessage(chainId, params) {
+  return iwFetch(
+    buildUrl(chainId, "auth/sign-in-message", {
+      address: params.address,
+      domain: params.domain,
+      uri: params.uri,
+      statement: params.statement,
+      version: params.version
+    })
+  );
+}
+async function login2(chainId, message, signature) {
+  return iwFetch(buildUrl(chainId, "auth/login"), {
+    method: "POST",
+    body: { message, signature }
+  });
+}
+async function getFeeOptions(chainId, account, amount, token) {
+  return iwFetch(
+    buildUrl(chainId, "fee-options", {
+      account,
+      amount: amount.toString()
+    }),
+    { method: "POST", token }
+  );
+}
+async function unlockAccount(chainId, account, token) {
+  return iwFetch(
+    buildUrl(chainId, `unlock/${account}`),
+    { method: "POST", token }
+  );
+}
+async function getPendingFeePolicy(chainId, account, token) {
+  return iwFetch(
+    buildUrl(chainId, `pending-fee-policy/${account}`),
+    { token }
+  );
+}
+async function getMaxInstantValue(chainId, account, token) {
+  const data = await iwFetch(
+    buildUrl(chainId, `max-instant-value/${account}`),
+    { token }
+  );
+  return BigInt(data.amount);
+}
+async function getWithdrawalConfig(chainId) {
+  const data = await iwFetch(
+    buildUrl(chainId, "withdrawal-config")
+  );
+  return {
+    operatorFee: data.operator_fee,
+    maxInstantAmount: data.max_instant_amount,
+    instantFeeRate: data.instant_fee_rate,
+    policyValidTime: data.policy_valid_time,
+    minWithdrawalCooldown: data.min_withdrawal_cooldown
+  };
+}
+async function getSelectReceiverMessage(chainId, receiver, bridgeId) {
+  return iwFetch(
+    buildUrl(chainId, "get-select-receiver-message", {
+      receiver,
+      bridgeId
+    })
+  );
+}
+async function selectFeePolicy(chainId, body, token) {
+  return iwFetch(
+    buildUrl(chainId, "select-fee-policy"),
+    { method: "POST", token, body }
+  );
+}
+async function getBridges(chainId, account, start, size, filters, token) {
+  return iwFetch(
+    buildUrl(chainId, `bridges/${account}/${start}/${size}`),
+    { method: "POST", token, body: filters }
+  );
+}
+
+// src/react/instant-withdrawal-auth.ts
+var TOKEN_STORAGE_PREFIX2 = "symm_iw_token";
+var TOKEN_STORAGE_VERSION2 = 1;
+var DEFAULT_TTL_MS = 24 * 60 * 60 * 1e3;
+var EXPIRY_SKEW_MS = 6e4;
+function storageKey2(address, chainId) {
+  return `${TOKEN_STORAGE_PREFIX2}:${TOKEN_STORAGE_VERSION2}:${address.toLowerCase()}:${chainId}`;
+}
+function readJwtExpiryMs(token) {
+  try {
+    const payload = token.split(".")[1];
+    if (!payload) return null;
+    const normalized = payload.replace(/-/g, "+").replace(/_/g, "/");
+    const json = typeof atob === "function" ? atob(normalized) : Buffer.from(normalized, "base64").toString("binary");
+    const parsed = JSON.parse(json);
+    return typeof parsed.exp === "number" ? parsed.exp * 1e3 : null;
+  } catch {
+    return null;
+  }
+}
+function getCachedTokenEntry2(address, chainId) {
+  if (typeof window === "undefined") return null;
+  const key = storageKey2(address, chainId);
+  try {
+    const raw = window.localStorage.getItem(key);
+    if (!raw) return null;
+    const parsed = JSON.parse(raw);
+    if (!parsed || typeof parsed.token !== "string" || typeof parsed.expiresAt !== "number" || Date.now() >= parsed.expiresAt) {
+      window.localStorage.removeItem(key);
+      return null;
+    }
+    return parsed;
+  } catch {
+    window.localStorage.removeItem(key);
+    return null;
+  }
+}
+function getCachedToken(address, chainId) {
+  return getCachedTokenEntry2(address, chainId)?.token ?? null;
+}
+function writeStoredToken2(address, chainId, cached) {
+  if (typeof window === "undefined") return;
+  try {
+    window.localStorage.setItem(
+      storageKey2(address, chainId),
+      JSON.stringify(cached)
+    );
+  } catch {
+  }
+}
+function clearCachedToken2(address, chainId) {
+  if (typeof window === "undefined") return;
+  try {
+    window.localStorage.removeItem(storageKey2(address, chainId));
+  } catch {
+  }
+}
+async function fetchInstantWithdrawalTokenEntry(walletClient, signerAddress, chainId, domain) {
+  const resolvedDomain = domain ?? (typeof window !== "undefined" ? window.location.hostname : "localhost");
+  const uri = typeof window !== "undefined" ? window.location.origin : `https://${resolvedDomain}`;
+  await getNonce2(chainId, signerAddress);
+  const { message, params } = await getSignInMessage(chainId, {
+    address: signerAddress,
+    domain: resolvedDomain,
+    uri
+  });
+  const signature = await walletClient.signMessage({
+    account: signerAddress,
+    message
+  });
+  const { accessToken } = await login2(chainId, params, signature);
+  const expiresAt = (readJwtExpiryMs(accessToken) ?? Date.now() + DEFAULT_TTL_MS) - EXPIRY_SKEW_MS;
+  const cached = { token: accessToken, expiresAt };
+  writeStoredToken2(signerAddress, chainId, cached);
+  return cached;
+}
+async function fetchInstantWithdrawalToken(walletClient, signerAddress, chainId, domain) {
+  const entry = await fetchInstantWithdrawalTokenEntry(
+    walletClient,
+    signerAddress,
+    chainId,
+    domain
+  );
+  return entry.token;
+}
+async function resolveInstantWithdrawalToken(walletClient, signerAddress, chainId, options) {
+  if (!options?.force) {
+    const cached = getCachedToken(signerAddress, chainId);
+    if (cached) return cached;
+  }
+  return fetchInstantWithdrawalToken(
+    walletClient,
+    signerAddress,
+    chainId,
+    options?.domain
+  );
+}
+
+// src/react/hooks/use-symm-instant-withdrawal-auth.ts
+function useSymmInstantWithdrawalAuth(params) {
+  const context = useSymmContext();
+  const address = params?.address ?? context.address;
+  const chainId = params?.chainId ?? context.chainId;
+  const walletClient = params?.walletClient ?? context.walletClient;
+  const siweDomain = params?.siweDomain;
+  const [accessToken, setAccessToken] = react.useState(null);
+  const [isLoading, setIsLoading] = react.useState(false);
+  const [error, setError] = react.useState(null);
+  react.useEffect(() => {
+    if (!address) {
+      setAccessToken(null);
+      return;
+    }
+    setAccessToken(getCachedToken(address, chainId));
+  }, [address, chainId]);
+  const signIn = react.useCallback(
+    async (options) => {
+      if (!walletClient || !address) return null;
+      try {
+        setError(null);
+        setIsLoading(true);
+        const token = await resolveInstantWithdrawalToken(
+          walletClient,
+          address,
+          chainId,
+          { domain: siweDomain, force: options?.force }
+        );
+        setAccessToken(token);
+        return token;
+      } catch (err) {
+        const normalized = err instanceof Error ? err : new Error("failed to sign in");
+        setError(normalized);
+        return null;
+      } finally {
+        setIsLoading(false);
+      }
+    },
+    [walletClient, address, chainId, siweDomain]
+  );
+  const clear = react.useCallback(() => {
+    if (address) clearCachedToken2(address, chainId);
+    setAccessToken(null);
+  }, [address, chainId]);
+  return {
+    accessToken,
+    isAuthenticated: !!accessToken,
+    isLoading,
+    error,
+    signIn,
+    clear
+  };
+}
+function useSymmWithdrawalConfig(params) {
+  const { chainId: ctxChainId } = useSymmContext();
+  const chainId = params?.chainId ?? ctxChainId;
+  return reactQuery.useQuery({
+    staleTime: 6e4,
+    ...params?.query,
+    queryKey: symmKeys.withdrawalConfig(chainId),
+    queryFn: () => getWithdrawalConfig(chainId),
+    enabled: params?.query?.enabled ?? true
+  });
+}
+function useSymmMaxInstantValue(params) {
+  const { chainId: ctxChainId } = useSymmContext();
+  const chainId = params.chainId ?? ctxChainId;
+  const { account, accessToken } = params;
+  const internalEnabled = !!account && !!accessToken;
+  return reactQuery.useQuery({
+    staleTime: 15e3,
+    ...params.query,
+    queryKey: symmKeys.maxInstantValue(account, chainId),
+    queryFn: () => getMaxInstantValue(chainId, account, accessToken),
+    enabled: internalEnabled && (params.query?.enabled ?? true)
+  });
+}
+function useSymmFeeOptionsMutation(params, options) {
+  const { chainId: ctxChainId } = useSymmContext();
+  const chainId = params?.chainId ?? ctxChainId;
+  return reactQuery.useMutation({
+    ...withSymmMutationConfig(options?.mutation),
+    mutationFn: ({ account, amount, accessToken }) => getFeeOptions(chainId, account, amount, accessToken)
+  });
+}
+function useSymmPendingFeePolicy(params) {
+  const { chainId: ctxChainId } = useSymmContext();
+  const chainId = params.chainId ?? ctxChainId;
+  const { account, accessToken } = params;
+  const internalEnabled = !!account && !!accessToken;
+  return reactQuery.useQuery({
+    ...params.query,
+    queryKey: symmKeys.pendingFeePolicy(account, chainId),
+    queryFn: () => getPendingFeePolicy(chainId, account, accessToken),
+    enabled: internalEnabled && (params.query?.enabled ?? true)
+  });
+}
+function useSymmUnlockAccountMutation(params, options) {
+  const { chainId: ctxChainId } = useSymmContext();
+  const chainId = params?.chainId ?? ctxChainId;
+  return reactQuery.useMutation({
+    ...withSymmMutationConfig(options?.mutation),
+    mutationFn: ({ account, accessToken }) => unlockAccount(chainId, account, accessToken)
+  });
+}
+function useSymmRefreshFeeOptionsMutation(params, options) {
+  const { chainId: ctxChainId } = useSymmContext();
+  const chainId = params?.chainId ?? ctxChainId;
+  return reactQuery.useMutation({
+    ...withSymmMutationConfig(options?.mutation),
+    mutationFn: async ({ account, amount, accessToken }) => {
+      await unlockAccount(chainId, account, accessToken);
+      return getFeeOptions(chainId, account, amount, accessToken);
+    }
+  });
+}
+function useSymmBridges(params) {
+  const { chainId: ctxChainId } = useSymmContext();
+  const chainId = params.chainId ?? ctxChainId;
+  const {
+    account,
+    accessToken,
+    start = null,
+    size = null,
+    bridgeState = null,
+    bridgeType = null
+  } = params;
+  const internalEnabled = !!account && !!accessToken;
+  return reactQuery.useQuery({
+    ...params.query,
+    queryKey: symmKeys.bridges({
+      account,
+      chainId,
+      start,
+      size,
+      bridgeState,
+      bridgeType
+    }),
+    queryFn: () => getBridges(
+      chainId,
+      account,
+      start,
+      size,
+      { bridge_state: bridgeState, bridge_type: bridgeType },
+      accessToken
+    ),
+    enabled: internalEnabled && (params.query?.enabled ?? true)
+  });
+}
+async function buildSpecifiedReceiver(chainId, receiver, bridgeId, walletClient, signerAddress) {
+  const { payload } = await getSelectReceiverMessage(chainId, receiver, bridgeId);
+  const { EIP712Domain: _ignored, ...types } = payload.types;
+  const signature = await walletClient.signTypedData({
+    account: signerAddress,
+    domain: payload.domain,
+    types,
+    primaryType: payload.primaryType,
+    message: payload.message
+  });
+  return { address: receiver, signature };
+}
+function useSymmSelectFeePolicyMutation(params, options) {
+  const { chainId: ctxChainId, address, walletClient: ctxWallet } = useSymmContext();
+  const chainId = params?.chainId ?? ctxChainId;
+  const walletClient = params?.walletClient ?? ctxWallet;
+  const queryClient = reactQuery.useQueryClient();
+  return reactQuery.useMutation({
+    ...withSymmMutationConfig(options?.mutation, {
+      onSuccess: () => invalidateBridges(queryClient)
+    }),
+    mutationFn: async (variables) => {
+      let receiver = variables.receiver ?? null;
+      if (!receiver && variables.newReceiver) {
+        if (!walletClient || !address) {
+          throw new Error("wallet client is required to sign a new receiver");
+        }
+        receiver = await buildSpecifiedReceiver(
+          chainId,
+          variables.newReceiver,
+          variables.symmioBridgeId,
+          walletClient,
+          address
+        );
+      }
+      return selectFeePolicy(
+        chainId,
+        {
+          symmioBridgeId: variables.symmioBridgeId,
+          cooldown: variables.cooldown,
+          feeAmount: variables.feeAmount,
+          receiver
+        },
+        variables.accessToken
+      );
+    }
+  });
+}
+function pickOption(options, speed) {
+  if (options.length === 0) {
+    throw new InstantWithdrawalError("no fee options available", {
+      code: 8 /* INVALID_BRIDGE_POLICY_OPTION */
+    });
+  }
+  const sorted = [...options].sort((a, b) => a.cooldown - b.cooldown);
+  return speed === "instant" ? sorted[0] : sorted[sorted.length - 1];
+}
+function useSymmInstantWithdraw(params, options) {
+  const {
+    chainId: ctxChainId,
+    address,
+    walletClient: ctxWallet,
+    symmioConfig
+  } = useSymmContext();
+  const chainId = params.chainId ?? ctxChainId;
+  const walletClient = params.walletClient ?? ctxWallet;
+  const publicClient = params.publicClient;
+  const queryClient = reactQuery.useQueryClient();
+  const [status, setStatus] = react.useState("idle");
+  const [bridgeTxHash, setBridgeTxHash] = react.useState();
+  const reset = react.useCallback(() => {
+    setStatus("idle");
+    setBridgeTxHash(void 0);
+  }, []);
+  const mutation = reactQuery.useMutation({
+    ...withSymmMutationConfig(options?.mutation, {
+      onSuccess: () => invalidateBridges(queryClient)
+    }),
+    mutationFn: async (variables) => {
+      if (!walletClient || !address) {
+        throw new Error("wallet client and address are required");
+      }
+      if (!publicClient) throw new Error("public client is required");
+      const speed = variables.speed ?? "instant";
+      const apiAccount = variables.subAccount ?? address;
+      const bridgeAddress = getAddress(
+        INSTANT_WITHDRAWAL_ADDRESS,
+        chainId,
+        "InstantWithdrawal"
+      );
+      try {
+        setStatus("authenticating");
+        const accessToken = await resolveInstantWithdrawalToken(
+          walletClient,
+          address,
+          chainId,
+          { domain: params.siweDomain, force: variables.forceReauth }
+        );
+        if (speed === "instant") {
+          const maxInstant = await getMaxInstantValue(
+            chainId,
+            apiAccount,
+            accessToken
+          );
+          if (maxInstant <= 0n) {
+            throw new InstantWithdrawalError(
+              "instant withdrawal is not available for this account right now",
+              { code: 7 /* INVALID_BRIDGE_TRANSACTION */ }
+            );
+          }
+          if (variables.amount > maxInstant) {
+            throw new InstantWithdrawalError(
+              `amount exceeds max instant value (${maxInstant} wei); use the standard 12h withdrawal`,
+              { code: 10 /* LOW_AMOUNT_TO_BRIDGE */ }
+            );
+          }
+        }
+        setStatus("bridging");
+        let txHash;
+        if (variables.subAccount) {
+          const multiAccount = symmioConfig?.multiAccountAddress ?? getAddress(MULTI_ACCOUNT_ADDRESS, chainId, "MultiAccount");
+          txHash = await bridgeWithdraw(
+            walletClient,
+            publicClient,
+            multiAccount,
+            variables.subAccount,
+            {
+              amount: variables.amount,
+              bridgeAddress,
+              deallocate: variables.deallocate
+            }
+          );
+        } else {
+          const symmioDiamond = symmioConfig?.symmioDiamondAddress ?? getAddress(SYMMIO_DIAMOND_ADDRESS, chainId, "SymmioDiamond");
+          txHash = await transferToBridge(walletClient, publicClient, symmioDiamond, {
+            amount: variables.amount,
+            bridgeAddress
+          });
+        }
+        setBridgeTxHash(txHash);
+        await publicClient.waitForTransactionReceipt({ hash: txHash });
+        setStatus("awaitingBridgeId");
+        const bridgeId = await pollForBridgeId(
+          chainId,
+          apiAccount,
+          variables.amount,
+          accessToken,
+          params.bridgeIdTimeoutMs ?? 3e4
+        );
+        setStatus("fetchingOptions");
+        const { options: feeOptions } = await getFeeOptions(
+          chainId,
+          apiAccount,
+          variables.amount,
+          accessToken
+        );
+        const option = pickOption(feeOptions, speed);
+        setStatus("selectingPolicy");
+        let receiver = null;
+        if (variables.newReceiver) {
+          receiver = await buildSpecifiedReceiver(
+            chainId,
+            variables.newReceiver,
+            bridgeId,
+            walletClient,
+            address
+          );
+        }
+        const result = await selectFeePolicy(
+          chainId,
+          {
+            symmioBridgeId: bridgeId,
+            cooldown: option.cooldown,
+            feeAmount: option.fee,
+            receiver
+          },
+          accessToken
+        );
+        setStatus("done");
+        return {
+          bridgeId,
+          executionTime: result.execution_time,
+          fee: result.fee,
+          bridgeTxHash: txHash
+        };
+      } catch (err) {
+        setStatus("failed");
+        throw err;
+      }
+    }
+  });
+  return { ...mutation, status, bridgeTxHash, reset };
+}
+async function pollForBridgeId(chainId, account, amount, accessToken, timeoutMs) {
+  const deadline = Date.now() + timeoutMs;
+  const intervalMs = 2e3;
+  const target = Number(amount);
+  while (Date.now() < deadline) {
+    const { bridges } = await getBridges(
+      chainId,
+      account,
+      0,
+      50,
+      { bridge_state: "pending" /* PENDING */, bridge_type: "no_policy" /* NO_POLICY */ },
+      accessToken
+    );
+    const matches = (bridges ?? []).filter((b) => b.bridge_amount === target);
+    if (matches.length > 0) {
+      return matches.reduce((a, b) => b.bridge_id > a.bridge_id ? b : a).bridge_id;
+    }
+    await new Promise((resolve) => setTimeout(resolve, intervalMs));
+  }
+  throw new InstantWithdrawalError(
+    "timed out resolving the bridge transaction; the bot may still be indexing \u2014 retry fee selection from your bridge list",
+    { code: 7 /* INVALID_BRIDGE_TRANSACTION */ }
+  );
+}
+function useSymmProcessWithdrawalMutation(params, options) {
+  const { chainId: ctxChainId, walletClient: ctxWallet } = useSymmContext();
+  const chainId = params.chainId ?? ctxChainId;
+  const walletClient = params.walletClient ?? ctxWallet;
+  const { publicClient } = params;
+  const queryClient = reactQuery.useQueryClient();
+  return reactQuery.useMutation({
+    ...withSymmMutationConfig(options?.mutation, {
+      onSuccess: () => invalidateBridges(queryClient)
+    }),
+    mutationFn: async ({ bridgeId }) => {
+      if (!walletClient || !publicClient) {
+        throw new Error("Clients not available");
+      }
+      const instantWithdrawal = getAddress(
+        INSTANT_WITHDRAWAL_ADDRESS,
+        chainId,
+        "InstantWithdrawal"
+      );
+      return processWithdrawal(walletClient, publicClient, instantWithdrawal, {
+        bridgeId
+      });
+    }
+  });
+}
 function prepareAllocate(multiAccount, account, subAccount, params) {
   validateAmount(params.amount, "allocate amount");
   const innerData = viem.encodeFunctionData({
@@ -28032,6 +28800,7 @@ function getSymmErrorMessage(error) {
 }
 
 exports.SymmProvider = SymmProvider;
+exports.buildSpecifiedReceiver = buildSpecifiedReceiver;
 exports.computeSymmAccountOverview = computeSymmAccountOverview;
 exports.computeSymmAccountOverviewFromData = computeSymmAccountOverviewFromData;
 exports.computeSymmNetDeposited = computeSymmNetDeposited;
@@ -28057,6 +28826,7 @@ exports.useSymmApproveMutation = useSymmApproveMutation;
 exports.useSymmAuth = useSymmAuth;
 exports.useSymmAvailableMargin = useSymmAvailableMargin;
 exports.useSymmBalances = useSymmBalances;
+exports.useSymmBridges = useSymmBridges;
 exports.useSymmCancelClose = useSymmCancelClose;
 exports.useSymmCancelOpenMutation = useSymmCancelOpenMutation;
 exports.useSymmCancelTpslMutation = useSymmCancelTpslMutation;
@@ -28076,6 +28846,7 @@ exports.useSymmDelegation = useSymmDelegation;
 exports.useSymmDepositAndAllocateMutation = useSymmDepositAndAllocateMutation;
 exports.useSymmDepositMutation = useSymmDepositMutation;
 exports.useSymmEditAccountNameMutation = useSymmEditAccountNameMutation;
+exports.useSymmFeeOptionsMutation = useSymmFeeOptionsMutation;
 exports.useSymmFunding = useSymmFunding;
 exports.useSymmFundingHistory = useSymmFundingHistory;
 exports.useSymmFundingPayments = useSymmFundingPayments;
@@ -28084,22 +28855,29 @@ exports.useSymmHedgerMarketBySymbol = useSymmHedgerMarketBySymbol;
 exports.useSymmHedgerMarkets = useSymmHedgerMarkets;
 exports.useSymmInstantTradeEnsureReadyMutation = useSymmInstantTradeEnsureReadyMutation;
 exports.useSymmInstantTradeExecuteMutation = useSymmInstantTradeExecuteMutation;
+exports.useSymmInstantWithdraw = useSymmInstantWithdraw;
+exports.useSymmInstantWithdrawalAuth = useSymmInstantWithdrawalAuth;
 exports.useSymmInternalTransferCollateralMutation = useSymmInternalTransferCollateralMutation;
 exports.useSymmLeaderboard = useSymmLeaderboard;
 exports.useSymmLockedParams = useSymmLockedParams;
 exports.useSymmMarkReadNotificationMutation = useSymmMarkReadNotificationMutation;
 exports.useSymmMarketPositioning = useSymmMarketPositioning;
 exports.useSymmMarkets = useSymmMarkets;
+exports.useSymmMaxInstantValue = useSymmMaxInstantValue;
 exports.useSymmNotificationsQuery = useSymmNotificationsQuery;
 exports.useSymmOpenBasketMutation = useSymmOpenBasketMutation;
 exports.useSymmOpenOrders = useSymmOpenOrders;
+exports.useSymmPendingFeePolicy = useSymmPendingFeePolicy;
 exports.useSymmPendingIds = useSymmPendingIds;
 exports.useSymmPendingInstantOpens = useSymmPendingInstantOpens;
 exports.useSymmPerformanceOverlays = useSymmPerformanceOverlays;
 exports.useSymmPortfolio = useSymmPortfolio;
 exports.useSymmPositions = useSymmPositions;
+exports.useSymmProcessWithdrawalMutation = useSymmProcessWithdrawalMutation;
 exports.useSymmProposeRevokeDelegationMutation = useSymmProposeRevokeDelegationMutation;
+exports.useSymmRefreshFeeOptionsMutation = useSymmRefreshFeeOptionsMutation;
 exports.useSymmRevokeDelegationMutation = useSymmRevokeDelegationMutation;
+exports.useSymmSelectFeePolicyMutation = useSymmSelectFeePolicyMutation;
 exports.useSymmSetTpslMutation = useSymmSetTpslMutation;
 exports.useSymmSetTriggerConfigMutation = useSymmSetTriggerConfigMutation;
 exports.useSymmSignTermsMutation = useSymmSignTermsMutation;
@@ -28113,10 +28891,12 @@ exports.useSymmTriggerConfigQuery = useSymmTriggerConfigQuery;
 exports.useSymmTriggerOrders = useSymmTriggerOrders;
 exports.useSymmTwapOrder = useSymmTwapOrder;
 exports.useSymmTwapOrdersQuery = useSymmTwapOrdersQuery;
+exports.useSymmUnlockAccountMutation = useSymmUnlockAccountMutation;
 exports.useSymmUnreadCountQuery = useSymmUnreadCountQuery;
 exports.useSymmUpdatePositionMutation = useSymmUpdatePositionMutation;
 exports.useSymmUpnlWebSocket = useSymmUpnlWebSocket;
 exports.useSymmWithdraw = useSymmWithdraw;
+exports.useSymmWithdrawalConfig = useSymmWithdrawalConfig;
 exports.useSymmWsStore = useSymmWsStore;
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map