@oasisprotocol/privana-sdk 0.2.0

package/dist/index.cjs

@@ -0,0 +1,4438 @@
+"use client";
+'use strict';
+
+var react = require('react');
+var viem = require('viem');
+var jsxRuntime = require('react/jsx-runtime');
+var reactQuery = require('@tanstack/react-query');
+var clsx = require('clsx');
+var tailwindMerge = require('tailwind-merge');
+var siwe = require('viem/siwe');
+var wagmi = require('wagmi');
+var actions = require('wagmi/actions');
+var actions$1 = require('viem/actions');
+var reactSlot = require('@radix-ui/react-slot');
+var classVarianceAuthority = require('class-variance-authority');
+var DialogPrimitive = require('@radix-ui/react-dialog');
+var lucideReact = require('lucide-react');
+var sonner = require('sonner');
+
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+
+var DialogPrimitive__namespace = /*#__PURE__*/_interopNamespace(DialogPrimitive);
+
+// ../../shared/config.json
+var config_default = {
+  chains: [
+    {
+      id: 84532,
+      name: "Base Sepolia",
+      explorerUrl: "https://sepolia.basescan.org"
+    }
+  ],
+  networks: {
+    testnet: {
+      chainId: 23295,
+      name: "Sapphire Testnet",
+      accountingContract: "0xaF8e5de153A584528B57DD4B9B0195956BBDF571",
+      apiUrl: "https://flexvaults-staging.rofl.build"
+    },
+    mainnet: {
+      chainId: 23294,
+      name: "Sapphire Mainnet",
+      accountingContract: "0x0000000000000000000000000000000000000000",
+      apiUrl: ""
+    }
+  }
+};
+
+// src/sdk/types/common.ts
+var NETWORK_CONFIG = {
+  testnet: {
+    ...config_default.networks.testnet,
+    accountingContract: config_default.networks.testnet.accountingContract
+  },
+  mainnet: {
+    ...config_default.networks.mainnet,
+    accountingContract: config_default.networks.mainnet.accountingContract
+  }
+};
+function getChainId(network) {
+  return NETWORK_CONFIG[network].chainId;
+}
+function getAccountingContract(network) {
+  return NETWORK_CONFIG[network].accountingContract;
+}
+function getApiUrl(network) {
+  return NETWORK_CONFIG[network].apiUrl;
+}
+function normalizeHex(value) {
+  const normalized = value.trim().toLowerCase();
+  return normalized.startsWith("0x") ? normalized : `0x${normalized}`;
+}
+function normalizeAddress(value) {
+  return normalizeHex(value);
+}
+
+// src/sdk/types/chains.ts
+var SUPPORTED_CHAINS = config_default.chains.map((chain) => ({
+  id: chain.id,
+  name: chain.name,
+  explorerUrl: chain.explorerUrl
+}));
+function getChainById(chainId) {
+  return SUPPORTED_CHAINS.find((c) => c.id === chainId);
+}
+function getExplorerAddressUrl(chainId, address) {
+  const chain = getChainById(chainId);
+  if (!chain) return void 0;
+  return `${chain.explorerUrl}/address/${address}#tokentxns`;
+}
+
+// src/sdk/auth/hosted-auth.ts
+var HOSTED_AUTH_CLOCK_SKEW_MS = 3e4;
+var PKCE_CHARSET = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-._~";
+var DEFAULT_RANDOM_LENGTH = 64;
+var HOSTED_AUTH_CALLBACK_QUERY_KEYS = ["code", "error", "error_description", "state"];
+function randomString(length) {
+  const values = new Uint8Array(length);
+  crypto.getRandomValues(values);
+  let output = "";
+  for (const value of values) {
+    output += PKCE_CHARSET[value % PKCE_CHARSET.length];
+  }
+  return output;
+}
+function toBase64Url(bytes) {
+  let binary = "";
+  bytes.forEach((byte) => {
+    binary += String.fromCharCode(byte);
+  });
+  return btoa(binary).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/g, "");
+}
+function createPkceVerifier(length = DEFAULT_RANDOM_LENGTH) {
+  return randomString(length);
+}
+async function createPkceChallenge(verifier) {
+  const digest = await crypto.subtle.digest("SHA-256", new TextEncoder().encode(verifier));
+  return toBase64Url(new Uint8Array(digest));
+}
+function createHostedAuthState(length = DEFAULT_RANDOM_LENGTH) {
+  return randomString(length);
+}
+function createHostedAuthStorageKey(apiUrl, config) {
+  const normalizedApiUrl = apiUrl.replace(/\/$/, "");
+  return [
+    "privana",
+    "hosted-auth",
+    normalizedApiUrl,
+    config.clientId.trim(),
+    config.redirectUri.trim()
+  ].join(":");
+}
+function createHostedAuthPendingStorageKey(apiUrl, config) {
+  return `${createHostedAuthStorageKey(apiUrl, config)}:pending`;
+}
+function persistHostedAuthPendingTransaction(storage, key, transaction) {
+  storage.setItem(key, JSON.stringify(transaction));
+}
+function readHostedAuthPendingTransaction(storage, key) {
+  const raw = storage.getItem(key);
+  if (!raw) return null;
+  try {
+    const parsed = JSON.parse(raw);
+    if (typeof parsed.codeVerifier !== "string" || typeof parsed.state !== "string") {
+      return null;
+    }
+    return {
+      codeVerifier: parsed.codeVerifier,
+      state: parsed.state
+    };
+  } catch {
+    return null;
+  }
+}
+function clearHostedAuthPendingTransaction(storage, key) {
+  storage.removeItem(key);
+}
+function parseHostedAuthCallback(url, redirectUri) {
+  const expectedUrl = new URL(redirectUri);
+  if (url.origin !== expectedUrl.origin || url.pathname !== expectedUrl.pathname) {
+    return null;
+  }
+  const code = url.searchParams.get("code");
+  if (code) {
+    return {
+      code,
+      state: url.searchParams.get("state")
+    };
+  }
+  const error = url.searchParams.get("error");
+  if (error) {
+    return {
+      error,
+      errorDescription: url.searchParams.get("error_description") ?? void 0,
+      state: url.searchParams.get("state")
+    };
+  }
+  return null;
+}
+function stripHostedAuthCallbackParams(url) {
+  const nextUrl = new URL(url.toString());
+  HOSTED_AUTH_CALLBACK_QUERY_KEYS.forEach((key) => {
+    nextUrl.searchParams.delete(key);
+  });
+  return `${nextUrl.pathname}${nextUrl.search}${nextUrl.hash}`;
+}
+function buildHostedAuthSession(response, config, now = Date.now()) {
+  return {
+    accessToken: response.access_token,
+    refreshToken: response.refresh_token,
+    idToken: response.id_token,
+    tokenType: response.token_type,
+    address: response.address,
+    clientId: config.clientId,
+    redirectUri: config.redirectUri,
+    expiresAt: now + response.expires_in * 1e3,
+    refreshExpiresAt: now + response.refresh_expires_in * 1e3
+  };
+}
+function applyRefreshResponse(session, response, now = Date.now()) {
+  return {
+    ...session,
+    accessToken: response.token,
+    refreshToken: response.refresh_token,
+    expiresAt: now + response.expires_in * 1e3,
+    refreshExpiresAt: now + response.refresh_expires_in * 1e3
+  };
+}
+function isHostedAuthSessionActive(session, now = Date.now(), skewMs = HOSTED_AUTH_CLOCK_SKEW_MS) {
+  return session.expiresAt > now + skewMs;
+}
+function isHostedAuthRefreshActive(session, now = Date.now(), skewMs = HOSTED_AUTH_CLOCK_SKEW_MS) {
+  return session.refreshExpiresAt > now + skewMs;
+}
+
+// src/sdk/client/errors.ts
+var AccountingApiError = class _AccountingApiError extends Error {
+  constructor(message, statusCode, detail) {
+    super(message);
+    this.statusCode = statusCode;
+    this.detail = detail;
+    this.name = "AccountingApiError";
+    Object.setPrototypeOf(this, _AccountingApiError.prototype);
+  }
+};
+var NetworkError = class _NetworkError extends Error {
+  constructor(message, cause) {
+    super(message);
+    this.cause = cause;
+    this.name = "NetworkError";
+    Object.setPrototypeOf(this, _NetworkError.prototype);
+  }
+};
+var ValidationError = class _ValidationError extends Error {
+  constructor(message, field) {
+    super(message);
+    this.field = field;
+    this.name = "ValidationError";
+    Object.setPrototypeOf(this, _ValidationError.prototype);
+  }
+};
+var HostedAuthError = class _HostedAuthError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "HostedAuthError";
+    Object.setPrototypeOf(this, _HostedAuthError.prototype);
+  }
+};
+var HostedAuthRequiredError = class _HostedAuthRequiredError extends HostedAuthError {
+  constructor(message = "Hosted redirect authentication is required. Start login with useHostedRedirectAuth().") {
+    super(message);
+    this.name = "HostedAuthRequiredError";
+    Object.setPrototypeOf(this, _HostedAuthRequiredError.prototype);
+  }
+};
+var HostedAuthStateMismatchError = class _HostedAuthStateMismatchError extends HostedAuthError {
+  constructor(message = "Hosted authentication returned an invalid state value.") {
+    super(message);
+    this.name = "HostedAuthStateMismatchError";
+    Object.setPrototypeOf(this, _HostedAuthStateMismatchError.prototype);
+  }
+};
+
+// src/sdk/client/http-client.ts
+var HttpClient = class {
+  constructor(config) {
+    this.baseUrl = config.baseUrl.replace(/\/$/, "");
+    this.timeout = config.timeout ?? 3e4;
+    this.headers = {
+      "Content-Type": "application/json",
+      ...config.headers
+    };
+  }
+  async get(path) {
+    return this.request("GET", path);
+  }
+  async post(path, body) {
+    return this.request("POST", path, body);
+  }
+  getBaseUrl() {
+    return this.baseUrl;
+  }
+  setHeader(name, value) {
+    this.headers[name] = value;
+  }
+  removeHeader(name) {
+    delete this.headers[name];
+  }
+  getHeader(name) {
+    return this.headers[name];
+  }
+  async request(method, path, body) {
+    const url = `${this.baseUrl}${path}`;
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+    try {
+      const response = await fetch(url, {
+        method,
+        headers: this.headers,
+        body: body ? JSON.stringify(body) : void 0,
+        signal: controller.signal
+      });
+      clearTimeout(timeoutId);
+      if (!response.ok) {
+        let detail;
+        try {
+          const errorBody = await response.json();
+          detail = errorBody.detail || errorBody.error_description || errorBody.message;
+        } catch {
+          detail = await response.text().catch(() => void 0);
+        }
+        throw new AccountingApiError(
+          `API request failed: ${response.status} ${response.statusText}`,
+          response.status,
+          detail
+        );
+      }
+      return response.json();
+    } catch (error) {
+      clearTimeout(timeoutId);
+      if (error instanceof AccountingApiError) {
+        throw error;
+      }
+      if (error instanceof Error) {
+        if (error.name === "AbortError") {
+          throw new NetworkError(`Request timeout after ${this.timeout}ms`);
+        }
+        throw new NetworkError(`Network request failed: ${error.message}`, error);
+      }
+      throw new NetworkError("Unknown network error occurred");
+    }
+  }
+};
+
+// src/sdk/client/privana-client.ts
+var PRIVATE_READ_TOKEN_HEADER = "X-SIWE-Token";
+var MAX_BATCH_BALANCE_TOKEN_IDS = 100;
+var MAX_HISTORY_PAGE_SIZE = 100;
+var PrivanaClient = class {
+  constructor(config) {
+    this.http = new HttpClient(config);
+  }
+  getBaseUrl() {
+    return this.http.getBaseUrl();
+  }
+  async getDepositAddress(request = {}) {
+    return this.http.post("/v1/accounting/deposits/address", {
+      chain_type: request.chain_type ?? "evm",
+      version: request.version ?? 0
+    });
+  }
+  async checkDeposit(request) {
+    return this.http.post("/v1/accounting/deposits/check", {
+      chain_type: request.chain_type ?? "evm",
+      chain_id: request.chain_id,
+      tx_hash: normalizeHex(request.tx_hash),
+      amount: String(request.amount),
+      log_index: request.log_index ?? 0,
+      version: request.version ?? 0
+    });
+  }
+  async getDepositStatus(depositId) {
+    return this.http.get(`/v1/accounting/deposits/status/${depositId}`);
+  }
+  async getBalance(tokenId) {
+    const token = normalizeHex(tokenId);
+    return this.http.get(`/v1/accounting/balances/${token}`);
+  }
+  async getBatchBalances(request) {
+    if (request.token_ids.length > MAX_BATCH_BALANCE_TOKEN_IDS) {
+      throw new Error(
+        `Batch balance requests support at most ${MAX_BATCH_BALANCE_TOKEN_IDS} token IDs`
+      );
+    }
+    return this.http.post("/v1/accounting/balances/batch", {
+      token_ids: request.token_ids.map((id) => normalizeHex(id))
+    });
+  }
+  async getHistory(request = {}) {
+    const offset = request.offset ?? -1;
+    const limit = request.limit ?? 50;
+    if (!Number.isSafeInteger(offset)) {
+      throw new Error("History offset must be an integer");
+    }
+    if (!Number.isSafeInteger(limit)) {
+      throw new Error("History limit must be an integer");
+    }
+    if (limit < 0 || limit > MAX_HISTORY_PAGE_SIZE) {
+      throw new Error(`History requests support between 0 and ${MAX_HISTORY_PAGE_SIZE} entries`);
+    }
+    const params = new URLSearchParams({
+      offset: String(offset),
+      limit: String(limit)
+    });
+    return this.http.get(`/v1/accounting/history?${params.toString()}`);
+  }
+  async listTokens() {
+    return this.http.get("/v1/accounting/tokens");
+  }
+  async getTokenInfo(tokenId) {
+    const token = normalizeHex(tokenId);
+    return this.http.get(`/v1/accounting/tokens/${token}`);
+  }
+  async lockFunds(request) {
+    return this.http.post("/v1/accounting/funds/lock", {
+      service_address: normalizeAddress(request.service_address),
+      token_id: normalizeHex(request.token_id),
+      amount: String(request.amount),
+      expiry: String(request.expiry),
+      nonce: String(request.nonce),
+      signature: normalizeHex(request.signature)
+    });
+  }
+  async modifyLock(request) {
+    return this.http.post("/v1/accounting/funds/modify-lock", {
+      lock_id: request.lock_id,
+      amount: String(request.amount),
+      new_expiry: String(request.new_expiry),
+      nonce: String(request.nonce),
+      signature: normalizeHex(request.signature)
+    });
+  }
+  async unlockFunds(request) {
+    return this.http.post("/v1/accounting/funds/unlock", {
+      user_address: normalizeAddress(request.user_address),
+      lock_id: request.lock_id
+    });
+  }
+  async unlockAllExpired(request) {
+    return this.http.post(
+      "/v1/accounting/funds/unlock-all-expired",
+      {
+        user_address: normalizeAddress(request.user_address)
+      }
+    );
+  }
+  async getLockedFunds(serviceAddress) {
+    const queryParams = serviceAddress ? `?service_address=${normalizeAddress(serviceAddress)}` : "";
+    return this.http.get(`/v1/accounting/funds/locked${queryParams}`);
+  }
+  async getTotalLockedBalance(tokenId) {
+    const token = normalizeHex(tokenId);
+    return this.http.get(`/v1/accounting/funds/locked/total/${token}`);
+  }
+  async getExpiredLocks() {
+    return this.http.get("/v1/accounting/funds/expired");
+  }
+  async transferFunds(request) {
+    return this.http.post("/v1/accounting/funds/transfer", {
+      to_address: normalizeAddress(request.to_address),
+      token_id: normalizeHex(request.token_id),
+      amount: String(request.amount),
+      nonce: String(request.nonce),
+      signature: normalizeHex(request.signature)
+    });
+  }
+  async getTransferNonce(userAddress) {
+    const user = normalizeAddress(userAddress);
+    return this.http.get(`/v1/accounting/funds/transfer/nonce/${user}`);
+  }
+  async getLockNonce(userAddress) {
+    const user = normalizeAddress(userAddress);
+    return this.http.get(`/v1/accounting/funds/lock/nonce/${user}`);
+  }
+  async getModifyLockNonce(userAddress) {
+    const user = normalizeAddress(userAddress);
+    return this.http.get(`/v1/accounting/funds/modify-lock/nonce/${user}`);
+  }
+  async transferLockedFunds(request) {
+    return this.http.post("/v1/accounting/funds/transfer-locked", {
+      user_address: normalizeAddress(request.user_address),
+      lock_id: request.lock_id,
+      to_address: normalizeAddress(request.to_address),
+      amount: String(request.amount),
+      service_address: normalizeAddress(request.service_address),
+      nonce: String(request.nonce),
+      signature: normalizeHex(request.signature)
+    });
+  }
+  async withdrawFromLock(request) {
+    return this.http.post(
+      "/v1/accounting/funds/withdraw-from-lock",
+      {
+        to_address: normalizeAddress(request.to_address),
+        lock_id: request.lock_id,
+        amount: String(request.amount),
+        nonce: String(request.nonce),
+        signature: normalizeHex(request.signature)
+      }
+    );
+  }
+  async requestWithdrawal(request) {
+    return this.http.post("/v1/accounting/withdraw", {
+      token_id: normalizeHex(request.token_id),
+      amount: String(request.amount),
+      nonce: String(request.nonce),
+      signature: normalizeHex(request.signature)
+    });
+  }
+  async getWithdrawalNonce(userAddress) {
+    const user = normalizeAddress(userAddress);
+    return this.http.get(`/v1/accounting/withdraw/nonce/${user}`);
+  }
+  async getTransferLockedNonce(serviceAddress) {
+    const service = normalizeAddress(serviceAddress);
+    return this.http.get(
+      `/v1/accounting/funds/transfer-locked/nonce/${service}`
+    );
+  }
+  async getPendingWithdrawals(userAddress) {
+    const user = normalizeAddress(userAddress);
+    return this.http.get(`/v1/accounting/withdraw/pending/${user}`);
+  }
+  async getWithdrawalInfo(index) {
+    return this.http.get(`/v1/accounting/withdraw/${index}`);
+  }
+  async getSiweDomain() {
+    return this.http.get("/v1/accounting/auth/domain");
+  }
+  async getSiweNonce(userAddress) {
+    const user = normalizeAddress(userAddress);
+    return this.http.get(`/v1/accounting/auth/nonce?address=${user}`);
+  }
+  async loginWithSiwe(request) {
+    return this.http.post("/v1/accounting/auth/login", {
+      siwe_message: request.siwe_message,
+      signature: normalizeHex(request.signature)
+    });
+  }
+  getHostedAuthAuthorizeUrl(request) {
+    const url = new URL(
+      "v1/accounting/auth/authorize",
+      `${this.http.getBaseUrl().replace(/\/$/, "")}/`
+    );
+    url.searchParams.set("client_id", request.client_id);
+    url.searchParams.set("redirect_uri", request.redirect_uri);
+    url.searchParams.set("code_challenge", request.code_challenge);
+    url.searchParams.set("state", request.state);
+    url.searchParams.set("chain_id", String(request.chain_id));
+    url.searchParams.set("response_mode", request.response_mode ?? "redirect");
+    url.searchParams.set("code_challenge_method", request.code_challenge_method ?? "S256");
+    return url.toString();
+  }
+  async exchangeHostedAuthCode(request) {
+    return this.http.post("/v1/accounting/auth/token", {
+      grant_type: request.grant_type ?? "authorization_code",
+      code: request.code,
+      code_verifier: request.code_verifier,
+      client_id: request.client_id,
+      redirect_uri: request.redirect_uri
+    });
+  }
+  async refreshJwtSession(request) {
+    return this.http.post("/v1/accounting/auth/jwt/refresh", {
+      refresh_token: request.refresh_token
+    });
+  }
+  async logoutJwtSession(request = {}) {
+    return this.http.post("/v1/accounting/auth/jwt/logout", {
+      refresh_token: request.refresh_token,
+      revoke_all: request.revoke_all ?? false
+    });
+  }
+  setPrivateReadToken(token) {
+    this.http.removeHeader("Authorization");
+    this.http.setHeader(PRIVATE_READ_TOKEN_HEADER, token);
+  }
+  getPrivateReadToken() {
+    return this.http.getHeader(PRIVATE_READ_TOKEN_HEADER);
+  }
+  clearPrivateReadToken() {
+    this.http.removeHeader(PRIVATE_READ_TOKEN_HEADER);
+  }
+  setBearerToken(token) {
+    this.http.removeHeader(PRIVATE_READ_TOKEN_HEADER);
+    this.http.setHeader("Authorization", `Bearer ${token}`);
+  }
+  clearBearerToken() {
+    this.http.removeHeader("Authorization");
+  }
+};
+
+// src/sdk/signatures/eip712-types.ts
+function createDomain(chainId, verifyingContract) {
+  return {
+    name: "AccountingModule",
+    version: "1",
+    chainId,
+    verifyingContract
+  };
+}
+var LOCK_TYPES = {
+  Lock: [
+    { name: "serviceAddress", type: "address" },
+    { name: "tokenId", type: "bytes32" },
+    { name: "amount", type: "uint256" },
+    { name: "expiry", type: "uint256" },
+    { name: "nonce", type: "uint256" }
+  ]
+};
+var TRANSFER_TYPES = {
+  Transfer: [
+    { name: "toAddress", type: "address" },
+    { name: "tokenId", type: "bytes32" },
+    { name: "amount", type: "uint256" },
+    { name: "nonce", type: "uint256" }
+  ]
+};
+var TRANSFER_LOCKED_TYPES = {
+  TransferLocked: [
+    { name: "userAddress", type: "address" },
+    { name: "toAddress", type: "address" },
+    { name: "lockId", type: "uint256" },
+    { name: "amount", type: "uint256" },
+    { name: "nonce", type: "uint256" },
+    { name: "serviceAddress", type: "address" }
+  ]
+};
+var WITHDRAW_TYPES = {
+  Withdraw: [
+    { name: "tokenId", type: "bytes32" },
+    { name: "amount", type: "uint256" },
+    { name: "nonce", type: "uint256" }
+  ]
+};
+var MODIFY_LOCK_TYPES = {
+  ModifyLock: [
+    { name: "lockId", type: "uint256" },
+    { name: "amount", type: "uint256" },
+    { name: "newExpiry", type: "uint256" },
+    { name: "nonce", type: "uint256" }
+  ]
+};
+var WITHDRAW_FROM_LOCK_TYPES = {
+  WithdrawFromLock: [
+    { name: "userAddress", type: "address" },
+    { name: "toAddress", type: "address" },
+    { name: "lockId", type: "uint256" },
+    { name: "amount", type: "uint256" },
+    { name: "nonce", type: "uint256" }
+  ]
+};
+
+// src/sdk/signatures/sign-lock.ts
+async function signLockMessage({
+  walletClient,
+  chainId,
+  verifyingContract,
+  message
+}) {
+  const account = walletClient.account;
+  if (!account) {
+    throw new Error("No account connected to wallet client");
+  }
+  const domain = createDomain(chainId, verifyingContract);
+  const signature = await walletClient.signTypedData({
+    account,
+    domain,
+    types: LOCK_TYPES,
+    primaryType: "Lock",
+    message
+  });
+  return signature;
+}
+function createLockExpiry(minutesFromNow = 60) {
+  return BigInt(Math.floor(Date.now() / 1e3) + minutesFromNow * 60);
+}
+
+// src/sdk/signatures/sign-modify-lock.ts
+async function signModifyLockMessage({
+  walletClient,
+  chainId,
+  verifyingContract,
+  message
+}) {
+  const account = walletClient.account;
+  if (!account) {
+    throw new Error("No account connected to wallet client");
+  }
+  const domain = createDomain(chainId, verifyingContract);
+  const signature = await walletClient.signTypedData({
+    account,
+    domain,
+    types: MODIFY_LOCK_TYPES,
+    primaryType: "ModifyLock",
+    message
+  });
+  return signature;
+}
+
+// src/sdk/signatures/sign-transfer.ts
+async function signTransferMessage({
+  walletClient,
+  chainId,
+  verifyingContract,
+  message
+}) {
+  const account = walletClient.account;
+  if (!account) {
+    throw new Error("No account connected to wallet client");
+  }
+  const domain = createDomain(chainId, verifyingContract);
+  const signature = await walletClient.signTypedData({
+    account,
+    domain,
+    types: TRANSFER_TYPES,
+    primaryType: "Transfer",
+    message
+  });
+  return signature;
+}
+
+// src/sdk/signatures/sign-transfer-locked.ts
+async function signTransferLockedMessage({
+  walletClient,
+  chainId,
+  verifyingContract,
+  message
+}) {
+  const account = walletClient.account;
+  if (!account) {
+    throw new Error("No account connected to wallet client");
+  }
+  const domain = createDomain(chainId, verifyingContract);
+  const signature = await walletClient.signTypedData({
+    account,
+    domain,
+    types: TRANSFER_LOCKED_TYPES,
+    primaryType: "TransferLocked",
+    message
+  });
+  return signature;
+}
+
+// src/sdk/signatures/sign-withdraw.ts
+async function signWithdrawMessage({
+  walletClient,
+  chainId,
+  verifyingContract,
+  message
+}) {
+  const account = walletClient.account;
+  if (!account) {
+    throw new Error("No account connected to wallet client");
+  }
+  const domain = createDomain(chainId, verifyingContract);
+  const signature = await walletClient.signTypedData({
+    account,
+    domain,
+    types: WITHDRAW_TYPES,
+    primaryType: "Withdraw",
+    message
+  });
+  return signature;
+}
+
+// src/sdk/signatures/sign-withdraw-from-lock.ts
+async function signWithdrawFromLockMessage({
+  walletClient,
+  chainId,
+  verifyingContract,
+  message
+}) {
+  const account = walletClient.account;
+  if (!account) {
+    throw new Error("No account connected to wallet client");
+  }
+  const domain = createDomain(chainId, verifyingContract);
+  const signature = await walletClient.signTypedData({
+    account,
+    domain,
+    types: WITHDRAW_FROM_LOCK_TYPES,
+    primaryType: "WithdrawFromLock",
+    message
+  });
+  return signature;
+}
+var PrivanaContext = react.createContext(null);
+function readStoredHostedAuthSession(storage, hostedAuthStorageKey, now = Date.now()) {
+  const raw = storage.getItem(hostedAuthStorageKey);
+  if (!raw) {
+    return null;
+  }
+  try {
+    const parsed = JSON.parse(raw);
+    if (!isHostedAuthRefreshActive(parsed, now, 0)) {
+      storage.removeItem(hostedAuthStorageKey);
+      return null;
+    }
+    return parsed;
+  } catch {
+    storage.removeItem(hostedAuthStorageKey);
+    return null;
+  }
+}
+function syncHostedAuthSessionToClient(client, hostedAuthConfig, hostedAuthSession) {
+  if (!hostedAuthConfig) {
+    client.clearBearerToken();
+    client.clearPrivateReadToken();
+    return;
+  }
+  if (hostedAuthSession && isHostedAuthSessionActive(hostedAuthSession)) {
+    client.setBearerToken(hostedAuthSession.accessToken);
+    client.clearPrivateReadToken();
+    return;
+  }
+  client.clearBearerToken();
+  client.clearPrivateReadToken();
+}
+var DEFAULT_NETWORK_CONFIG = NETWORK_CONFIG.testnet;
+function PrivanaProvider({
+  children,
+  networkConfig: networkConfigOverride,
+  tokens,
+  chains,
+  pollingInterval = 1e4,
+  serviceAddress,
+  hostedAuth
+}) {
+  const networkConfig = react.useMemo(() => {
+    const config = {
+      ...DEFAULT_NETWORK_CONFIG,
+      ...networkConfigOverride
+    };
+    if (!config.chainId || config.chainId <= 0) {
+      throw new Error("PrivanaProvider: networkConfig.chainId must be a positive number");
+    }
+    if (!config.accountingContract || !config.accountingContract.startsWith("0x")) {
+      throw new Error("PrivanaProvider: networkConfig.accountingContract must be a valid address");
+    }
+    if (!config.apiUrl) {
+      throw new Error("PrivanaProvider: networkConfig.apiUrl must be provided");
+    }
+    return config;
+  }, [
+    networkConfigOverride?.chainId,
+    networkConfigOverride?.name,
+    networkConfigOverride?.accountingContract,
+    networkConfigOverride?.apiUrl
+  ]);
+  const resolvedChains = react.useMemo(() => {
+    if (chains && chains.length > 0) return chains;
+    return SUPPORTED_CHAINS;
+  }, [chains]);
+  const client = react.useMemo(
+    () => new PrivanaClient({ baseUrl: networkConfig.apiUrl }),
+    [networkConfig.apiUrl]
+  );
+  const [allTokens, setAllTokens] = react.useState([]);
+  const [tokensStatus, setTokensStatus] = react.useState("loading");
+  const [tokensError, setTokensError] = react.useState();
+  react.useEffect(() => {
+    setTokensStatus("loading");
+    setTokensError(void 0);
+    client.listTokens().then(({ tokens: list }) => {
+      setAllTokens(
+        list.map((t) => ({
+          id: t.token_id,
+          symbol: t.symbol,
+          decimals: t.decimals,
+          contract: t.token_address ?? viem.zeroAddress,
+          name: t.name,
+          chainId: t.chain_id
+        }))
+      );
+      setTokensStatus("ready");
+    }).catch((err) => {
+      setTokensError(err instanceof Error ? err : new Error(String(err)));
+      setTokensStatus("error");
+    });
+  }, [client]);
+  const enabledTokens = react.useMemo(() => {
+    if (tokens && tokens.length > 0) {
+      const allowed = new Set(tokens.map((id) => id.toLowerCase()));
+      return allTokens.filter((t) => allowed.has(t.id.toLowerCase()));
+    }
+    return allTokens;
+  }, [allTokens, tokens]);
+  const tokenById = react.useMemo(
+    () => Object.fromEntries(enabledTokens.map((t) => [t.id.toLowerCase(), t])),
+    [enabledTokens]
+  );
+  const getTokenById = react.useMemo(() => (id) => tokenById[id.toLowerCase()], [tokenById]);
+  const chainById = react.useMemo(
+    () => Object.fromEntries(resolvedChains.map((c) => [c.id, c])),
+    [resolvedChains]
+  );
+  const getChainById2 = react.useMemo(() => (id) => chainById[id], [chainById]);
+  const hostedAuthConfig = react.useMemo(() => {
+    if (!hostedAuth) return null;
+    const clientId = hostedAuth.clientId.trim();
+    const redirectUri = hostedAuth.redirectUri.trim();
+    if (!clientId) {
+      throw new Error(
+        "PrivanaProvider: hostedAuth.clientId must be provided when hostedAuth is enabled"
+      );
+    }
+    if (!redirectUri) {
+      throw new Error(
+        "PrivanaProvider: hostedAuth.redirectUri must be provided when hostedAuth is enabled"
+      );
+    }
+    return {
+      clientId,
+      redirectUri
+    };
+  }, [hostedAuth]);
+  const hostedAuthStorageKey = react.useMemo(
+    () => hostedAuthConfig ? createHostedAuthStorageKey(networkConfig.apiUrl, hostedAuthConfig) : null,
+    [hostedAuthConfig, networkConfig.apiUrl]
+  );
+  const [hostedAuthSession, setHostedAuthSessionState] = react.useState(null);
+  const hostedAuthSessionRef = react.useRef(null);
+  const hostedAuthStateVersionRef = react.useRef(0);
+  const hostedAuthRefreshInflight = react.useRef(null);
+  const clearHostedAuthSession = react.useCallback(() => {
+    hostedAuthStateVersionRef.current += 1;
+    hostedAuthSessionRef.current = null;
+    hostedAuthRefreshInflight.current = null;
+    setHostedAuthSessionState(null);
+    client.clearBearerToken();
+    client.clearPrivateReadToken();
+    if (hostedAuthStorageKey && typeof window !== "undefined") {
+      window.sessionStorage.removeItem(hostedAuthStorageKey);
+    }
+  }, [client, hostedAuthStorageKey]);
+  const setHostedAuthSession = react.useCallback(
+    (session) => {
+      if (!session) {
+        clearHostedAuthSession();
+        return;
+      }
+      hostedAuthStateVersionRef.current += 1;
+      hostedAuthSessionRef.current = session;
+      setHostedAuthSessionState(session);
+      if (isHostedAuthSessionActive(session)) {
+        client.setBearerToken(session.accessToken);
+      } else {
+        client.clearBearerToken();
+      }
+      client.clearPrivateReadToken();
+      if (hostedAuthStorageKey && typeof window !== "undefined") {
+        window.sessionStorage.setItem(hostedAuthStorageKey, JSON.stringify(session));
+      }
+    },
+    [clearHostedAuthSession, client, hostedAuthStorageKey]
+  );
+  const refreshHostedAuthSession = react.useCallback(async () => {
+    if (!hostedAuthConfig) {
+      throw new HostedAuthRequiredError(
+        "Hosted redirect authentication is not configured for this provider."
+      );
+    }
+    const currentSession = hostedAuthSessionRef.current;
+    if (!currentSession) {
+      throw new HostedAuthRequiredError();
+    }
+    if (!isHostedAuthRefreshActive(currentSession)) {
+      clearHostedAuthSession();
+      throw new HostedAuthRequiredError(
+        "Hosted redirect authentication has expired. Start login again."
+      );
+    }
+    if (hostedAuthRefreshInflight.current) {
+      return hostedAuthRefreshInflight.current;
+    }
+    const refreshPromise = (async () => {
+      const refreshVersion = hostedAuthStateVersionRef.current;
+      try {
+        const response = await client.refreshJwtSession({
+          refresh_token: currentSession.refreshToken
+        });
+        if (refreshVersion !== hostedAuthStateVersionRef.current) {
+          const latestSession = hostedAuthSessionRef.current;
+          if (latestSession) {
+            return latestSession;
+          }
+          throw new HostedAuthRequiredError(
+            "Hosted redirect authentication has changed. Start login again."
+          );
+        }
+        const nextSession = applyRefreshResponse(currentSession, response);
+        setHostedAuthSession(nextSession);
+        return nextSession;
+      } catch (error) {
+        if (refreshVersion === hostedAuthStateVersionRef.current) {
+          clearHostedAuthSession();
+        }
+        throw error;
+      } finally {
+        hostedAuthRefreshInflight.current = null;
+      }
+    })();
+    hostedAuthRefreshInflight.current = refreshPromise;
+    return refreshPromise;
+  }, [clearHostedAuthSession, client, hostedAuthConfig, setHostedAuthSession]);
+  react.useEffect(() => {
+    hostedAuthSessionRef.current = hostedAuthSession;
+  }, [hostedAuthSession]);
+  react.useEffect(() => {
+    if (!hostedAuthStorageKey || typeof window === "undefined") {
+      hostedAuthStateVersionRef.current += 1;
+      hostedAuthSessionRef.current = null;
+      hostedAuthRefreshInflight.current = null;
+      setHostedAuthSessionState(null);
+      return;
+    }
+    const restoredSession = readStoredHostedAuthSession(window.sessionStorage, hostedAuthStorageKey);
+    hostedAuthStateVersionRef.current += 1;
+    hostedAuthSessionRef.current = restoredSession;
+    hostedAuthRefreshInflight.current = null;
+    setHostedAuthSessionState(restoredSession);
+  }, [hostedAuthStorageKey]);
+  react.useEffect(() => {
+    syncHostedAuthSessionToClient(client, hostedAuthConfig, hostedAuthSession);
+  }, [client, hostedAuthConfig, hostedAuthSession]);
+  const value = react.useMemo(
+    () => ({
+      client,
+      networkConfig,
+      enabledTokens,
+      defaultToken: enabledTokens[0],
+      getTokenById,
+      getChainById: getChainById2,
+      chains: resolvedChains,
+      tokensStatus,
+      tokensError,
+      pollingInterval,
+      serviceAddress,
+      hostedAuthConfig,
+      hostedAuthSession,
+      setHostedAuthSession,
+      clearHostedAuthSession,
+      refreshHostedAuthSession
+    }),
+    [
+      client,
+      networkConfig,
+      enabledTokens,
+      getTokenById,
+      getChainById2,
+      resolvedChains,
+      tokensStatus,
+      tokensError,
+      pollingInterval,
+      serviceAddress,
+      hostedAuthConfig,
+      hostedAuthSession,
+      setHostedAuthSession,
+      clearHostedAuthSession,
+      refreshHostedAuthSession
+    ]
+  );
+  return /* @__PURE__ */ jsxRuntime.jsx(PrivanaContext.Provider, { value, children });
+}
+function usePrivanaContext() {
+  const context = react.useContext(PrivanaContext);
+  if (!context) {
+    throw new Error("usePrivanaContext must be used within a PrivanaProvider");
+  }
+  return context;
+}
+function useSafePrivanaContext() {
+  return react.useContext(PrivanaContext);
+}
+
+// src/sdk/hooks/use-privana-client.ts
+function usePrivanaClient() {
+  const { client } = usePrivanaContext();
+  return client;
+}
+var hostedAuthExchangeInflight = /* @__PURE__ */ new Map();
+function normalizeHostedAuthError(error) {
+  if (error instanceof AccountingApiError && error.detail) {
+    return new HostedAuthError(error.detail);
+  }
+  if (error instanceof Error) {
+    return error;
+  }
+  return new HostedAuthError("Hosted authentication failed.");
+}
+function useHostedRedirectAuth() {
+  const {
+    client,
+    hostedAuthConfig,
+    hostedAuthSession,
+    networkConfig,
+    setHostedAuthSession,
+    clearHostedAuthSession,
+    refreshHostedAuthSession
+  } = usePrivanaContext();
+  const [error, setError] = react.useState(null);
+  const [isLoading, setIsLoading] = react.useState(false);
+  const loginInflight = react.useRef(null);
+  const completionInflight = react.useRef(null);
+  const pendingStorageKey = react.useMemo(
+    () => hostedAuthConfig ? createHostedAuthPendingStorageKey(client.getBaseUrl(), hostedAuthConfig) : null,
+    [client, hostedAuthConfig]
+  );
+  const clearPendingLogin = react.useCallback(() => {
+    if (!pendingStorageKey || typeof window === "undefined") return;
+    clearHostedAuthPendingTransaction(window.sessionStorage, pendingStorageKey);
+  }, [pendingStorageKey]);
+  const login = react.useCallback(async () => {
+    if (!hostedAuthConfig) {
+      throw new HostedAuthRequiredError(
+        "Hosted redirect authentication is not configured for this provider."
+      );
+    }
+    if (typeof window === "undefined") {
+      throw new HostedAuthError("Hosted redirect authentication requires a browser environment.");
+    }
+    if (!pendingStorageKey) {
+      throw new HostedAuthError("Hosted redirect authentication storage is not configured.");
+    }
+    if (loginInflight.current) {
+      return loginInflight.current;
+    }
+    const loginPromise = (async () => {
+      setIsLoading(true);
+      setError(null);
+      try {
+        const verifier = createPkceVerifier();
+        const codeChallenge = await createPkceChallenge(verifier);
+        const state = createHostedAuthState();
+        persistHostedAuthPendingTransaction(window.sessionStorage, pendingStorageKey, {
+          codeVerifier: verifier,
+          state
+        });
+        const authorizeUrl = client.getHostedAuthAuthorizeUrl({
+          client_id: hostedAuthConfig.clientId,
+          redirect_uri: hostedAuthConfig.redirectUri,
+          code_challenge: codeChallenge,
+          chain_id: networkConfig.chainId,
+          code_challenge_method: "S256",
+          response_mode: "redirect",
+          state
+        });
+        window.location.assign(authorizeUrl);
+      } catch (loginError) {
+        clearPendingLogin();
+        const normalizedError = normalizeHostedAuthError(loginError);
+        setError(normalizedError);
+        throw normalizedError;
+      } finally {
+        loginInflight.current = null;
+        setIsLoading(false);
+      }
+    })();
+    loginInflight.current = loginPromise;
+    return loginPromise;
+  }, [clearPendingLogin, client, hostedAuthConfig, networkConfig.chainId, pendingStorageKey]);
+  const completeLogin = react.useCallback(async () => {
+    if (!hostedAuthConfig) {
+      throw new HostedAuthRequiredError(
+        "Hosted redirect authentication is not configured for this provider."
+      );
+    }
+    if (typeof window === "undefined") {
+      throw new HostedAuthError("Hosted redirect authentication requires a browser environment.");
+    }
+    if (!pendingStorageKey) {
+      throw new HostedAuthError("Hosted redirect authentication storage is not configured.");
+    }
+    if (completionInflight.current) {
+      return completionInflight.current;
+    }
+    const completionPromise = (async () => {
+      setIsLoading(true);
+      setError(null);
+      const callbackUrl = new URL(window.location.href);
+      const cleanupCallbackUrl = () => {
+        window.history.replaceState(null, "", stripHostedAuthCallbackParams(callbackUrl));
+      };
+      try {
+        const callback = parseHostedAuthCallback(callbackUrl, hostedAuthConfig.redirectUri);
+        if (!callback) {
+          return null;
+        }
+        const pending = readHostedAuthPendingTransaction(window.sessionStorage, pendingStorageKey);
+        if (!pending) {
+          clearPendingLogin();
+          cleanupCallbackUrl();
+          throw new HostedAuthError(
+            "Hosted authentication response could not be matched to a pending login request."
+          );
+        }
+        if (!callback.state || callback.state !== pending.state) {
+          clearPendingLogin();
+          cleanupCallbackUrl();
+          throw new HostedAuthStateMismatchError();
+        }
+        if ("error" in callback) {
+          clearPendingLogin();
+          cleanupCallbackUrl();
+          throw new HostedAuthError(
+            callback.errorDescription || callback.error || "Hosted authentication failed."
+          );
+        }
+        const { codeVerifier } = pending;
+        const exchangeKey = `${pendingStorageKey}:${callback.code}:${pending.state}`;
+        let exchangePromise = hostedAuthExchangeInflight.get(exchangeKey);
+        if (!exchangePromise) {
+          exchangePromise = (async () => {
+            const response = await client.exchangeHostedAuthCode({
+              code: callback.code,
+              code_verifier: codeVerifier,
+              client_id: hostedAuthConfig.clientId,
+              redirect_uri: hostedAuthConfig.redirectUri
+            });
+            const session = buildHostedAuthSession(response, hostedAuthConfig);
+            setHostedAuthSession(session);
+            clearPendingLogin();
+            cleanupCallbackUrl();
+            return session;
+          })();
+          hostedAuthExchangeInflight.set(exchangeKey, exchangePromise);
+        }
+        try {
+          return await exchangePromise;
+        } finally {
+          if (hostedAuthExchangeInflight.get(exchangeKey) === exchangePromise) {
+            hostedAuthExchangeInflight.delete(exchangeKey);
+          }
+        }
+      } catch (completionError) {
+        const normalizedError = normalizeHostedAuthError(completionError);
+        setError(normalizedError);
+        throw normalizedError;
+      } finally {
+        completionInflight.current = null;
+        setIsLoading(false);
+      }
+    })();
+    completionInflight.current = completionPromise;
+    return completionPromise;
+  }, [clearPendingLogin, client, hostedAuthConfig, pendingStorageKey, setHostedAuthSession]);
+  const logout = react.useCallback(async () => {
+    setError(null);
+    try {
+      if (hostedAuthSession) {
+        await client.logoutJwtSession({
+          refresh_token: hostedAuthSession.refreshToken
+        });
+      }
+    } finally {
+      clearHostedAuthSession();
+    }
+  }, [clearHostedAuthSession, client, hostedAuthSession]);
+  const refresh = react.useCallback(async () => {
+    setIsLoading(true);
+    setError(null);
+    try {
+      return await refreshHostedAuthSession();
+    } catch (refreshError) {
+      const normalizedError = refreshError instanceof Error ? refreshError : new HostedAuthError("Hosted authentication refresh failed.");
+      setError(normalizedError);
+      throw normalizedError;
+    } finally {
+      setIsLoading(false);
+    }
+  }, [refreshHostedAuthSession]);
+  return {
+    session: hostedAuthSession,
+    isAuthenticated: !!hostedAuthSession,
+    isLoading,
+    error,
+    login,
+    completeLogin,
+    logout,
+    refresh
+  };
+}
+function cn(...inputs) {
+  return tailwindMerge.twMerge(clsx.clsx(inputs));
+}
+function formatTokenAmount(amount, decimals = 18) {
+  const value = typeof amount === "string" ? BigInt(amount) : amount;
+  const divisor = BigInt(10 ** decimals);
+  const integerPart = value / divisor;
+  const fractionalPart = value % divisor;
+  const fractionalStr = fractionalPart.toString().padStart(decimals, "0");
+  const twoDecimals = fractionalStr.slice(0, 2).padEnd(2, "0");
+  const integerWithSpaces = integerPart.toString().replace(/\B(?=(\d{3})+(?!\d))/g, "\u2009");
+  return `${integerWithSpaces}.${twoDecimals}`;
+}
+function parseTokenAmount(amount, decimals = 18) {
+  const sanitized = amount.replace(/[\s\u2009]/g, "").replace(/,/g, ".");
+  const lastDot = sanitized.lastIndexOf(".");
+  const integerPart = lastDot === -1 ? sanitized : sanitized.slice(0, lastDot).replace(/\./g, "");
+  const fractionalPart = lastDot === -1 ? "" : sanitized.slice(lastDot + 1);
+  const paddedFractional = fractionalPart.padEnd(decimals, "0").slice(0, decimals);
+  return BigInt(integerPart + paddedFractional);
+}
+function shortenAddress(address, chars = 4) {
+  if (!address || address.length < chars * 2 + 2) return address;
+  return `${address.slice(0, chars + 2)}...${address.slice(-chars)}`;
+}
+function formatTimeRemaining(expiryTimestamp) {
+  const now = Math.floor(Date.now() / 1e3);
+  const diff = expiryTimestamp - now;
+  if (diff <= 0) return "Expired";
+  const days = Math.floor(diff / 86400);
+  const hours = Math.floor(diff % 86400 / 3600);
+  const minutes = Math.floor(diff % 3600 / 60);
+  if (days > 0) {
+    return hours > 0 ? `${days}d ${hours}h left` : `${days}d left`;
+  }
+  if (hours > 0) {
+    return minutes > 0 ? `${hours}h ${minutes}m left` : `${hours}h left`;
+  }
+  return `${minutes}m left`;
+}
+var defaultResult = {
+  address: void 0,
+  isConnected: false
+};
+function useSafeAccount() {
+  const context = react.useContext(wagmi.WagmiContext);
+  const cacheRef = react.useRef(defaultResult);
+  const subscribe = react.useCallback(
+    (onChange) => {
+      if (!context) return () => {
+      };
+      return actions.watchAccount(context, { onChange });
+    },
+    [context]
+  );
+  const getSnapshot = react.useCallback(() => {
+    if (!context) return defaultResult;
+    const account = actions.getAccount(context);
+    if (cacheRef.current.address !== account.address || cacheRef.current.isConnected !== account.isConnected) {
+      cacheRef.current = { address: account.address, isConnected: account.isConnected };
+    }
+    return cacheRef.current;
+  }, [context]);
+  const getServerSnapshot = react.useCallback(() => defaultResult, []);
+  return react.useSyncExternalStore(subscribe, getSnapshot, getServerSnapshot);
+}
+
+// src/sdk/hooks/use-private-read-request.ts
+var AUTH_CLOCK_SKEW_MS = 3e4;
+var INITIAL_AUTH_BACKOFF_MS = 5e3;
+var MAX_AUTH_BACKOFF_MS = 6e4;
+var DEFAULT_SIWE_AUTH_VALIDITY_MS = 24 * 60 * 60 * 1e3;
+var PRIVATE_READ_STATEMENT = "Sign in to Privana to access private account data.";
+var privateReadTokenCache = /* @__PURE__ */ new Map();
+var privateReadFailureCache = /* @__PURE__ */ new Map();
+var privateReadInflight = /* @__PURE__ */ new Map();
+async function executeHostedAuthPrivateReadRequest({
+  client,
+  hostedAuthSession,
+  refreshHostedAuthSession,
+  request
+}) {
+  const ensureHostedAuth = async (forceRefresh) => {
+    if (!hostedAuthSession) {
+      throw new HostedAuthRequiredError();
+    }
+    if (!forceRefresh && isHostedAuthSessionActive(hostedAuthSession)) {
+      client.clearPrivateReadToken();
+      client.setBearerToken(hostedAuthSession.accessToken);
+      return hostedAuthSession.accessToken;
+    }
+    const refreshed = await refreshHostedAuthSession();
+    client.clearPrivateReadToken();
+    client.setBearerToken(refreshed.accessToken);
+    return refreshed.accessToken;
+  };
+  await ensureHostedAuth(false);
+  try {
+    return await request();
+  } catch (error) {
+    if (!(error instanceof AccountingApiError) || error.statusCode !== 401) {
+      throw error;
+    }
+    await ensureHostedAuth(true);
+    return request();
+  }
+}
+function createScopeKey(apiUrl, deploymentChainId, address) {
+  return `${apiUrl.replace(/\/$/, "")}:${deploymentChainId}:${address.toLowerCase()}`;
+}
+function getCachedPrivateReadToken(scopeKey) {
+  const cached = privateReadTokenCache.get(scopeKey);
+  if (!cached) return null;
+  if (cached.expiresAt <= Date.now() + AUTH_CLOCK_SKEW_MS) {
+    privateReadTokenCache.delete(scopeKey);
+    return null;
+  }
+  return cached.token;
+}
+function clearPrivateReadScope(scopeKey, client) {
+  privateReadTokenCache.delete(scopeKey);
+  privateReadFailureCache.delete(scopeKey);
+  client.clearPrivateReadToken();
+}
+function recordPrivateReadFailure(scopeKey) {
+  const previous = privateReadFailureCache.get(scopeKey);
+  const backoffMs = Math.min(
+    previous ? previous.backoffMs * 2 : INITIAL_AUTH_BACKOFF_MS,
+    MAX_AUTH_BACKOFF_MS
+  );
+  privateReadFailureCache.set(scopeKey, {
+    backoffMs,
+    retryAt: Date.now() + backoffMs
+  });
+}
+function ensureFailureBackoff(scopeKey) {
+  const failure = privateReadFailureCache.get(scopeKey);
+  if (!failure) return;
+  if (failure.retryAt <= Date.now()) {
+    privateReadFailureCache.delete(scopeKey);
+    return;
+  }
+  throw new Error(
+    `Private-read authentication is temporarily paused after a recent failure. Retry in ${Math.ceil(
+      (failure.retryAt - Date.now()) / 1e3
+    )}s.`
+  );
+}
+function usePrivateReadRequest() {
+  const wagmiContext = react.useContext(wagmi.WagmiContext);
+  const { client, networkConfig, hostedAuthConfig, hostedAuthSession, refreshHostedAuthSession } = usePrivanaContext();
+  const { address: walletAddress } = useSafeAccount();
+  const privateReadAddress = hostedAuthConfig ? hostedAuthSession?.address ?? null : walletAddress ?? null;
+  const privateReadReady = hostedAuthConfig ? !!hostedAuthSession : !!walletAddress;
+  const executePrivateRead = react.useCallback(
+    async (request) => {
+      if (hostedAuthConfig) {
+        return executeHostedAuthPrivateReadRequest({
+          client,
+          hostedAuthSession,
+          refreshHostedAuthSession,
+          request
+        });
+      }
+      if (!wagmiContext) {
+        throw new Error("WagmiProvider is required for authenticated private reads");
+      }
+      if (!walletAddress) {
+        throw new Error("No wallet connected");
+      }
+      const walletClient = await actions.getWalletClient(wagmiContext);
+      if (!walletClient) {
+        throw new Error("No wallet client available");
+      }
+      const apiUrl = networkConfig.apiUrl;
+      const scopeKey = createScopeKey(apiUrl, networkConfig.chainId, walletAddress);
+      const getToken = async (forceRefresh) => {
+        const inflight = privateReadInflight.get(scopeKey);
+        if (inflight) {
+          const token = await inflight;
+          client.setPrivateReadToken(token);
+          return token;
+        }
+        if (!forceRefresh) {
+          const cached = getCachedPrivateReadToken(scopeKey);
+          if (cached) {
+            client.setPrivateReadToken(cached);
+            return cached;
+          }
+        }
+        ensureFailureBackoff(scopeKey);
+        const authPromise = (async () => {
+          try {
+            const [{ domain }, nonceResponse] = await Promise.all([
+              client.getSiweDomain(),
+              client.getSiweNonce(walletAddress)
+            ]);
+            const issuedAt = /* @__PURE__ */ new Date();
+            const expirationTime = new Date(issuedAt.getTime() + DEFAULT_SIWE_AUTH_VALIDITY_MS);
+            const uri = typeof window !== "undefined" && window.location.origin ? window.location.origin : apiUrl;
+            const message = siwe.createSiweMessage({
+              address: walletAddress,
+              chainId: walletClient.chain?.id ?? networkConfig.chainId,
+              domain,
+              expirationTime,
+              issuedAt,
+              nonce: nonceResponse.nonce,
+              statement: PRIVATE_READ_STATEMENT,
+              uri,
+              version: "1"
+            });
+            const signature = await walletClient.signMessage({
+              account: walletClient.account ?? walletAddress,
+              message
+            });
+            const login = await client.loginWithSiwe({
+              siwe_message: message,
+              signature
+            });
+            privateReadTokenCache.set(scopeKey, {
+              token: login.siwe_token,
+              expiresAt: expirationTime.getTime()
+            });
+            privateReadFailureCache.delete(scopeKey);
+            client.setPrivateReadToken(login.siwe_token);
+            return login.siwe_token;
+          } catch (error) {
+            const authError = error instanceof Error ? error : new Error("Failed to authenticate private reads");
+            clearPrivateReadScope(scopeKey, client);
+            recordPrivateReadFailure(scopeKey);
+            throw authError;
+          } finally {
+            privateReadInflight.delete(scopeKey);
+          }
+        })();
+        privateReadInflight.set(scopeKey, authPromise);
+        return authPromise;
+      };
+      await getToken(false);
+      try {
+        return await request();
+      } catch (error) {
+        if (!(error instanceof AccountingApiError) || error.statusCode !== 401) {
+          throw error;
+        }
+        clearPrivateReadScope(scopeKey, client);
+        await getToken(true);
+        return request();
+      }
+    },
+    [
+      client,
+      hostedAuthConfig,
+      hostedAuthSession,
+      networkConfig.apiUrl,
+      networkConfig.chainId,
+      refreshHostedAuthSession,
+      walletAddress,
+      wagmiContext
+    ]
+  );
+  const privateReadQueryScope = react.useMemo(
+    () => [networkConfig.apiUrl, networkConfig.chainId, privateReadAddress],
+    [networkConfig.apiUrl, networkConfig.chainId, privateReadAddress]
+  );
+  return {
+    executePrivateRead,
+    privateReadAddress,
+    privateReadReady,
+    privateReadQueryScope
+  };
+}
+
+// src/sdk/hooks/use-balance.ts
+function useBalance(options = {}) {
+  const queryClient = react.useContext(reactQuery.QueryClientContext);
+  const accountingContext = useSafePrivanaContext();
+  const hasProviders = !!queryClient && !!accountingContext;
+  const client = accountingContext?.client;
+  const defaultToken = accountingContext?.defaultToken;
+  const pollingInterval = accountingContext?.pollingInterval ?? 1e4;
+  const { executePrivateRead, privateReadAddress, privateReadQueryScope, privateReadReady } = usePrivateReadRequest();
+  const tokenId = options.tokenId ?? defaultToken?.id;
+  const query = reactQuery.useQuery({
+    queryKey: ["accounting-balance", ...privateReadQueryScope, tokenId],
+    queryFn: async () => {
+      if (!privateReadAddress) throw new Error("No authenticated account available");
+      if (!tokenId) throw new Error("No token ID provided");
+      if (!client) throw new Error("No accounting client");
+      return executePrivateRead(() => client.getBalance(tokenId));
+    },
+    enabled: hasProviders && (options.enabled ?? true) && privateReadReady && !!privateReadAddress && !!tokenId && !!client,
+    refetchInterval: pollingInterval
+  });
+  const balanceWei = query.data?.balance ?? "0";
+  return {
+    balance: balanceWei,
+    balanceWei,
+    balanceFormatted: formatTokenAmount(balanceWei),
+    tokenSymbol: query.data?.token_symbol ?? "",
+    chainId: query.data?.chain_id ?? "",
+    isLoading: query.isPending || query.isLoading,
+    isError: query.isError,
+    error: query.error,
+    refetch: query.refetch
+  };
+}
+function useBatchBalances(options) {
+  const { client, pollingInterval } = usePrivanaContext();
+  const { executePrivateRead, privateReadAddress, privateReadQueryScope, privateReadReady } = usePrivateReadRequest();
+  const query = reactQuery.useQuery({
+    queryKey: ["accounting-batch-balances", ...privateReadQueryScope, options.tokenIds],
+    queryFn: async () => {
+      if (!privateReadAddress) throw new Error("No authenticated account available");
+      return executePrivateRead(() => client.getBatchBalances({ token_ids: options.tokenIds }));
+    },
+    enabled: (options.enabled ?? true) && privateReadReady && !!privateReadAddress && options.tokenIds.length > 0 && !!client,
+    refetchInterval: pollingInterval
+  });
+  return {
+    balances: query.data?.balances ?? [],
+    isLoading: query.isLoading,
+    isError: query.isError,
+    error: query.error,
+    refetch: query.refetch
+  };
+}
+
+// ../../node_modules/@wagmi/core/dist/esm/utils/getAction.js
+function getAction(client, actionFn, name) {
+  const action_implicit = client[actionFn.name];
+  if (typeof action_implicit === "function")
+    return action_implicit;
+  const action_explicit = client[name];
+  if (typeof action_explicit === "function")
+    return action_explicit;
+  return (params) => actionFn(client, params);
+}
+
+// ../../node_modules/@wagmi/core/dist/esm/actions/getChainId.js
+function getChainId2(config) {
+  return config.state.chainId;
+}
+async function waitForTransactionReceipt(config, parameters) {
+  const { chainId, timeout = 0, ...rest } = parameters;
+  const client = config.getClient({ chainId });
+  const action = getAction(client, actions$1.waitForTransactionReceipt, "waitForTransactionReceipt");
+  const receipt = await action({ ...rest, timeout });
+  if (receipt.status === "reverted") {
+    const action_getTransaction = getAction(client, actions$1.getTransaction, "getTransaction");
+    const { from: account, ...txn } = await action_getTransaction({
+      hash: receipt.transactionHash
+    });
+    const action_call = getAction(client, actions$1.call, "call");
+    const code = await action_call({
+      ...txn,
+      account,
+      data: txn.input,
+      gasPrice: txn.type !== "eip1559" ? txn.gasPrice : void 0,
+      maxFeePerGas: txn.type === "eip1559" ? txn.maxFeePerGas : void 0,
+      maxPriorityFeePerGas: txn.type === "eip1559" ? txn.maxPriorityFeePerGas : void 0
+    });
+    const reason = code?.data ? viem.hexToString(`0x${code.data.substring(138)}`) : "unknown reason";
+    throw new Error(reason);
+  }
+  return {
+    ...receipt,
+    chainId: client.chain.id
+  };
+}
+function useEnsureCorrectChain() {
+  const config = wagmi.useConfig();
+  const chainId = wagmi.useChainId();
+  const { switchChainAsync } = wagmi.useSwitchChain();
+  const waitUntilOnChain = react.useCallback(
+    async (expectedChainId, timeoutMs, pollIntervalMs = 250) => {
+      const startedAt = Date.now();
+      while (Date.now() - startedAt < timeoutMs) {
+        const currentChainId = getChainId2(config);
+        if (currentChainId === expectedChainId) return true;
+        await new Promise((resolve) => setTimeout(resolve, pollIntervalMs));
+      }
+      return false;
+    },
+    [config]
+  );
+  const ensureCorrectChain = react.useCallback(
+    async (targetChainId) => {
+      const currentChainId = getChainId2(config);
+      if (currentChainId === targetChainId) return false;
+      let switchErrorMessage;
+      try {
+        const timeoutPromise = new Promise((_, reject) => {
+          setTimeout(() => reject(new Error("Chain switch timeout")), 3e3);
+        });
+        await Promise.race([switchChainAsync({ chainId: targetChainId }), timeoutPromise]);
+      } catch (error) {
+        if (error instanceof Error && error.message.includes("Unsupported Chain")) {
+          console.warn("Got 'Unsupported Chain' error, chain may have switched anyway.");
+        } else {
+          switchErrorMessage = error instanceof Error ? error.message : "Unknown chain switch error";
+        }
+      }
+      const settled = await waitUntilOnChain(targetChainId, 2e4);
+      if (settled) return true;
+      if (switchErrorMessage) {
+        throw new Error(
+          `Failed to switch to chain (Chain ID: ${targetChainId}): ${switchErrorMessage}`
+        );
+      }
+      throw new Error(`Chain switch did not settle in time (expected ${targetChainId}).`);
+    },
+    [config, switchChainAsync, waitUntilOnChain]
+  );
+  const isOnChain = react.useCallback((targetChainId) => chainId === targetChainId, [chainId]);
+  return {
+    chainId,
+    ensureCorrectChain,
+    isOnChain
+  };
+}
+
+// src/sdk/hooks/use-deposit.ts
+function useDeposit(options = {}) {
+  const { address } = wagmi.useAccount();
+  const { client, enabledTokens, getChainById: getChainById2 } = usePrivanaContext();
+  const { data: walletClient } = wagmi.useWalletClient();
+  const queryClient = reactQuery.useQueryClient();
+  const config = wagmi.useConfig();
+  const { executePrivateRead } = usePrivateReadRequest();
+  const pollInterval = options.pollInterval ?? 5e3;
+  const pollTimeout = options.pollTimeout ?? 18e4;
+  const confirmations = options.confirmations ?? 15;
+  const [depositAddress, setDepositAddress] = react.useState(null);
+  const [txHash, setTxHash] = react.useState();
+  const [isSwitchingChain, setIsSwitchingChain] = react.useState(false);
+  const [isWaitingForConfirmation, setIsWaitingForConfirmation] = react.useState(false);
+  const [isWaitingForProcessing, setIsWaitingForProcessing] = react.useState(false);
+  const [didTimeout, setDidTimeout] = react.useState(false);
+  const [verificationFailed, setVerificationFailed] = react.useState(false);
+  const [depositError, setDepositError] = react.useState(null);
+  const generationRef = react.useRef(0);
+  const pollIntervalRef = react.useRef(null);
+  const verificationContextRef = react.useRef(null);
+  const onDepositAddressReceivedRef = react.useRef(options.onDepositAddressReceived);
+  const onDepositSuccessRef = react.useRef(options.onDepositSuccess);
+  const onCreditedRef = react.useRef(options.onCredited);
+  const onCheckTimeoutRef = react.useRef(options.onCheckTimeout);
+  const onErrorRef = react.useRef(options.onError);
+  react.useEffect(() => {
+    onDepositAddressReceivedRef.current = options.onDepositAddressReceived;
+    onDepositSuccessRef.current = options.onDepositSuccess;
+    onCreditedRef.current = options.onCredited;
+    onCheckTimeoutRef.current = options.onCheckTimeout;
+    onErrorRef.current = options.onError;
+  }, [
+    options.onDepositAddressReceived,
+    options.onDepositSuccess,
+    options.onCredited,
+    options.onCheckTimeout,
+    options.onError
+  ]);
+  const addressMutation = reactQuery.useMutation({
+    mutationFn: async () => {
+      if (!address) throw new Error("No wallet connected");
+      return executePrivateRead(() => client.getDepositAddress());
+    },
+    onSuccess: (data) => {
+      setDepositAddress(data);
+      onDepositAddressReceivedRef.current?.(data);
+    },
+    onError: (error2) => {
+      onErrorRef.current?.(error2);
+    }
+  });
+  const {
+    writeContractAsync,
+    isPending: isWritingContract,
+    error: writeError,
+    reset: resetWriteContract
+  } = wagmi.useWriteContract();
+  const {
+    sendTransactionAsync,
+    isPending: isSendingNative,
+    error: sendNativeError,
+    reset: resetSendTransaction
+  } = wagmi.useSendTransaction();
+  const isSendingTx = isWritingContract || isSendingNative;
+  const sendError = writeError ?? sendNativeError;
+  const { ensureCorrectChain } = useEnsureCorrectChain();
+  react.useEffect(() => {
+    return () => {
+      if (pollIntervalRef.current) {
+        clearTimeout(pollIntervalRef.current);
+      }
+    };
+  }, []);
+  const stopPolling = react.useCallback(() => {
+    if (pollIntervalRef.current) {
+      clearTimeout(pollIntervalRef.current);
+      pollIntervalRef.current = null;
+    }
+  }, []);
+  const reset = react.useCallback(() => {
+    generationRef.current++;
+    stopPolling();
+    verificationContextRef.current = null;
+    setDepositAddress(null);
+    setTxHash(void 0);
+    setIsSwitchingChain(false);
+    setIsWaitingForConfirmation(false);
+    setIsWaitingForProcessing(false);
+    setDidTimeout(false);
+    setVerificationFailed(false);
+    setDepositError(null);
+    addressMutation.reset();
+    resetWriteContract();
+    resetSendTransaction();
+  }, [addressMutation, resetWriteContract, resetSendTransaction, stopPolling]);
+  const runVerification = react.useCallback(
+    async (ctx, generation) => {
+      const isStale = () => generation !== generationRef.current;
+      const { hash, chainId, amount } = ctx;
+      setVerificationFailed(false);
+      setDepositError(null);
+      setDidTimeout(false);
+      setIsWaitingForProcessing(true);
+      const pollStartTime = Date.now();
+      const markVerificationFailed = (err) => {
+        setIsWaitingForProcessing(false);
+        setDepositError(err);
+        setVerificationFailed(true);
+        onErrorRef.current?.(err);
+      };
+      try {
+        const triggerResult = await executePrivateRead(
+          () => client.checkDeposit({
+            chain_id: chainId,
+            tx_hash: hash,
+            amount: amount.toString()
+          })
+        );
+        if (isStale()) return;
+        if (triggerResult.status === "credited") {
+          setIsWaitingForProcessing(false);
+          verificationContextRef.current = null;
+          queryClient.invalidateQueries({ queryKey: ["accounting-balance"] });
+          queryClient.invalidateQueries({ queryKey: ["accounting-history"] });
+          onCreditedRef.current?.(hash, triggerResult);
+          return;
+        }
+        if (triggerResult.status === "error") {
+          markVerificationFailed(new Error(triggerResult.detail ?? "Deposit verification failed"));
+          return;
+        }
+        const depositId = triggerResult.deposit_id;
+        if (!depositId) {
+          markVerificationFailed(new Error("Deposit check did not return a deposit id"));
+          return;
+        }
+        let consecutiveFailures = 0;
+        const checkStatus = async () => {
+          if (isStale()) return true;
+          if (Date.now() - pollStartTime > pollTimeout) {
+            stopPolling();
+            setIsWaitingForProcessing(false);
+            setDidTimeout(true);
+            onCheckTimeoutRef.current?.(hash);
+            queryClient.invalidateQueries({ queryKey: ["accounting-balance"] });
+            return true;
+          }
+          try {
+            const result = await executePrivateRead(() => client.getDepositStatus(depositId));
+            if (isStale()) return true;
+            consecutiveFailures = 0;
+            if (result.status === "credited") {
+              stopPolling();
+              setIsWaitingForProcessing(false);
+              verificationContextRef.current = null;
+              queryClient.invalidateQueries({ queryKey: ["accounting-balance"] });
+              queryClient.invalidateQueries({ queryKey: ["accounting-history"] });
+              onCreditedRef.current?.(hash, result);
+              return true;
+            }
+            if (result.status === "error") {
+              stopPolling();
+              markVerificationFailed(new Error(result.detail ?? "Deposit verification failed"));
+              return true;
+            }
+          } catch (err) {
+            if (isStale()) return true;
+            consecutiveFailures++;
+            console.warn("Error polling deposit status:", err);
+            if (consecutiveFailures >= 3) {
+              stopPolling();
+              markVerificationFailed(
+                err instanceof Error ? err : new Error("Deposit status polling failed")
+              );
+              return true;
+            }
+          }
+          return false;
+        };
+        const pollLoop = async () => {
+          const done = await checkStatus();
+          if (!done && !isStale() && pollIntervalRef.current !== null) {
+            pollIntervalRef.current = setTimeout(pollLoop, pollInterval);
+          }
+        };
+        pollIntervalRef.current = setTimeout(pollLoop, pollInterval);
+      } catch (err) {
+        if (isStale()) return;
+        stopPolling();
+        markVerificationFailed(
+          err instanceof Error ? err : new Error("Deposit verification failed")
+        );
+      }
+    },
+    [client, executePrivateRead, pollInterval, pollTimeout, queryClient, stopPolling]
+  );
+  const retryVerification = react.useCallback(async () => {
+    const ctx = verificationContextRef.current;
+    if (!ctx) {
+      throw new Error("No pending deposit to verify");
+    }
+    generationRef.current++;
+    stopPolling();
+    const generation = generationRef.current;
+    await runVerification(ctx, generation);
+  }, [runVerification, stopPolling]);
+  const deposit = react.useCallback(
+    async (params) => {
+      if (verificationContextRef.current) {
+        throw new Error(
+          "A deposit is pending verification. Call retryVerification() or reset() first."
+        );
+      }
+      reset();
+      const generation = generationRef.current;
+      const isStale = () => generation !== generationRef.current;
+      try {
+        if (!address || !walletClient) throw new Error("No wallet connected");
+        const token = enabledTokens.find((t) => t.id.toLowerCase() === params.tokenId.toLowerCase());
+        if (!token) throw new Error(`Unknown token ID: ${params.tokenId}`);
+        const sourceChain = getChainById2(token.chainId);
+        if (!sourceChain) throw new Error(`Chain ${token.chainId} not configured`);
+        const addrResponse = await addressMutation.mutateAsync();
+        if (isStale()) return;
+        setIsSwitchingChain(true);
+        try {
+          await ensureCorrectChain(sourceChain.id);
+        } finally {
+          if (!isStale()) setIsSwitchingChain(false);
+        }
+        if (isStale()) return;
+        const depositAddr = addrResponse.deposit_address;
+        if (!depositAddr || depositAddr === viem.zeroAddress) {
+          throw new Error("Invalid deposit address received from API");
+        }
+        const isNative = token.contract === viem.zeroAddress;
+        const minsForChain = addrResponse.min_deposit?.[String(sourceChain.id)];
+        const minAmountStr = isNative ? minsForChain?.native : minsForChain?.erc20;
+        if (minAmountStr && params.amount < BigInt(minAmountStr)) {
+          throw new Error(
+            `Amount is below the minimum deposit (${minAmountStr}) for ${isNative ? "native" : "ERC-20"} on chain ${sourceChain.id}`
+          );
+        }
+        const hash = token.contract === viem.zeroAddress ? await sendTransactionAsync({
+          to: depositAddr,
+          value: params.amount,
+          chainId: sourceChain.id
+        }) : await writeContractAsync({
+          address: token.contract,
+          abi: viem.erc20Abi,
+          functionName: "transfer",
+          args: [depositAddr, params.amount],
+          chainId: sourceChain.id
+        });
+        if (isStale()) return;
+        setTxHash(hash);
+        const ctx = {
+          hash,
+          chainId: sourceChain.id,
+          amount: params.amount
+        };
+        verificationContextRef.current = ctx;
+        try {
+          setIsWaitingForConfirmation(true);
+          try {
+            await waitForTransactionReceipt(config, { hash, confirmations });
+          } finally {
+            if (!isStale()) setIsWaitingForConfirmation(false);
+          }
+          if (isStale()) return;
+          onDepositSuccessRef.current?.(hash);
+          queryClient.invalidateQueries({ queryKey: ["readContract"] });
+          await runVerification(ctx, generation);
+        } catch (err) {
+          if (isStale()) return;
+          setIsWaitingForConfirmation(false);
+          stopPolling();
+          const error2 = err instanceof Error ? err : new Error("Deposit verification failed");
+          setIsWaitingForProcessing(false);
+          setDepositError(error2);
+          setVerificationFailed(true);
+          onErrorRef.current?.(error2);
+        }
+      } catch (err) {
+        if (isStale()) return;
+        const error2 = err instanceof Error ? err : new Error("Deposit failed");
+        setDepositError(error2);
+        onErrorRef.current?.(error2);
+      }
+    },
+    [
+      address,
+      walletClient,
+      addressMutation,
+      getChainById2,
+      config,
+      confirmations,
+      enabledTokens,
+      ensureCorrectChain,
+      queryClient,
+      writeContractAsync,
+      sendTransactionAsync,
+      stopPolling,
+      reset,
+      runVerification
+    ]
+  );
+  const isPending = addressMutation.isPending || isSwitchingChain || isSendingTx || isWaitingForConfirmation || isWaitingForProcessing;
+  const error = addressMutation.error || sendError || depositError;
+  return {
+    depositAddress,
+    txHash,
+    isGettingAddress: addressMutation.isPending,
+    isSwitchingChain,
+    isSendingTransaction: isSendingTx,
+    isWaitingForConfirmation,
+    isWaitingForProcessing,
+    didTimeout,
+    verificationFailed,
+    isPending,
+    error,
+    deposit,
+    retryVerification,
+    reset
+  };
+}
+function useWithdraw(options = {}) {
+  const { address } = wagmi.useAccount();
+  const { data: walletClient } = wagmi.useWalletClient();
+  const { client, networkConfig } = usePrivanaContext();
+  const queryClient = reactQuery.useQueryClient();
+  const { chainId, ensureCorrectChain } = useEnsureCorrectChain();
+  const pollInterval = options.pollInterval ?? 3e3;
+  const pollTimeout = options.pollTimeout ?? 18e4;
+  const [currentStep, setCurrentStep] = react.useState("idle");
+  const [didTimeout, setDidTimeout] = react.useState(false);
+  const [isSuccess, setIsSuccess] = react.useState(false);
+  const [withdrawError, setWithdrawError] = react.useState(null);
+  const generationRef = react.useRef(0);
+  const pollIntervalRef = react.useRef(null);
+  const onSubmitSuccessRef = react.useRef(options.onSubmitSuccess);
+  const onProcessingSuccessRef = react.useRef(options.onProcessingSuccess);
+  const onProcessingTimeoutRef = react.useRef(options.onProcessingTimeout);
+  const onSuccessRef = react.useRef(options.onSuccess);
+  const onErrorRef = react.useRef(options.onError);
+  react.useEffect(() => {
+    onSubmitSuccessRef.current = options.onSubmitSuccess;
+    onProcessingSuccessRef.current = options.onProcessingSuccess;
+    onProcessingTimeoutRef.current = options.onProcessingTimeout;
+    onSuccessRef.current = options.onSuccess;
+    onErrorRef.current = options.onError;
+  }, [
+    options.onSubmitSuccess,
+    options.onProcessingSuccess,
+    options.onProcessingTimeout,
+    options.onSuccess,
+    options.onError
+  ]);
+  const { chainId: signingChainId } = networkConfig;
+  react.useEffect(() => {
+    return () => {
+      if (pollIntervalRef.current) {
+        clearTimeout(pollIntervalRef.current);
+      }
+    };
+  }, []);
+  const stopPolling = react.useCallback(() => {
+    if (pollIntervalRef.current) {
+      clearTimeout(pollIntervalRef.current);
+      pollIntervalRef.current = null;
+    }
+  }, []);
+  const reset = react.useCallback(() => {
+    generationRef.current++;
+    stopPolling();
+    setCurrentStep("idle");
+    setDidTimeout(false);
+    setIsSuccess(false);
+    setWithdrawError(null);
+  }, [stopPolling]);
+  const withdraw = react.useCallback(
+    async (params) => {
+      reset();
+      const generation = generationRef.current;
+      const isStale = () => generation !== generationRef.current;
+      try {
+        if (!address || !walletClient) throw new Error("Wallet not connected");
+        const pendingResponse = await client.getPendingWithdrawals(address);
+        if (isStale()) return void 0;
+        const knownIndices = new Set(pendingResponse.pending_withdrawals.map((w) => w.index));
+        if (chainId !== signingChainId) {
+          setCurrentStep("switching-chain");
+        }
+        await ensureCorrectChain(signingChainId);
+        if (isStale()) return void 0;
+        const nonceResponse = await client.getWithdrawalNonce(address);
+        if (isStale()) return void 0;
+        const nonce = BigInt(nonceResponse.nonce);
+        setCurrentStep("signing");
+        const signature = await signWithdrawMessage({
+          walletClient,
+          chainId: signingChainId,
+          verifyingContract: networkConfig.accountingContract,
+          message: {
+            tokenId: params.tokenId,
+            amount: params.amount,
+            nonce
+          }
+        });
+        if (isStale()) return void 0;
+        setCurrentStep("submitting");
+        const submissionResponse = await client.requestWithdrawal({
+          token_id: params.tokenId,
+          amount: params.amount.toString(),
+          nonce: String(nonce),
+          signature
+        });
+        if (isStale()) return submissionResponse;
+        onSubmitSuccessRef.current?.(submissionResponse);
+        onSuccessRef.current?.(submissionResponse);
+        queryClient.invalidateQueries({ queryKey: ["accounting-history"] });
+        setCurrentStep("processing");
+        const pollStartTime = Date.now();
+        let withdrawalIndex = null;
+        let consecutiveFailures = 0;
+        const handleSuccess = () => {
+          stopPolling();
+          setCurrentStep("idle");
+          setIsSuccess(true);
+          onProcessingSuccessRef.current?.();
+          queryClient.refetchQueries({ queryKey: ["accounting-balance"] });
+          queryClient.refetchQueries({ queryKey: ["accounting-pending-withdrawals"] });
+        };
+        const handleTimeout = () => {
+          stopPolling();
+          setCurrentStep("idle");
+          setDidTimeout(true);
+          onProcessingTimeoutRef.current?.();
+          queryClient.refetchQueries({ queryKey: ["accounting-balance"] });
+          queryClient.refetchQueries({ queryKey: ["accounting-pending-withdrawals"] });
+        };
+        const checkWithdrawalStatus = async () => {
+          if (isStale()) return true;
+          if (Date.now() - pollStartTime > pollTimeout) {
+            handleTimeout();
+            return true;
+          }
+          try {
+            if (withdrawalIndex !== null) {
+              const info = await client.getWithdrawalInfo(withdrawalIndex);
+              if (isStale()) return true;
+              consecutiveFailures = 0;
+              if (info.resolved) {
+                handleSuccess();
+                return true;
+              }
+              return false;
+            }
+            const pending = await client.getPendingWithdrawals(address);
+            if (isStale()) return true;
+            consecutiveFailures = 0;
+            const match = pending.pending_withdrawals.find(
+              (w) => !knownIndices.has(w.index) && w.user_address.toLowerCase() === address.toLowerCase() && w.token_id.toLowerCase() === params.tokenId.toLowerCase() && w.amount === String(params.amount)
+            );
+            if (match) {
+              withdrawalIndex = match.index;
+              if (match.resolved) {
+                handleSuccess();
+                return true;
+              }
+            }
+          } catch (err) {
+            if (isStale()) return true;
+            consecutiveFailures++;
+            console.warn("Error polling withdrawal status:", err);
+            if (consecutiveFailures >= 3) {
+              handleTimeout();
+              return true;
+            }
+          }
+          return false;
+        };
+        const pollLoop = async () => {
+          const done = await checkWithdrawalStatus();
+          if (!done && !isStale() && pollIntervalRef.current !== null) {
+            pollIntervalRef.current = setTimeout(pollLoop, pollInterval);
+          }
+        };
+        pollIntervalRef.current = setTimeout(pollLoop, 0);
+        return submissionResponse;
+      } catch (err) {
+        if (isStale()) return void 0;
+        const error = err instanceof Error ? err : new Error("Withdrawal failed");
+        setCurrentStep("idle");
+        setWithdrawError(error);
+        onErrorRef.current?.(error);
+        return void 0;
+      }
+    },
+    [
+      address,
+      walletClient,
+      client,
+      chainId,
+      signingChainId,
+      networkConfig.accountingContract,
+      ensureCorrectChain,
+      pollInterval,
+      pollTimeout,
+      queryClient,
+      stopPolling,
+      reset
+    ]
+  );
+  const isPending = currentStep !== "idle";
+  return {
+    withdraw,
+    isPending,
+    isSuccess,
+    currentStep,
+    didTimeout,
+    error: withdrawError,
+    reset
+  };
+}
+function useLockFunds(options = {}) {
+  const { address } = wagmi.useAccount();
+  const { data: walletClient } = wagmi.useWalletClient();
+  const { client, networkConfig, serviceAddress } = usePrivanaContext();
+  const queryClient = reactQuery.useQueryClient();
+  const mutation = reactQuery.useMutation({
+    mutationFn: async (params) => {
+      if (!address || !walletClient) {
+        throw new Error("Wallet not connected");
+      }
+      if (!serviceAddress) {
+        throw new Error("Service address not configured");
+      }
+      const { nonce } = await client.getLockNonce(address);
+      const signature = await signLockMessage({
+        walletClient,
+        chainId: networkConfig.chainId,
+        verifyingContract: networkConfig.accountingContract,
+        message: {
+          serviceAddress,
+          tokenId: params.tokenId,
+          amount: params.amount,
+          expiry: params.expiry,
+          nonce: BigInt(nonce)
+        }
+      });
+      return client.lockFunds({
+        service_address: serviceAddress,
+        token_id: params.tokenId,
+        amount: params.amount.toString(),
+        expiry: params.expiry.toString(),
+        nonce: String(nonce),
+        signature
+      });
+    },
+    onSuccess: (data) => {
+      options.onSuccess?.(data);
+      queryClient.invalidateQueries({ queryKey: ["accounting-balance"] });
+      queryClient.invalidateQueries({ queryKey: ["accounting-locked-funds"] });
+      queryClient.invalidateQueries({ queryKey: ["accounting-total-locked-balance"] });
+      queryClient.invalidateQueries({ queryKey: ["accounting-history"] });
+    },
+    onError: (error) => {
+      options.onError?.(error);
+    }
+  });
+  const lockFunds = react.useCallback(
+    async (params) => {
+      return mutation.mutateAsync(params);
+    },
+    [mutation]
+  );
+  return {
+    lockFunds,
+    isPending: mutation.isPending,
+    isSuccess: mutation.isSuccess,
+    error: mutation.error,
+    reset: mutation.reset
+  };
+}
+function useUnlockFunds(options = {}) {
+  const { address } = wagmi.useAccount();
+  const { client } = usePrivanaContext();
+  const queryClient = reactQuery.useQueryClient();
+  const unlockMutation = reactQuery.useMutation({
+    mutationFn: async (params) => {
+      if (!address) {
+        throw new Error("Wallet not connected");
+      }
+      return client.unlockFunds({
+        user_address: address,
+        lock_id: params.lockId
+      });
+    },
+    onSuccess: (data) => {
+      options.onSuccess?.(data);
+      queryClient.invalidateQueries({ queryKey: ["accounting-balance"] });
+      queryClient.invalidateQueries({ queryKey: ["accounting-locked-funds"] });
+      queryClient.invalidateQueries({ queryKey: ["accounting-total-locked-balance"] });
+      queryClient.invalidateQueries({ queryKey: ["accounting-expired-locks"] });
+    },
+    onError: (error) => {
+      options.onError?.(error);
+    }
+  });
+  const unlockAllMutation = reactQuery.useMutation({
+    mutationFn: async () => {
+      if (!address) {
+        throw new Error("Wallet not connected");
+      }
+      return client.unlockAllExpired({
+        user_address: address
+      });
+    },
+    onSuccess: (data) => {
+      options.onSuccess?.(data);
+      queryClient.invalidateQueries({ queryKey: ["accounting-balance"] });
+      queryClient.invalidateQueries({ queryKey: ["accounting-locked-funds"] });
+      queryClient.invalidateQueries({ queryKey: ["accounting-total-locked-balance"] });
+      queryClient.invalidateQueries({ queryKey: ["accounting-expired-locks"] });
+    },
+    onError: (error) => {
+      options.onError?.(error);
+    }
+  });
+  const unlockFunds = react.useCallback(
+    async (params) => {
+      return unlockMutation.mutateAsync(params);
+    },
+    [unlockMutation]
+  );
+  const unlockAllExpired = react.useCallback(async () => {
+    return unlockAllMutation.mutateAsync();
+  }, [unlockAllMutation]);
+  const reset = react.useCallback(() => {
+    unlockMutation.reset();
+    unlockAllMutation.reset();
+  }, [unlockMutation, unlockAllMutation]);
+  return {
+    unlockFunds,
+    unlockAllExpired,
+    isPending: unlockMutation.isPending || unlockAllMutation.isPending,
+    isSuccess: unlockMutation.isSuccess || unlockAllMutation.isSuccess,
+    error: unlockMutation.error || unlockAllMutation.error,
+    reset
+  };
+}
+function useTransfer(options = {}) {
+  const { address } = wagmi.useAccount();
+  const { data: walletClient } = wagmi.useWalletClient();
+  const { client, networkConfig, serviceAddress } = usePrivanaContext();
+  const queryClient = reactQuery.useQueryClient();
+  const transferMutation = reactQuery.useMutation({
+    mutationFn: async (params) => {
+      if (!address || !walletClient) {
+        throw new Error("Wallet not connected");
+      }
+      const { nonce } = await client.getTransferNonce(address);
+      const signature = await signTransferMessage({
+        walletClient,
+        chainId: networkConfig.chainId,
+        verifyingContract: networkConfig.accountingContract,
+        message: {
+          toAddress: params.toAddress,
+          tokenId: params.tokenId,
+          amount: params.amount,
+          nonce: BigInt(nonce)
+        }
+      });
+      return client.transferFunds({
+        to_address: params.toAddress,
+        token_id: params.tokenId,
+        amount: params.amount.toString(),
+        nonce: String(nonce),
+        signature
+      });
+    },
+    onSuccess: (data) => {
+      options.onSuccess?.(data);
+      queryClient.invalidateQueries({ queryKey: ["accounting-balance"] });
+      queryClient.invalidateQueries({ queryKey: ["accounting-history"] });
+    },
+    onError: (error) => {
+      options.onError?.(error);
+    }
+  });
+  const transferLockedMutation = reactQuery.useMutation({
+    mutationFn: async (params) => {
+      if (!address || !walletClient) {
+        throw new Error("Wallet not connected");
+      }
+      if (!serviceAddress) {
+        throw new Error("Service address not configured");
+      }
+      const { nonce } = await client.getTransferLockedNonce(serviceAddress);
+      const signature = await signTransferLockedMessage({
+        walletClient,
+        chainId: networkConfig.chainId,
+        verifyingContract: networkConfig.accountingContract,
+        message: {
+          userAddress: address,
+          toAddress: params.toAddress,
+          lockId: BigInt(params.lockId),
+          amount: params.amount,
+          nonce: BigInt(nonce),
+          serviceAddress
+        }
+      });
+      return client.transferLockedFunds({
+        user_address: address,
+        lock_id: params.lockId,
+        to_address: params.toAddress,
+        amount: params.amount.toString(),
+        service_address: serviceAddress,
+        nonce: String(nonce),
+        signature
+      });
+    },
+    onSuccess: (data) => {
+      options.onSuccess?.(data);
+      queryClient.invalidateQueries({ queryKey: ["accounting-balance"] });
+      queryClient.invalidateQueries({ queryKey: ["accounting-locked-funds"] });
+      queryClient.invalidateQueries({ queryKey: ["accounting-total-locked-balance"] });
+      queryClient.invalidateQueries({ queryKey: ["accounting-history"] });
+    },
+    onError: (error) => {
+      options.onError?.(error);
+    }
+  });
+  const transfer = react.useCallback(
+    async (params) => {
+      return transferMutation.mutateAsync(params);
+    },
+    [transferMutation]
+  );
+  const transferLocked = react.useCallback(
+    async (params) => {
+      return transferLockedMutation.mutateAsync(params);
+    },
+    [transferLockedMutation]
+  );
+  const reset = react.useCallback(() => {
+    transferMutation.reset();
+    transferLockedMutation.reset();
+  }, [transferMutation, transferLockedMutation]);
+  return {
+    transfer,
+    transferLocked,
+    isPending: transferMutation.isPending || transferLockedMutation.isPending,
+    isSuccess: transferMutation.isSuccess || transferLockedMutation.isSuccess,
+    error: transferMutation.error || transferLockedMutation.error,
+    reset
+  };
+}
+function useLockedFunds(options = {}) {
+  const { client, pollingInterval, serviceAddress } = usePrivanaContext();
+  const { executePrivateRead, privateReadAddress, privateReadQueryScope, privateReadReady } = usePrivateReadRequest();
+  const query = reactQuery.useQuery({
+    queryKey: ["accounting-locked-funds", ...privateReadQueryScope, serviceAddress ?? null],
+    queryFn: async () => {
+      if (!privateReadAddress) throw new Error("No authenticated account available");
+      return executePrivateRead(() => client.getLockedFunds(serviceAddress));
+    },
+    enabled: (options.enabled ?? true) && privateReadReady && !!privateReadAddress && !!client,
+    refetchInterval: pollingInterval,
+    placeholderData: reactQuery.keepPreviousData,
+    staleTime: 5e3
+  });
+  return {
+    locks: query.data?.locks ?? [],
+    totalLocked: query.data?.total_locked ?? "0",
+    isLoading: query.isLoading,
+    isError: query.isError,
+    error: query.error,
+    refetch: query.refetch
+  };
+}
+function useTotalLockedBalance(options = {}) {
+  const { client, pollingInterval, defaultToken } = usePrivanaContext();
+  const { executePrivateRead, privateReadAddress, privateReadQueryScope, privateReadReady } = usePrivateReadRequest();
+  const tokenId = options.tokenId ?? defaultToken?.id;
+  const query = reactQuery.useQuery({
+    queryKey: ["accounting-total-locked-balance", ...privateReadQueryScope, tokenId],
+    queryFn: async () => {
+      if (!privateReadAddress) throw new Error("No authenticated account available");
+      if (!tokenId) throw new Error("No token ID provided");
+      return executePrivateRead(() => client.getTotalLockedBalance(tokenId));
+    },
+    enabled: (options.enabled ?? true) && privateReadReady && !!privateReadAddress && !!tokenId && !!client,
+    refetchInterval: pollingInterval
+  });
+  return {
+    totalLocked: query.data?.total_locked ?? "0",
+    isLoading: query.isLoading,
+    isError: query.isError,
+    error: query.error,
+    refetch: query.refetch
+  };
+}
+function useExpiredLocks(options = {}) {
+  const { client, pollingInterval } = usePrivanaContext();
+  const { executePrivateRead, privateReadAddress, privateReadQueryScope, privateReadReady } = usePrivateReadRequest();
+  const query = reactQuery.useQuery({
+    queryKey: ["accounting-expired-locks", ...privateReadQueryScope],
+    queryFn: async () => {
+      if (!privateReadAddress) throw new Error("No authenticated account available");
+      return executePrivateRead(() => client.getExpiredLocks());
+    },
+    enabled: (options.enabled ?? true) && privateReadReady && !!privateReadAddress && !!client,
+    refetchInterval: pollingInterval
+  });
+  const expiredLocks = query.data?.expired_locks ?? [];
+  return {
+    expiredLocks,
+    hasExpiredLocks: expiredLocks.length > 0,
+    isLoading: query.isLoading,
+    isError: query.isError,
+    error: query.error,
+    refetch: query.refetch
+  };
+}
+function usePendingWithdrawals(options = {}) {
+  const { address, isConnected } = wagmi.useAccount();
+  const { client, pollingInterval } = usePrivanaContext();
+  const query = reactQuery.useQuery({
+    queryKey: ["accounting-pending-withdrawals", address],
+    queryFn: async () => {
+      if (!address) throw new Error("No wallet connected");
+      try {
+        return await client.getPendingWithdrawals(address);
+      } catch (error) {
+        if (error && typeof error === "object" && "statusCode" in error && error.statusCode === 404) {
+          return { user_address: address, pending_withdrawals: [] };
+        }
+        throw error;
+      }
+    },
+    enabled: (options.enabled ?? true) && isConnected && !!address,
+    refetchInterval: pollingInterval,
+    placeholderData: reactQuery.keepPreviousData,
+    staleTime: 5e3,
+    retry: (failureCount, error) => {
+      if (error && typeof error === "object" && "statusCode" in error && error.statusCode === 404) {
+        return false;
+      }
+      return failureCount < 3;
+    }
+  });
+  const withdrawals = query.data?.pending_withdrawals ?? [];
+  return {
+    withdrawals,
+    hasPendingWithdrawals: withdrawals.length > 0,
+    isLoading: query.isLoading,
+    isError: query.isError,
+    error: query.error,
+    refetch: query.refetch
+  };
+}
+function useHistory(options = {}) {
+  const { client, pollingInterval } = usePrivanaContext();
+  const { executePrivateRead, privateReadAddress, privateReadQueryScope, privateReadReady } = usePrivateReadRequest();
+  const offset = options.offset ?? -1;
+  const limit = options.limit ?? 50;
+  const query = reactQuery.useQuery({
+    queryKey: ["accounting-history", ...privateReadQueryScope, offset, limit],
+    queryFn: async () => {
+      if (!privateReadAddress) throw new Error("No authenticated account available");
+      return executePrivateRead(() => client.getHistory({ offset, limit }));
+    },
+    enabled: (options.enabled ?? true) && privateReadReady && !!privateReadAddress && !!client,
+    refetchInterval: pollingInterval,
+    placeholderData: reactQuery.keepPreviousData,
+    staleTime: 5e3
+  });
+  return {
+    history: query.data?.history ?? [],
+    total: query.data?.total ?? 0,
+    isLoading: query.isLoading,
+    isError: query.isError,
+    error: query.error,
+    refetch: query.refetch
+  };
+}
+function useTokenInfo(options = {}) {
+  const { client } = usePrivanaContext();
+  const { tokenId } = options;
+  const query = reactQuery.useQuery({
+    queryKey: ["accounting-token-info", tokenId],
+    queryFn: () => {
+      if (!tokenId) throw new Error("No token ID provided");
+      return client.getTokenInfo(tokenId);
+    },
+    enabled: (options.enabled ?? true) && !!tokenId && !!client,
+    staleTime: Infinity
+  });
+  return {
+    data: query.data,
+    isLoading: query.isLoading,
+    isError: query.isError,
+    error: query.error,
+    refetch: query.refetch
+  };
+}
+function useTokenList(options = {}) {
+  const { client } = usePrivanaContext();
+  const query = reactQuery.useQuery({
+    queryKey: ["accounting-token-list"],
+    queryFn: () => client.listTokens(),
+    enabled: (options.enabled ?? true) && !!client,
+    staleTime: Infinity
+  });
+  return {
+    tokens: query.data?.tokens ?? [],
+    isLoading: query.isLoading,
+    isError: query.isError,
+    error: query.error,
+    refetch: query.refetch
+  };
+}
+function useModifyLock(options = {}) {
+  const { address } = wagmi.useAccount();
+  const { data: walletClient } = wagmi.useWalletClient();
+  const { client, networkConfig } = usePrivanaContext();
+  const queryClient = reactQuery.useQueryClient();
+  const mutation = reactQuery.useMutation({
+    mutationFn: async (params) => {
+      if (!address || !walletClient) {
+        throw new Error("Wallet not connected");
+      }
+      const { nonce } = await client.getModifyLockNonce(address);
+      const signature = await signModifyLockMessage({
+        walletClient,
+        chainId: networkConfig.chainId,
+        verifyingContract: networkConfig.accountingContract,
+        message: {
+          lockId: BigInt(params.lockId),
+          amount: params.amount,
+          newExpiry: params.newExpiry,
+          nonce: BigInt(nonce)
+        }
+      });
+      return client.modifyLock({
+        lock_id: params.lockId,
+        amount: params.amount.toString(),
+        new_expiry: params.newExpiry.toString(),
+        nonce: String(nonce),
+        signature
+      });
+    },
+    onSuccess: (data) => {
+      options.onSuccess?.(data);
+      queryClient.invalidateQueries({ queryKey: ["accounting-balance"] });
+      queryClient.invalidateQueries({ queryKey: ["accounting-locked-funds"] });
+      queryClient.invalidateQueries({ queryKey: ["accounting-total-locked-balance"] });
+    },
+    onError: (error) => {
+      options.onError?.(error);
+    }
+  });
+  const modifyLock = react.useCallback(
+    async (params) => {
+      return mutation.mutateAsync(params);
+    },
+    [mutation]
+  );
+  return {
+    modifyLock,
+    isPending: mutation.isPending,
+    isSuccess: mutation.isSuccess,
+    error: mutation.error,
+    reset: mutation.reset
+  };
+}
+var buttonVariants = classVarianceAuthority.cva(
+  "inline-flex items-center justify-center gap-2 whitespace-nowrap rounded-md text-sm font-medium transition-all disabled:pointer-events-none disabled:opacity-50 [&_svg]:pointer-events-none [&_svg:not([class*='size-'])]:size-4 shrink-0 [&_svg]:shrink-0 outline-none focus-visible:border-ring focus-visible:ring-ring/50 focus-visible:ring-[3px] aria-invalid:ring-destructive/20 dark:aria-invalid:ring-destructive/40 aria-invalid:border-destructive",
+  {
+    variants: {
+      variant: {
+        default: "bg-primary text-primary-foreground hover:bg-primary/90",
+        destructive: "bg-destructive text-white hover:bg-destructive/90 focus-visible:ring-destructive/20 dark:focus-visible:ring-destructive/40 dark:bg-destructive/60",
+        outline: "border bg-background shadow-xs hover:bg-accent hover:text-accent-foreground dark:bg-input/30 dark:border-input dark:hover:bg-input/50",
+        secondary: "bg-secondary text-secondary-foreground hover:bg-secondary/80",
+        ghost: "hover:bg-accent hover:text-accent-foreground dark:hover:bg-accent/50",
+        link: "text-primary underline-offset-4 hover:underline"
+      },
+      size: {
+        default: "h-9 px-4 py-2 has-[>svg]:px-3",
+        sm: "h-8 rounded-md gap-1.5 px-3 has-[>svg]:px-2.5",
+        lg: "h-10 rounded-md px-6 has-[>svg]:px-4",
+        icon: "size-9",
+        "icon-sm": "size-8",
+        "icon-lg": "size-10"
+      }
+    },
+    defaultVariants: {
+      variant: "default",
+      size: "default"
+    }
+  }
+);
+function Button({
+  className,
+  variant = "default",
+  size = "default",
+  asChild = false,
+  ...props
+}) {
+  const Comp = asChild ? reactSlot.Slot : "button";
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    Comp,
+    {
+      "data-slot": "button",
+      "data-variant": variant,
+      "data-size": size,
+      className: cn(buttonVariants({ variant, size, className })),
+      ...props
+    }
+  );
+}
+function Dialog({ ...props }) {
+  return /* @__PURE__ */ jsxRuntime.jsx(DialogPrimitive__namespace.Root, { "data-slot": "dialog", ...props });
+}
+function DialogPortal({ ...props }) {
+  return /* @__PURE__ */ jsxRuntime.jsx(DialogPrimitive__namespace.Portal, { "data-slot": "dialog-portal", ...props });
+}
+function DialogOverlay({
+  className,
+  ...props
+}) {
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    DialogPrimitive__namespace.Overlay,
+    {
+      "data-slot": "dialog-overlay",
+      "data-privana": true,
+      className: cn(
+        "data-[state=open]:animate-in data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=open]:fade-in-0 fixed inset-0 z-50 bg-black/50",
+        className
+      ),
+      ...props
+    }
+  );
+}
+function DialogContent({
+  className,
+  children,
+  showCloseButton = true,
+  overlayClassName,
+  ...props
+}) {
+  return /* @__PURE__ */ jsxRuntime.jsxs(DialogPortal, { "data-slot": "dialog-portal", children: [
+    /* @__PURE__ */ jsxRuntime.jsx(DialogOverlay, { className: overlayClassName }),
+    /* @__PURE__ */ jsxRuntime.jsxs(
+      DialogPrimitive__namespace.Content,
+      {
+        "data-slot": "dialog-content",
+        "data-privana": true,
+        className: cn(
+          "bg-background data-[state=open]:animate-in data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=open]:fade-in-0 data-[state=closed]:zoom-out-95 data-[state=open]:zoom-in-95 fixed top-[50%] left-[50%] z-50 grid w-full max-w-[calc(100%-2rem)] translate-x-[-50%] translate-y-[-50%] gap-4 rounded-lg border p-6 shadow-lg duration-200 outline-none sm:max-w-lg",
+          className
+        ),
+        ...props,
+        children: [
+          children,
+          showCloseButton && /* @__PURE__ */ jsxRuntime.jsxs(
+            DialogPrimitive__namespace.Close,
+            {
+              "data-slot": "dialog-close",
+              className: "text-muted-foreground hover:text-foreground absolute top-4 right-4 cursor-pointer rounded-xs transition-colors focus:outline-none disabled:pointer-events-none [&_svg]:pointer-events-none [&_svg]:shrink-0 [&_svg:not([class*='size-'])]:size-4",
+              children: [
+                /* @__PURE__ */ jsxRuntime.jsx(lucideReact.XIcon, {}),
+                /* @__PURE__ */ jsxRuntime.jsx("span", { className: "sr-only", children: "Close" })
+              ]
+            }
+          )
+        ]
+      }
+    )
+  ] });
+}
+function DialogHeader({ className, ...props }) {
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    "div",
+    {
+      "data-slot": "dialog-header",
+      className: cn("flex flex-col gap-2 text-center sm:text-left", className),
+      ...props
+    }
+  );
+}
+function DialogTitle({ className, ...props }) {
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    DialogPrimitive__namespace.Title,
+    {
+      "data-slot": "dialog-title",
+      className: cn("text-lg leading-none font-semibold", className),
+      ...props
+    }
+  );
+}
+function DialogDescription({
+  className,
+  ...props
+}) {
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    DialogPrimitive__namespace.Description,
+    {
+      "data-slot": "dialog-description",
+      className: cn("text-muted-foreground text-sm", className),
+      ...props
+    }
+  );
+}
+function ChevronRightIcon() {
+  return /* @__PURE__ */ jsxRuntime.jsx("svg", { width: "10", height: "5", viewBox: "0 0 12 6", className: "-rotate-90", children: /* @__PURE__ */ jsxRuntime.jsx(
+    "path",
+    {
+      d: "M0 0l6 6 6-6",
+      stroke: "currentColor",
+      strokeWidth: "1.5",
+      strokeLinecap: "round",
+      strokeLinejoin: "round",
+      fill: "none"
+    }
+  ) });
+}
+function USDCIcon({ className, size = 24 }) {
+  return /* @__PURE__ */ jsxRuntime.jsxs(
+    "svg",
+    {
+      width: size,
+      height: size,
+      viewBox: "0 0 2000 2000",
+      fill: "none",
+      xmlns: "http://www.w3.org/2000/svg",
+      className,
+      children: [
+        /* @__PURE__ */ jsxRuntime.jsx(
+          "path",
+          {
+            d: "M1000 2000c554.17 0 1000-445.83 1000-1000S1554.17 0 1000 0 0 445.83 0 1000s445.83 1000 1000 1000z",
+            fill: "#2775ca"
+          }
+        ),
+        /* @__PURE__ */ jsxRuntime.jsx(
+          "path",
+          {
+            d: "M1275 1158.33c0-145.83-87.5-195.83-262.5-216.66-125-16.67-150-50-150-108.34s41.67-95.83 125-95.83c75 0 116.67 25 137.5 87.5 4.17 12.5 16.67 20.83 29.17 20.83h66.66c16.67 0 29.17-12.5 29.17-29.16v-4.17c-16.67-91.67-91.67-162.5-187.5-170.83v-100c0-16.67-12.5-29.17-33.33-33.34h-62.5c-16.67 0-29.17 12.5-33.34 33.34v95.83c-125 16.67-204.16 100-204.16 204.17 0 137.5 83.33 191.66 258.33 212.5 116.67 20.83 154.17 45.83 154.17 112.5s-58.34 112.5-137.5 112.5c-108.34 0-145.84-45.84-158.34-108.34-4.16-16.66-16.66-25-29.16-25h-70.84c-16.66 0-29.16 12.5-29.16 29.17v4.17c16.66 104.16 83.33 179.16 220.83 200v100c0 16.66 12.5 29.16 33.33 33.33h62.5c16.67 0 29.17-12.5 33.34-33.33v-100c125-20.84 208.33-108.34 208.33-220.84z",
+            fill: "#fff"
+          }
+        ),
+        /* @__PURE__ */ jsxRuntime.jsx(
+          "path",
+          {
+            d: "M787.5 1595.83c-325-116.66-491.67-479.16-370.83-800 62.5-175 200-308.33 370.83-370.83 16.67-8.33 25-20.83 25-41.67V325c0-16.67-8.33-29.17-25-33.33-4.17 0-12.5 0-16.67 4.16-395.83 125-612.5 545.84-487.5 941.67 75 233.33 254.17 412.5 487.5 487.5 16.67 8.33 33.34 0 37.5-16.67 4.17-4.16 4.17-8.33 4.17-16.66v-58.34c0-12.5-12.5-29.16-25-37.5zM1229.17 295.83c-16.67-8.33-33.34 0-37.5 16.67-4.17 4.17-4.17 8.33-4.17 16.67v58.33c0 16.67 12.5 33.33 25 41.67 325 116.66 491.67 479.16 370.83 800-62.5 175-200 308.33-370.83 370.83-16.67 8.33-25 20.83-25 41.67V1700c0 16.67 8.33 29.17 25 33.33 4.17 0 12.5 0 16.67-4.16 395.83-125 612.5-545.84 487.5-941.67-75-237.5-258.34-416.67-487.5-491.67z",
+            fill: "#fff"
+          }
+        )
+      ]
+    }
+  );
+}
+function BaseIcon({ className, size = 24 }) {
+  return /* @__PURE__ */ jsxRuntime.jsxs(
+    "svg",
+    {
+      width: size,
+      height: size,
+      viewBox: "0 0 2500 2500",
+      xmlns: "http://www.w3.org/2000/svg",
+      className,
+      children: [
+        /* @__PURE__ */ jsxRuntime.jsx("circle", { cx: "1250", cy: "1250", r: "1250", fill: "#0052FF" }),
+        /* @__PURE__ */ jsxRuntime.jsx(
+          "path",
+          {
+            d: "M1247.8,2500c691.6,0,1252.2-559.6,1252.2-1250C2500,559.6,1939.4,0,1247.8,0C591.7,0,53.5,503.8,0,1144.9h1655.1v210.2H0C53.5,1996.2,591.7,2500,1247.8,2500z",
+            fill: "white"
+          }
+        )
+      ]
+    }
+  );
+}
+function WETHIcon({ className, size = 24 }) {
+  return /* @__PURE__ */ jsxRuntime.jsxs(
+    "svg",
+    {
+      width: size,
+      height: size,
+      viewBox: "0 0 250 250",
+      fill: "none",
+      xmlns: "http://www.w3.org/2000/svg",
+      className,
+      children: [
+        /* @__PURE__ */ jsxRuntime.jsx(
+          "path",
+          {
+            d: "M0 125C0 55.9644 55.9644 0 125 0C194.036 0 250 55.9644 250 125C250 194.036 194.036 250 125 250C55.9644 250 0 194.036 0 125Z",
+            fill: "#627EEA"
+          }
+        ),
+        /* @__PURE__ */ jsxRuntime.jsx(
+          "path",
+          {
+            d: "M125.047 30.5V100.351L184.086 126.732L125.047 30.5Z",
+            fill: "white",
+            fillOpacity: "0.602"
+          }
+        ),
+        /* @__PURE__ */ jsxRuntime.jsx("path", { d: "M125.047 30.5L66 126.732L125.047 100.351V30.5Z", fill: "white" }),
+        /* @__PURE__ */ jsxRuntime.jsx(
+          "path",
+          {
+            d: "M125.047 172V219.462L184.125 137.728L125.047 172Z",
+            fill: "white",
+            fillOpacity: "0.602"
+          }
+        ),
+        /* @__PURE__ */ jsxRuntime.jsx("path", { d: "M125.047 219.462V171.992L66 137.728L125.047 219.462Z", fill: "white" }),
+        /* @__PURE__ */ jsxRuntime.jsx(
+          "path",
+          {
+            d: "M125.047 161.013L184.086 126.733L125.047 100.368V161.013Z",
+            fill: "white",
+            fillOpacity: "0.2"
+          }
+        ),
+        /* @__PURE__ */ jsxRuntime.jsx("path", { d: "M66 126.733L125.047 161.013V100.368L66 126.733Z", fill: "white", fillOpacity: "0.602" })
+      ]
+    }
+  );
+}
+function getTokenIcon(symbol, size) {
+  const iconSize = size ?? 24;
+  switch (symbol.toUpperCase()) {
+    case "USDC":
+      return /* @__PURE__ */ jsxRuntime.jsx(USDCIcon, { size: iconSize });
+    case "WETH":
+      return /* @__PURE__ */ jsxRuntime.jsx(WETHIcon, { size: iconSize });
+    default:
+      return /* @__PURE__ */ jsxRuntime.jsx(
+        "div",
+        {
+          className: "bg-muted flex items-center justify-center rounded-full text-xs font-bold",
+          style: { width: iconSize, height: iconSize },
+          children: symbol.slice(0, 2)
+        }
+      );
+  }
+}
+function getChainIcon(chainId, size) {
+  const iconSize = size ?? 24;
+  switch (chainId) {
+    case 84532:
+      return /* @__PURE__ */ jsxRuntime.jsx(BaseIcon, { size: iconSize });
+    default:
+      return /* @__PURE__ */ jsxRuntime.jsx(
+        "div",
+        {
+          className: "bg-muted flex items-center justify-center rounded-full text-xs font-bold",
+          style: { width: iconSize, height: iconSize },
+          children: "?"
+        }
+      );
+  }
+}
+function CheckIcon() {
+  return /* @__PURE__ */ jsxRuntime.jsx("svg", { width: "14", height: "14", viewBox: "0 0 12 12", fill: "none", children: /* @__PURE__ */ jsxRuntime.jsx(
+    "path",
+    {
+      d: "M2.5 6l2.5 2.5 4.5-4.5",
+      stroke: "currentColor",
+      strokeWidth: "1.5",
+      strokeLinecap: "round",
+      strokeLinejoin: "round"
+    }
+  ) });
+}
+function ExternalLinkIcon() {
+  return /* @__PURE__ */ jsxRuntime.jsx("svg", { width: "12", height: "12", viewBox: "0 0 12 12", fill: "none", children: /* @__PURE__ */ jsxRuntime.jsx(
+    "path",
+    {
+      d: "M3.5 1.5h7v7M10.5 1.5L1.5 10.5",
+      stroke: "currentColor",
+      strokeWidth: "1.5",
+      strokeLinecap: "round",
+      strokeLinejoin: "round"
+    }
+  ) });
+}
+function Spinner({ size = 20 }) {
+  return /* @__PURE__ */ jsxRuntime.jsxs("svg", { width: size, height: size, viewBox: "0 0 20 20", fill: "none", className: "animate-spin", children: [
+    /* @__PURE__ */ jsxRuntime.jsx("circle", { cx: "10", cy: "10", r: "8", stroke: "currentColor", strokeWidth: "2", opacity: "0.15" }),
+    /* @__PURE__ */ jsxRuntime.jsx("path", { d: "M10 2a8 8 0 016.93 4", stroke: "currentColor", strokeWidth: "2", strokeLinecap: "round" })
+  ] });
+}
+function TransactionProgressView({ title, steps, onCancel }) {
+  const completed = steps.filter((s) => s.status === "completed").length;
+  const active = steps.find((s) => s.status === "active");
+  const total = steps.length;
+  const progress = (completed + (active ? 0.5 : 0)) / total * 100;
+  return /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex w-full flex-col gap-4", children: [
+    /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex items-center gap-3", children: [
+      /* @__PURE__ */ jsxRuntime.jsx("div", { className: "text-primary", children: /* @__PURE__ */ jsxRuntime.jsx(Spinner, { size: 20 }) }),
+      /* @__PURE__ */ jsxRuntime.jsx("span", { className: "text-foreground text-sm font-medium", children: active?.label ?? title })
+    ] }),
+    /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex flex-col gap-1.5", children: [
+      /* @__PURE__ */ jsxRuntime.jsx("div", { className: "bg-secondary h-1.5 w-full overflow-hidden rounded-full", children: /* @__PURE__ */ jsxRuntime.jsx(
+        "div",
+        {
+          className: "bg-primary h-full rounded-full transition-all duration-500",
+          style: { width: `${progress}%` }
+        }
+      ) }),
+      /* @__PURE__ */ jsxRuntime.jsxs("span", { className: "text-muted-foreground text-xs", children: [
+        "Step ",
+        Math.max(1, completed + (active ? 1 : 0)),
+        " of ",
+        total
+      ] })
+    ] }),
+    onCancel && /* @__PURE__ */ jsxRuntime.jsx(
+      "button",
+      {
+        onClick: onCancel,
+        className: "border-border text-foreground hover:bg-secondary flex h-10 w-full cursor-pointer items-center justify-center rounded-[10px] border px-3 py-2 text-sm font-medium transition-colors",
+        children: "Cancel"
+      }
+    )
+  ] });
+}
+function TransactionSuccessView({
+  title,
+  message,
+  explorerUrl,
+  explorerLabel,
+  onDone
+}) {
+  return /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex w-full flex-col gap-4", children: [
+    /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex items-center gap-3", children: [
+      /* @__PURE__ */ jsxRuntime.jsx("div", { className: "flex h-7 w-7 shrink-0 items-center justify-center rounded-full bg-emerald-500/10 text-emerald-400", children: /* @__PURE__ */ jsxRuntime.jsx(CheckIcon, {}) }),
+      /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex flex-col gap-0.5", children: [
+        /* @__PURE__ */ jsxRuntime.jsx("span", { className: "text-foreground text-sm font-medium", children: title }),
+        /* @__PURE__ */ jsxRuntime.jsx("span", { className: "text-muted-foreground text-xs", children: message })
+      ] })
+    ] }),
+    /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex gap-2", children: [
+      explorerUrl && /* @__PURE__ */ jsxRuntime.jsxs(
+        "a",
+        {
+          href: explorerUrl,
+          target: "_blank",
+          rel: "noopener noreferrer",
+          className: "border-border text-foreground hover:bg-secondary flex h-10 flex-1 items-center justify-center gap-1.5 rounded-[10px] border text-sm transition-colors",
+          children: [
+            explorerLabel ?? "View on Explorer",
+            /* @__PURE__ */ jsxRuntime.jsx(ExternalLinkIcon, {})
+          ]
+        }
+      ),
+      /* @__PURE__ */ jsxRuntime.jsx(
+        "button",
+        {
+          onClick: onDone,
+          className: "bg-primary text-primary-foreground hover:bg-primary/90 flex h-10 flex-1 cursor-pointer items-center justify-center rounded-[10px] px-3 py-2 text-sm font-medium transition-colors",
+          children: "Done"
+        }
+      )
+    ] })
+  ] });
+}
+function WarningIcon() {
+  return /* @__PURE__ */ jsxRuntime.jsx("svg", { width: "14", height: "14", viewBox: "0 0 14 14", fill: "none", children: /* @__PURE__ */ jsxRuntime.jsx(
+    "path",
+    {
+      d: "M7 5v2.5M7 10h.005M6.13 2.5h1.74L13 11.5H1L6.13 2.5z",
+      stroke: "currentColor",
+      strokeWidth: "1.5",
+      strokeLinecap: "round",
+      strokeLinejoin: "round"
+    }
+  ) });
+}
+function TransactionWarningView({ title, message, onDone }) {
+  return /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex w-full flex-col gap-4", children: [
+    /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex items-center gap-3", children: [
+      /* @__PURE__ */ jsxRuntime.jsx("div", { className: "flex h-7 w-7 shrink-0 items-center justify-center rounded-full bg-amber-500/10 text-amber-400", children: /* @__PURE__ */ jsxRuntime.jsx(WarningIcon, {}) }),
+      /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex flex-col gap-0.5", children: [
+        /* @__PURE__ */ jsxRuntime.jsx("span", { className: "text-foreground text-sm font-medium", children: title }),
+        /* @__PURE__ */ jsxRuntime.jsx("span", { className: "text-muted-foreground text-xs", children: message })
+      ] })
+    ] }),
+    /* @__PURE__ */ jsxRuntime.jsx(
+      "button",
+      {
+        onClick: onDone,
+        className: "bg-primary text-primary-foreground hover:bg-primary/90 flex h-10 w-full cursor-pointer items-center justify-center rounded-[10px] px-3 py-2 text-sm font-medium transition-colors",
+        children: "Done"
+      }
+    )
+  ] });
+}
+function TransactionErrorView({
+  title,
+  message,
+  explorerUrl,
+  explorerLabel,
+  onRetry,
+  onDismiss,
+  isRetrying
+}) {
+  return /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex w-full flex-col gap-4", children: [
+    /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex items-center gap-3", children: [
+      /* @__PURE__ */ jsxRuntime.jsx("div", { className: "flex h-7 w-7 shrink-0 items-center justify-center rounded-full bg-amber-500/10 text-amber-400", children: /* @__PURE__ */ jsxRuntime.jsx(WarningIcon, {}) }),
+      /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex flex-col gap-0.5", children: [
+        /* @__PURE__ */ jsxRuntime.jsx("span", { className: "text-foreground text-sm font-medium", children: title }),
+        /* @__PURE__ */ jsxRuntime.jsx("span", { className: "text-muted-foreground text-xs", children: message })
+      ] })
+    ] }),
+    explorerUrl && /* @__PURE__ */ jsxRuntime.jsxs(
+      "a",
+      {
+        href: explorerUrl,
+        target: "_blank",
+        rel: "noopener noreferrer",
+        className: "border-border text-foreground hover:bg-secondary flex h-10 w-full items-center justify-center gap-1.5 rounded-[10px] border text-sm transition-colors",
+        children: [
+          explorerLabel ?? "View on Explorer",
+          /* @__PURE__ */ jsxRuntime.jsx(ExternalLinkIcon, {})
+        ]
+      }
+    ),
+    /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex gap-2", children: [
+      /* @__PURE__ */ jsxRuntime.jsx(
+        "button",
+        {
+          onClick: onDismiss,
+          disabled: isRetrying,
+          className: "border-border text-foreground hover:bg-secondary flex h-10 flex-1 cursor-pointer items-center justify-center rounded-[10px] border px-3 py-2 text-sm font-medium transition-colors disabled:cursor-not-allowed disabled:opacity-50",
+          children: "Close"
+        }
+      ),
+      /* @__PURE__ */ jsxRuntime.jsx(
+        "button",
+        {
+          onClick: onRetry,
+          disabled: isRetrying,
+          className: "bg-primary text-primary-foreground hover:bg-primary/90 flex h-10 flex-1 cursor-pointer items-center justify-center rounded-[10px] px-3 py-2 text-sm font-medium transition-colors disabled:cursor-not-allowed disabled:opacity-50",
+          children: isRetrying ? "Retrying..." : "Retry Verification"
+        }
+      )
+    ] })
+  ] });
+}
+function DepositForm({
+  selectedToken,
+  onTokenSelect,
+  onPendingChange,
+  onSuccess
+}) {
+  const { isConnected, address } = wagmi.useAccount();
+  const { chains, getChainById: getChainById2 } = usePrivanaContext();
+  const [amount, setAmount] = react.useState("");
+  const [showSuccess, setShowSuccess] = react.useState(false);
+  const [showTimeout, setShowTimeout] = react.useState(false);
+  const [cancelled, setCancelled] = react.useState(false);
+  const targetChain = getChainById2(selectedToken.chainId) ?? chains[0];
+  const isNative = selectedToken.contract === viem.zeroAddress;
+  const { data: nativeBalanceData } = wagmi.useBalance({
+    address,
+    chainId: targetChain?.id,
+    query: {
+      enabled: !!address && isNative
+    }
+  });
+  const { data: erc20Balance } = wagmi.useReadContract({
+    address: selectedToken.contract,
+    abi: viem.erc20Abi,
+    functionName: "balanceOf",
+    args: address ? [address] : void 0,
+    chainId: targetChain?.id,
+    query: {
+      enabled: !!address && !isNative
+    }
+  });
+  const walletBalance = isNative ? nativeBalanceData?.value : erc20Balance;
+  const formattedWalletBalance = walletBalance ? formatTokenAmount(walletBalance.toString(), selectedToken.decimals) : "0";
+  const handleMaxClick = () => {
+    if (formattedWalletBalance && parseFloat(formattedWalletBalance) > 0) {
+      setAmount(formattedWalletBalance.replace(/[\s\u2009]/g, ""));
+    }
+  };
+  const hasValidAmount = amount && parseFloat(amount) > 0;
+  const tooManyDecimals = hasValidAmount && amount.includes(".") && amount.split(".")[1].length > selectedToken.decimals;
+  const exceedsBalance = hasValidAmount && !tooManyDecimals && walletBalance != null && parseTokenAmount(amount, selectedToken.decimals) > walletBalance;
+  const {
+    txHash,
+    isGettingAddress,
+    isSwitchingChain,
+    isSendingTransaction,
+    isWaitingForConfirmation,
+    isWaitingForProcessing,
+    verificationFailed,
+    isPending,
+    error,
+    deposit,
+    retryVerification,
+    reset
+  } = useDeposit({
+    onCredited: () => {
+      setAmount("");
+      if (onSuccess) {
+        reset();
+        onSuccess();
+      } else {
+        setShowSuccess(true);
+      }
+    },
+    onCheckTimeout: () => {
+      setAmount("");
+      setShowTimeout(true);
+    }
+  });
+  const depositSteps = [
+    {
+      label: "Getting deposit address",
+      status: isGettingAddress ? "active" : isSwitchingChain || isSendingTransaction || isWaitingForConfirmation || isWaitingForProcessing ? "completed" : "pending"
+    },
+    {
+      label: `Switching to ${targetChain?.name ?? "deposit chain"}`,
+      status: isSwitchingChain ? "active" : isSendingTransaction || isWaitingForConfirmation || isWaitingForProcessing ? "completed" : "pending"
+    },
+    {
+      label: "Confirm in wallet",
+      status: isSendingTransaction ? "active" : isWaitingForConfirmation || isWaitingForProcessing ? "completed" : "pending"
+    },
+    {
+      label: "Confirming transaction",
+      status: isWaitingForConfirmation ? "active" : isWaitingForProcessing ? "completed" : "pending"
+    },
+    {
+      label: "Verifying deposit \u2014 may take up to a few minutes",
+      status: isWaitingForProcessing ? "active" : "pending"
+    }
+  ];
+  react.useEffect(() => {
+    if (error && !verificationFailed) {
+      sonner.toast.error(error.message.length > 100 ? `${error.message.slice(0, 100)}...` : error.message);
+    }
+  }, [error, verificationFailed]);
+  react.useEffect(() => {
+    onPendingChange?.(isPending && !cancelled);
+  }, [isPending, cancelled, onPendingChange]);
+  const handleCancel = () => {
+    setCancelled(true);
+    reset();
+  };
+  const handleDone = () => {
+    setShowSuccess(false);
+    setShowTimeout(false);
+    setCancelled(false);
+    reset();
+  };
+  const handleDismissVerificationError = () => {
+    setAmount("");
+    setCancelled(false);
+    reset();
+  };
+  const handleRetryVerification = () => {
+    retryVerification().catch(() => {
+    });
+  };
+  const explorerTxUrl = txHash && targetChain?.explorerUrl ? `${targetChain.explorerUrl}/tx/${txHash}` : void 0;
+  const handleSubmit = async () => {
+    if (!amount || !selectedToken || exceedsBalance) return;
+    setCancelled(false);
+    const amountInWei = parseTokenAmount(amount, selectedToken.decimals);
+    await deposit({
+      tokenId: selectedToken.id,
+      amount: amountInWei
+    });
+  };
+  const getButtonText = () => {
+    if (!isConnected) return "Connect Wallet";
+    if (isSwitchingChain) return "Switching...";
+    return "Deposit";
+  };
+  if (showSuccess) {
+    return /* @__PURE__ */ jsxRuntime.jsx(
+      TransactionSuccessView,
+      {
+        title: "Deposit Successful",
+        message: `Your ${selectedToken.symbol} deposit has been processed.`,
+        onDone: handleDone
+      }
+    );
+  }
+  if (showTimeout) {
+    return /* @__PURE__ */ jsxRuntime.jsx(
+      TransactionWarningView,
+      {
+        title: "Deposit Processing",
+        message: `Your transaction was confirmed but the deposit is still being processed. Please check your balance - it should update shortly.`,
+        onDone: handleDone
+      }
+    );
+  }
+  if (verificationFailed) {
+    const baseMessage = "Your transfer was sent on-chain but we could not verify the deposit. The funds are already at the deposit address \u2014 retry verification instead of starting a new deposit.";
+    const detail = error?.message;
+    const message = detail ? `${baseMessage} (${detail})` : baseMessage;
+    return /* @__PURE__ */ jsxRuntime.jsx(
+      TransactionErrorView,
+      {
+        title: "Verification failed",
+        message,
+        explorerUrl: explorerTxUrl,
+        explorerLabel: "View transaction",
+        onRetry: handleRetryVerification,
+        onDismiss: handleDismissVerificationError
+      }
+    );
+  }
+  if (isPending && !cancelled) {
+    const canCancel = isGettingAddress || isSendingTransaction;
+    return /* @__PURE__ */ jsxRuntime.jsx(
+      TransactionProgressView,
+      {
+        title: "Depositing...",
+        steps: depositSteps,
+        onCancel: canCancel ? handleCancel : void 0
+      }
+    );
+  }
+  return /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex w-full flex-col gap-6", children: [
+    /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex w-full flex-col gap-3", children: [
+      /* @__PURE__ */ jsxRuntime.jsx("label", { className: "text-muted-foreground text-sm", children: "Token" }),
+      /* @__PURE__ */ jsxRuntime.jsxs(
+        "button",
+        {
+          onClick: onTokenSelect,
+          className: "border-border bg-input flex w-full cursor-pointer items-center gap-3 rounded-lg border p-3",
+          children: [
+            /* @__PURE__ */ jsxRuntime.jsx("div", { className: "h-8 w-8 shrink-0 overflow-hidden rounded-full", children: getTokenIcon(selectedToken.symbol, 32) }),
+            /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex flex-1 flex-col items-start gap-1", children: [
+              /* @__PURE__ */ jsxRuntime.jsx("span", { className: "text-foreground text-sm font-medium", children: selectedToken.symbol }),
+              /* @__PURE__ */ jsxRuntime.jsxs("span", { className: "text-muted-foreground text-xs", children: [
+                "on ",
+                targetChain?.name ?? "Base Sepolia"
+              ] })
+            ] }),
+            /* @__PURE__ */ jsxRuntime.jsx("div", { className: "text-muted-foreground flex h-5 w-5 items-center justify-center", children: /* @__PURE__ */ jsxRuntime.jsx(ChevronRightIcon, {}) })
+          ]
+        }
+      )
+    ] }),
+    /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex w-full flex-col gap-3", children: [
+      /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex items-center justify-between", children: [
+        /* @__PURE__ */ jsxRuntime.jsx("label", { className: "text-muted-foreground text-sm", children: "Amount" }),
+        /* @__PURE__ */ jsxRuntime.jsxs("span", { className: "text-muted-foreground text-sm", children: [
+          formattedWalletBalance,
+          " ",
+          selectedToken.symbol
+        ] })
+      ] }),
+      /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "border-border bg-input flex items-center gap-2 rounded-[10px] border py-1 pr-1 pl-3", children: [
+        /* @__PURE__ */ jsxRuntime.jsx(
+          "input",
+          {
+            type: "text",
+            inputMode: "decimal",
+            placeholder: "Enter Amount",
+            value: amount,
+            onChange: (e) => {
+              const value = e.target.value.replace(/[^0-9.,]/g, "").replace(/,/g, ".");
+              if (value.split(".").length <= 2) {
+                setAmount(value);
+              }
+            },
+            className: cn(
+              "text-foreground flex-1 bg-transparent text-sm outline-none",
+              "placeholder:text-muted-foreground/50"
+            )
+          }
+        ),
+        /* @__PURE__ */ jsxRuntime.jsx(
+          "button",
+          {
+            onClick: handleMaxClick,
+            className: "bg-secondary text-foreground hover:bg-secondary/80 cursor-pointer rounded px-3 py-2.5 text-xs font-semibold transition-colors",
+            children: "MAX"
+          }
+        )
+      ] }),
+      tooManyDecimals && /* @__PURE__ */ jsxRuntime.jsxs("p", { className: "text-destructive text-sm", children: [
+        "Too many decimal places (max: ",
+        selectedToken.decimals,
+        ")"
+      ] }),
+      exceedsBalance && /* @__PURE__ */ jsxRuntime.jsx("p", { className: "text-destructive text-sm", children: "Insufficient balance" })
+    ] }),
+    /* @__PURE__ */ jsxRuntime.jsx(
+      "button",
+      {
+        onClick: handleSubmit,
+        disabled: !isConnected || !hasValidAmount || tooManyDecimals || !!exceedsBalance || isPending,
+        className: cn(
+          "flex h-10 w-full cursor-pointer items-center justify-center rounded-[10px] px-3 py-2 text-sm font-medium transition-colors",
+          "bg-primary text-primary-foreground hover:bg-primary/90",
+          "disabled:cursor-not-allowed disabled:opacity-50"
+        ),
+        children: getButtonText()
+      }
+    )
+  ] });
+}
+function WithdrawForm({ selectedToken, onTokenSelect, onPendingChange }) {
+  const { isConnected, address } = wagmi.useAccount();
+  const { chains, getChainById: getChainById2 } = usePrivanaContext();
+  const [amount, setAmount] = react.useState("");
+  const [showSuccess, setShowSuccess] = react.useState(false);
+  const [showTimeout, setShowTimeout] = react.useState(false);
+  const [cancelled, setCancelled] = react.useState(false);
+  const targetChain = getChainById2(selectedToken.chainId) ?? chains[0];
+  const {
+    balanceWei,
+    isLoading: isBalanceLoading,
+    isError: isBalanceError
+  } = useBalance({
+    tokenId: selectedToken.id
+  });
+  const formattedBalance = formatTokenAmount(balanceWei, selectedToken.decimals);
+  const { withdraw, isPending, currentStep, error, reset } = useWithdraw({
+    onProcessingSuccess: () => {
+      setAmount("");
+      setShowSuccess(true);
+    },
+    onProcessingTimeout: () => {
+      setAmount("");
+      setShowTimeout(true);
+    }
+  });
+  const explorerUrl = address && targetChain ? getExplorerAddressUrl(targetChain.id, address) : void 0;
+  const getStepStatus = (step, after) => {
+    if (currentStep === step) return "active";
+    if (after.includes(currentStep)) return "completed";
+    return "pending";
+  };
+  const withdrawSteps = [
+    {
+      label: "Switching to signing chain",
+      status: getStepStatus("switching-chain", ["signing", "submitting", "processing"])
+    },
+    { label: "Sign in wallet", status: getStepStatus("signing", ["submitting", "processing"]) },
+    {
+      label: "Submitting withdrawal",
+      status: getStepStatus("submitting", ["processing"])
+    },
+    {
+      label: "Processing \u2014 may take a minute or two",
+      status: getStepStatus("processing", [])
+    }
+  ];
+  react.useEffect(() => {
+    if (error) {
+      sonner.toast.error(error.message.length > 100 ? `${error.message.slice(0, 100)}...` : error.message);
+    }
+  }, [error]);
+  react.useEffect(() => {
+    onPendingChange?.(isPending && !cancelled);
+  }, [isPending, cancelled, onPendingChange]);
+  const handleCancel = () => {
+    setCancelled(true);
+    reset();
+  };
+  const handleDone = () => {
+    setShowSuccess(false);
+    setShowTimeout(false);
+    setCancelled(false);
+    reset();
+  };
+  const handleWithdraw = async () => {
+    if (!amount || !selectedToken || exceedsBalance) return;
+    setCancelled(false);
+    const amountInWei = parseTokenAmount(amount, selectedToken.decimals);
+    await withdraw({
+      tokenId: selectedToken.id,
+      amount: amountInWei
+    });
+  };
+  const handleMaxClick = () => {
+    if (formattedBalance && parseFloat(formattedBalance) > 0) {
+      setAmount(formattedBalance.replace(/[\s\u2009]/g, ""));
+    }
+  };
+  const hasValidAmount = amount && parseFloat(amount) > 0;
+  const tooManyDecimals = hasValidAmount && amount.includes(".") && amount.split(".")[1].length > selectedToken.decimals;
+  const exceedsBalance = hasValidAmount && !tooManyDecimals && !isBalanceLoading && !isBalanceError && parseTokenAmount(amount, selectedToken.decimals) > BigInt(balanceWei);
+  const getButtonText = () => {
+    if (!isConnected) return "Connect Wallet";
+    return "Withdraw";
+  };
+  if (showSuccess) {
+    return /* @__PURE__ */ jsxRuntime.jsx(
+      TransactionSuccessView,
+      {
+        title: "Withdrawal Complete",
+        message: `Your ${selectedToken.symbol} withdrawal has been processed. Funds should appear in your wallet shortly.`,
+        explorerUrl,
+        explorerLabel: "View on BaseScan",
+        onDone: handleDone
+      }
+    );
+  }
+  if (showTimeout) {
+    return /* @__PURE__ */ jsxRuntime.jsx(
+      TransactionWarningView,
+      {
+        title: "Withdrawal Processing",
+        message: `Your withdrawal is still being processed. Please check your balance \u2014 it should update shortly.`,
+        onDone: handleDone
+      }
+    );
+  }
+  if (isPending && !cancelled) {
+    const canCancel = currentStep === "idle" || currentStep === "switching-chain" || currentStep === "signing";
+    return /* @__PURE__ */ jsxRuntime.jsx(
+      TransactionProgressView,
+      {
+        title: "Withdrawing...",
+        steps: withdrawSteps,
+        onCancel: canCancel ? handleCancel : void 0
+      }
+    );
+  }
+  return /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex w-full flex-col gap-6", children: [
+    /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex w-full flex-col gap-3", children: [
+      /* @__PURE__ */ jsxRuntime.jsx("label", { className: "text-muted-foreground text-sm", children: "Token" }),
+      /* @__PURE__ */ jsxRuntime.jsxs(
+        "button",
+        {
+          onClick: onTokenSelect,
+          className: "border-border bg-input flex w-full cursor-pointer items-center gap-3 rounded-lg border p-3",
+          children: [
+            /* @__PURE__ */ jsxRuntime.jsx("div", { className: "h-8 w-8 shrink-0 overflow-hidden rounded-full", children: getTokenIcon(selectedToken.symbol, 32) }),
+            /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex flex-1 flex-col items-start gap-1", children: [
+              /* @__PURE__ */ jsxRuntime.jsx("span", { className: "text-foreground text-sm font-medium", children: selectedToken.symbol }),
+              /* @__PURE__ */ jsxRuntime.jsxs("span", { className: "text-muted-foreground text-xs", children: [
+                "on ",
+                targetChain?.name ?? "Base Sepolia"
+              ] })
+            ] }),
+            /* @__PURE__ */ jsxRuntime.jsx("div", { className: "text-muted-foreground flex h-5 w-5 items-center justify-center", children: /* @__PURE__ */ jsxRuntime.jsx(ChevronRightIcon, {}) })
+          ]
+        }
+      )
+    ] }),
+    /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex w-full flex-col gap-3", children: [
+      /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex items-center justify-between", children: [
+        /* @__PURE__ */ jsxRuntime.jsx("label", { className: "text-muted-foreground text-sm", children: "Amount" }),
+        /* @__PURE__ */ jsxRuntime.jsxs("span", { className: "text-muted-foreground text-sm", children: [
+          formattedBalance,
+          " ",
+          selectedToken.symbol
+        ] })
+      ] }),
+      /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "border-border bg-input flex items-center gap-2 rounded-[10px] border py-1 pr-1 pl-3", children: [
+        /* @__PURE__ */ jsxRuntime.jsx(
+          "input",
+          {
+            type: "text",
+            inputMode: "decimal",
+            placeholder: "Enter Amount",
+            value: amount,
+            onChange: (e) => {
+              const value = e.target.value.replace(/[^0-9.,]/g, "").replace(/,/g, ".");
+              if (value.split(".").length <= 2) {
+                setAmount(value);
+              }
+            },
+            className: cn(
+              "text-foreground flex-1 bg-transparent text-sm outline-none",
+              "placeholder:text-muted-foreground/50"
+            )
+          }
+        ),
+        /* @__PURE__ */ jsxRuntime.jsx(
+          "button",
+          {
+            onClick: handleMaxClick,
+            className: "bg-secondary text-foreground hover:bg-secondary/80 cursor-pointer rounded px-3 py-2.5 text-xs font-semibold transition-colors",
+            children: "MAX"
+          }
+        )
+      ] }),
+      tooManyDecimals && /* @__PURE__ */ jsxRuntime.jsxs("p", { className: "text-destructive text-sm", children: [
+        "Too many decimal places (max: ",
+        selectedToken.decimals,
+        ")"
+      ] }),
+      exceedsBalance && /* @__PURE__ */ jsxRuntime.jsx("p", { className: "text-destructive text-sm", children: "Insufficient balance" })
+    ] }),
+    /* @__PURE__ */ jsxRuntime.jsx(
+      "button",
+      {
+        onClick: handleWithdraw,
+        disabled: !isConnected || !hasValidAmount || tooManyDecimals || !!exceedsBalance || isPending,
+        className: cn(
+          "flex h-10 w-full cursor-pointer items-center justify-center rounded-[10px] px-3 py-2 text-sm font-medium transition-colors",
+          "bg-primary text-primary-foreground hover:bg-primary/90",
+          "disabled:cursor-not-allowed disabled:opacity-50"
+        ),
+        children: getButtonText()
+      }
+    )
+  ] });
+}
+function CloseIcon() {
+  return /* @__PURE__ */ jsxRuntime.jsx("svg", { width: "10", height: "10", viewBox: "0 0 12 12", fill: "none", children: /* @__PURE__ */ jsxRuntime.jsx(
+    "path",
+    {
+      d: "M11.99997 11.99997l-5.99995-5.99995-6.00002-6.00002m6.00002 6.00002l6.00001-6.00002m-12.00003 12.00003l6.00002-6.00001",
+      stroke: "currentColor",
+      strokeWidth: "1.5",
+      strokeLinecap: "round",
+      strokeLinejoin: "round"
+    }
+  ) });
+}
+function SearchIcon() {
+  return /* @__PURE__ */ jsxRuntime.jsx("div", { className: "h-3 w-3 rounded-full border-[1.5px] border-current" });
+}
+function ChevronRight() {
+  return /* @__PURE__ */ jsxRuntime.jsx("svg", { width: "10", height: "5", viewBox: "0 0 12 6", className: "-rotate-90", children: /* @__PURE__ */ jsxRuntime.jsx(
+    "path",
+    {
+      d: "M0 0l6 6 6-6",
+      stroke: "currentColor",
+      strokeWidth: "1.5",
+      strokeLinecap: "round",
+      strokeLinejoin: "round",
+      fill: "none"
+    }
+  ) });
+}
+function ChevronLeft() {
+  return /* @__PURE__ */ jsxRuntime.jsx("svg", { width: "10", height: "5", viewBox: "0 0 12 6", className: "rotate-90", children: /* @__PURE__ */ jsxRuntime.jsx(
+    "path",
+    {
+      d: "M0 0l6 6 6-6",
+      stroke: "currentColor",
+      strokeWidth: "1.5",
+      strokeLinecap: "round",
+      strokeLinejoin: "round",
+      fill: "none"
+    }
+  ) });
+}
+function ChevronDown({ collapsed }) {
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    "svg",
+    {
+      width: "12",
+      height: "6",
+      viewBox: "0 0 12 6",
+      className: cn("transition-transform", collapsed && "-rotate-90"),
+      children: /* @__PURE__ */ jsxRuntime.jsx(
+        "path",
+        {
+          d: "M0 0l6 6 6-6",
+          stroke: "currentColor",
+          strokeWidth: "1.5",
+          strokeLinecap: "round",
+          strokeLinejoin: "round",
+          fill: "none"
+        }
+      )
+    }
+  );
+}
+function BalanceCards({
+  selectedToken,
+  onLockedFundsClick,
+  onBalanceClick,
+  showLockedFunds = true,
+  disabled
+}) {
+  const { balanceWei, isLoading: balanceLoading } = useBalance({
+    tokenId: selectedToken.id
+  });
+  const { totalLocked, isLoading: lockedLoading } = useLockedFunds({ enabled: showLockedFunds });
+  const formattedBalance = formatTokenAmount(balanceWei, selectedToken.decimals);
+  const formattedLocked = showLockedFunds ? formatTokenAmount(String(totalLocked), selectedToken.decimals) : "0";
+  return /* @__PURE__ */ jsxRuntime.jsxs("div", { className: cn("flex gap-2", disabled && "opacity-50"), children: [
+    /* @__PURE__ */ jsxRuntime.jsxs(
+      "button",
+      {
+        onClick: onBalanceClick,
+        disabled,
+        className: cn(
+          "bg-muted flex flex-1 flex-col gap-2 rounded-[10px] p-5 text-left transition-colors",
+          disabled ? "cursor-not-allowed" : "hover:bg-muted/80 cursor-pointer"
+        ),
+        children: [
+          /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex w-full items-center justify-between", children: [
+            /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex items-center gap-1", children: [
+              /* @__PURE__ */ jsxRuntime.jsx("span", { className: "text-muted-foreground text-sm", children: "Balance" }),
+              /* @__PURE__ */ jsxRuntime.jsx("span", { className: "bg-secondary text-muted-foreground rounded-full px-2 py-[5px] text-[10px] font-bold", children: selectedToken.symbol })
+            ] }),
+            /* @__PURE__ */ jsxRuntime.jsx("div", { className: "text-muted-foreground flex h-6 w-6 items-center justify-center", children: /* @__PURE__ */ jsxRuntime.jsx(ChevronRight, {}) })
+          ] }),
+          /* @__PURE__ */ jsxRuntime.jsx("div", { className: "text-foreground text-xl font-medium", children: balanceLoading ? /* @__PURE__ */ jsxRuntime.jsx("span", { className: "bg-secondary inline-block h-6 w-24 animate-pulse rounded" }) : formattedBalance })
+        ]
+      }
+    ),
+    showLockedFunds && /* @__PURE__ */ jsxRuntime.jsxs(
+      "button",
+      {
+        onClick: onLockedFundsClick,
+        disabled,
+        className: cn(
+          "bg-muted flex flex-1 flex-col gap-2 rounded-[10px] p-5 text-left transition-colors",
+          disabled ? "cursor-not-allowed" : "hover:bg-muted/80 cursor-pointer"
+        ),
+        children: [
+          /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex w-full items-center justify-between", children: [
+            /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex items-center gap-1", children: [
+              /* @__PURE__ */ jsxRuntime.jsx("span", { className: "text-muted-foreground text-sm", children: "Locked Funds" }),
+              /* @__PURE__ */ jsxRuntime.jsx("span", { className: "bg-secondary text-muted-foreground rounded-full px-2 py-[5px] text-[10px] font-bold", children: selectedToken.symbol })
+            ] }),
+            /* @__PURE__ */ jsxRuntime.jsx("div", { className: "text-muted-foreground flex h-6 w-6 items-center justify-center", children: /* @__PURE__ */ jsxRuntime.jsx(ChevronRight, {}) })
+          ] }),
+          /* @__PURE__ */ jsxRuntime.jsx("div", { className: "text-foreground text-xl font-medium", children: lockedLoading ? /* @__PURE__ */ jsxRuntime.jsx("span", { className: "bg-secondary inline-block h-6 w-20 animate-pulse rounded" }) : formattedLocked })
+        ]
+      }
+    )
+  ] });
+}
+function Tabs({
+  activeTab,
+  onTabChange,
+  disabled
+}) {
+  return /* @__PURE__ */ jsxRuntime.jsxs(
+    "div",
+    {
+      className: cn(
+        "bg-muted relative flex gap-2 overflow-hidden rounded-[10px] p-1",
+        disabled && "opacity-50"
+      ),
+      children: [
+        /* @__PURE__ */ jsxRuntime.jsx(
+          "div",
+          {
+            className: cn(
+              "bg-input absolute top-1 bottom-1 left-1 w-[calc(50%-4px)] rounded-md transition-transform duration-200",
+              activeTab === "withdraw" && "translate-x-[calc(100%+8px)]"
+            )
+          }
+        ),
+        /* @__PURE__ */ jsxRuntime.jsx(
+          "button",
+          {
+            onClick: () => !disabled && onTabChange("deposit"),
+            disabled,
+            className: cn(
+              "relative z-10 flex-1 rounded-md px-3 py-[9px] text-sm transition-colors",
+              activeTab === "deposit" ? "text-foreground" : "text-muted-foreground",
+              disabled ? "cursor-not-allowed" : "cursor-pointer"
+            ),
+            children: "Deposit"
+          }
+        ),
+        /* @__PURE__ */ jsxRuntime.jsx(
+          "button",
+          {
+            onClick: () => !disabled && onTabChange("withdraw"),
+            disabled,
+            className: cn(
+              "relative z-10 flex-1 rounded-md px-3 py-[9px] text-sm transition-colors",
+              activeTab === "withdraw" ? "text-foreground" : "text-muted-foreground",
+              disabled ? "cursor-not-allowed" : "cursor-pointer"
+            ),
+            children: "Withdraw"
+          }
+        )
+      ]
+    }
+  );
+}
+function LockedFundsView({ onBack, onClose }) {
+  const { getTokenById } = usePrivanaContext();
+  const { locks, isLoading } = useLockedFunds();
+  const { unlockFunds, unlockAllExpired, isPending } = useUnlockFunds();
+  const [collapsedSections, setCollapsedSections] = react.useState({});
+  const sections = react.useMemo(() => {
+    const sectionMap = {};
+    locks.forEach((lock) => {
+      const serviceName = shortenAddress(lock.service_address);
+      if (!sectionMap[lock.service_address]) {
+        sectionMap[lock.service_address] = {
+          title: `Service ${serviceName}`,
+          items: []
+        };
+      }
+      sectionMap[lock.service_address].items.push({
+        lockId: lock.lock_id,
+        amount: formatTokenAmount(String(lock.amount), getTokenById(lock.token_id)?.decimals ?? 18),
+        serviceAddress: lock.service_address,
+        time: lock.is_expired ? "Click to unlock" : formatTimeRemaining(lock.expiry),
+        isExpired: lock.is_expired
+      });
+    });
+    return Object.values(sectionMap);
+  }, [getTokenById, locks]);
+  const toggleSection = (title) => {
+    setCollapsedSections((prev) => ({
+      ...prev,
+      [title]: !prev[title]
+    }));
+  };
+  const expiredCount = locks.filter((l) => l.is_expired).length;
+  return /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
+    /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex items-center justify-between px-5 py-4", children: [
+      /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex items-center gap-2.5", children: [
+        /* @__PURE__ */ jsxRuntime.jsx(
+          "button",
+          {
+            onClick: onBack,
+            className: "text-muted-foreground hover:text-foreground flex h-6 w-6 cursor-pointer items-center justify-center transition-colors",
+            children: /* @__PURE__ */ jsxRuntime.jsx(ChevronLeft, {})
+          }
+        ),
+        /* @__PURE__ */ jsxRuntime.jsx("span", { className: "text-foreground text-xl leading-6 font-medium", children: "Locked Funds" })
+      ] }),
+      onClose && /* @__PURE__ */ jsxRuntime.jsx(
+        "button",
+        {
+          onClick: onClose,
+          className: "text-muted-foreground hover:text-foreground flex h-6 w-6 cursor-pointer items-center justify-center transition-colors",
+          children: /* @__PURE__ */ jsxRuntime.jsx(CloseIcon, {})
+        }
+      )
+    ] }),
+    /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "bg-muted flex min-h-0 flex-1 flex-col rounded-[10px] p-2", children: [
+      /* @__PURE__ */ jsxRuntime.jsx("div", { className: "flex-1 overflow-y-auto", children: isLoading ? /* @__PURE__ */ jsxRuntime.jsx("div", { className: "flex flex-col gap-2 p-3", children: [1, 2].map((i) => /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex animate-pulse items-center gap-3 rounded-lg p-3", children: [
+        /* @__PURE__ */ jsxRuntime.jsx("div", { className: "bg-secondary h-10 w-10 rounded-full" }),
+        /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex-1", children: [
+          /* @__PURE__ */ jsxRuntime.jsx("div", { className: "bg-secondary mb-2 h-3.5 w-24 rounded" }),
+          /* @__PURE__ */ jsxRuntime.jsx("div", { className: "bg-secondary h-3 w-32 rounded" })
+        ] })
+      ] }, i)) }) : sections.length === 0 ? /* @__PURE__ */ jsxRuntime.jsx("div", { className: "flex items-center justify-center p-8", children: /* @__PURE__ */ jsxRuntime.jsx("span", { className: "text-muted-foreground text-sm", children: "No locked funds" }) }) : sections.map((section) => /* @__PURE__ */ jsxRuntime.jsxs("div", { children: [
+        /* @__PURE__ */ jsxRuntime.jsxs(
+          "button",
+          {
+            onClick: () => toggleSection(section.title),
+            className: "text-muted-foreground hover:bg-secondary flex w-full cursor-pointer items-center justify-between rounded-lg px-4 py-4 transition-colors",
+            children: [
+              /* @__PURE__ */ jsxRuntime.jsx("span", { className: "text-sm", children: section.title }),
+              /* @__PURE__ */ jsxRuntime.jsx(ChevronDown, { collapsed: collapsedSections[section.title] })
+            ]
+          }
+        ),
+        !collapsedSections[section.title] && section.items.map((item) => /* @__PURE__ */ jsxRuntime.jsxs(
+          "div",
+          {
+            className: cn(
+              "flex items-center justify-between gap-3 rounded-lg p-3",
+              item.isExpired && "bg-secondary"
+            ),
+            children: [
+              /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex flex-1 items-center gap-3", children: [
+                /* @__PURE__ */ jsxRuntime.jsx("div", { className: "bg-secondary h-10 w-10 rounded-full" }),
+                /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex flex-col gap-2", children: [
+                  /* @__PURE__ */ jsxRuntime.jsxs("span", { className: "text-foreground text-sm font-medium", children: [
+                    item.amount,
+                    " USDC"
+                  ] }),
+                  /* @__PURE__ */ jsxRuntime.jsxs("span", { className: "text-muted-foreground text-xs", children: [
+                    "Service: ",
+                    shortenAddress(item.serviceAddress)
+                  ] })
+                ] })
+              ] }),
+              /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex flex-1 flex-col items-end gap-2", children: [
+                item.isExpired ? /* @__PURE__ */ jsxRuntime.jsx(
+                  "button",
+                  {
+                    onClick: () => unlockFunds({ lockId: Number(item.lockId) }),
+                    disabled: isPending,
+                    className: "text-foreground hover:text-foreground/80 cursor-pointer text-sm transition-colors disabled:opacity-50",
+                    children: "Click to unlock"
+                  }
+                ) : /* @__PURE__ */ jsxRuntime.jsx("span", { className: "text-sm text-amber-500", children: item.time }),
+                /* @__PURE__ */ jsxRuntime.jsx("span", { className: "text-muted-foreground text-xs", children: "on Base Sepolia" })
+              ] })
+            ]
+          },
+          `${item.serviceAddress}-${item.lockId}`
+        ))
+      ] }, section.title)) }),
+      expiredCount > 0 && /* @__PURE__ */ jsxRuntime.jsx("div", { className: "p-3", children: /* @__PURE__ */ jsxRuntime.jsxs(
+        "button",
+        {
+          onClick: () => unlockAllExpired(),
+          disabled: isPending,
+          className: "border-border text-foreground hover:bg-secondary flex h-10 w-full cursor-pointer items-center justify-center rounded-[10px] border px-3 py-2 text-sm font-medium transition-colors disabled:opacity-50",
+          children: [
+            "Unlock All (",
+            expiredCount,
+            ")"
+          ]
+        }
+      ) })
+    ] })
+  ] });
+}
+function BalanceTokenRow({ token }) {
+  const { balanceWei, isLoading } = useBalance({
+    tokenId: token.id
+  });
+  const formattedBalance = formatTokenAmount(balanceWei, token.decimals);
+  return /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex w-full items-center gap-2 rounded-lg px-3 py-2.5", children: [
+    /* @__PURE__ */ jsxRuntime.jsx("div", { className: "h-[18px] w-[18px] overflow-hidden rounded-full", children: getTokenIcon(token.symbol, 18) }),
+    /* @__PURE__ */ jsxRuntime.jsx("span", { className: "text-foreground flex-1 text-sm", children: token.symbol }),
+    isLoading ? /* @__PURE__ */ jsxRuntime.jsx("span", { className: "bg-secondary h-4 w-16 animate-pulse rounded" }) : /* @__PURE__ */ jsxRuntime.jsx("span", { className: "text-muted-foreground text-sm", children: formattedBalance })
+  ] });
+}
+function BalanceDetailsView({ onBack, onClose }) {
+  const { enabledTokens, chains } = usePrivanaContext();
+  const [selectedChainId, setSelectedChainId] = react.useState(chains[0]?.id ?? 84532);
+  const chainTokens = react.useMemo(() => {
+    return enabledTokens.filter((t) => t.chainId === selectedChainId);
+  }, [enabledTokens, selectedChainId]);
+  return /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
+    /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex items-center justify-between px-5 py-4", children: [
+      /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex items-center gap-2.5", children: [
+        /* @__PURE__ */ jsxRuntime.jsx(
+          "button",
+          {
+            onClick: onBack,
+            className: "text-muted-foreground hover:text-foreground flex h-6 w-6 cursor-pointer items-center justify-center transition-colors",
+            children: /* @__PURE__ */ jsxRuntime.jsx(ChevronLeft, {})
+          }
+        ),
+        /* @__PURE__ */ jsxRuntime.jsx("span", { className: "text-foreground text-xl leading-6 font-medium", children: "Token Balances" })
+      ] }),
+      onClose && /* @__PURE__ */ jsxRuntime.jsx(
+        "button",
+        {
+          onClick: onClose,
+          className: "text-muted-foreground hover:text-foreground flex h-6 w-6 cursor-pointer items-center justify-center transition-colors",
+          children: /* @__PURE__ */ jsxRuntime.jsx(CloseIcon, {})
+        }
+      )
+    ] }),
+    /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex min-h-0 flex-1 gap-2", children: [
+      /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "bg-muted flex flex-1 flex-col overflow-hidden rounded-[10px] p-2", children: [
+        /* @__PURE__ */ jsxRuntime.jsx("div", { className: "px-4 pt-4 pb-2", children: /* @__PURE__ */ jsxRuntime.jsx("span", { className: "text-muted-foreground text-sm", children: "Network" }) }),
+        /* @__PURE__ */ jsxRuntime.jsx("div", { className: "mt-1 flex-1 overflow-y-auto", children: chains.map((chain) => {
+          const isSelected = selectedChainId === chain.id;
+          return /* @__PURE__ */ jsxRuntime.jsxs(
+            "button",
+            {
+              onClick: () => setSelectedChainId(chain.id),
+              className: cn(
+                "hover:bg-secondary flex w-full cursor-pointer items-center gap-2 rounded-lg px-3 py-2.5 text-left transition-colors",
+                isSelected && "bg-secondary"
+              ),
+              children: [
+                /* @__PURE__ */ jsxRuntime.jsx("div", { className: "h-[18px] w-[18px] overflow-hidden rounded-full", children: getChainIcon(chain.id, 18) }),
+                /* @__PURE__ */ jsxRuntime.jsx("span", { className: "text-foreground flex-1 text-sm", children: chain.name })
+              ]
+            },
+            chain.id
+          );
+        }) })
+      ] }),
+      /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "bg-muted flex flex-[2] flex-col overflow-hidden rounded-[10px] p-2", children: [
+        /* @__PURE__ */ jsxRuntime.jsx("div", { className: "px-4 pt-4 pb-2", children: /* @__PURE__ */ jsxRuntime.jsx("span", { className: "text-muted-foreground text-sm", children: "Token Balance" }) }),
+        /* @__PURE__ */ jsxRuntime.jsx("div", { className: "mt-2 flex-1 overflow-y-auto", children: chainTokens.map((token) => /* @__PURE__ */ jsxRuntime.jsx(BalanceTokenRow, { token }, token.id)) })
+      ] })
+    ] })
+  ] });
+}
+function TokenRow({
+  token,
+  isSelected,
+  onClick
+}) {
+  const { address } = wagmi.useAccount();
+  const isNative = token.contract === viem.zeroAddress;
+  const { data: nativeBalanceData } = wagmi.useBalance({
+    address,
+    chainId: token.chainId,
+    query: { enabled: !!address && isNative }
+  });
+  const { data: erc20Balance } = wagmi.useReadContract({
+    address: token.contract,
+    abi: viem.erc20Abi,
+    functionName: "balanceOf",
+    args: address ? [address] : void 0,
+    chainId: token.chainId,
+    query: { enabled: !!address && !isNative }
+  });
+  const walletBalance = isNative ? nativeBalanceData?.value : erc20Balance;
+  const formattedBalance = walletBalance ? formatTokenAmount(walletBalance.toString(), token.decimals) : "0.00";
+  return /* @__PURE__ */ jsxRuntime.jsxs(
+    "button",
+    {
+      onClick,
+      className: cn(
+        "hover:bg-secondary flex w-full cursor-pointer items-center gap-2 rounded-lg px-3 py-2.5 text-left transition-colors",
+        isSelected && "bg-secondary"
+      ),
+      children: [
+        /* @__PURE__ */ jsxRuntime.jsx("div", { className: "h-[18px] w-[18px] overflow-hidden rounded-full", children: getTokenIcon(token.symbol, 18) }),
+        /* @__PURE__ */ jsxRuntime.jsx("span", { className: "text-foreground flex-1 text-sm", children: token.symbol }),
+        /* @__PURE__ */ jsxRuntime.jsx("span", { className: "text-muted-foreground text-sm", children: formattedBalance })
+      ]
+    }
+  );
+}
+function TokenSelectorView({
+  onBack,
+  onClose,
+  onSelect,
+  selectedTokenId
+}) {
+  const [tokenSearch, setTokenSearch] = react.useState("");
+  const { enabledTokens, chains } = usePrivanaContext();
+  const [selectedChainId, setSelectedChainId] = react.useState(chains[0]?.id ?? 84532);
+  const chainTokens = react.useMemo(() => {
+    return enabledTokens.filter((t) => t.chainId === selectedChainId);
+  }, [enabledTokens, selectedChainId]);
+  const filteredTokens = react.useMemo(() => {
+    if (!tokenSearch) return chainTokens;
+    return chainTokens.filter(
+      (t) => t.symbol.toLowerCase().includes(tokenSearch.toLowerCase()) || t.name.toLowerCase().includes(tokenSearch.toLowerCase())
+    );
+  }, [tokenSearch, chainTokens]);
+  const handleTokenSelect = (token) => {
+    onSelect(token);
+    onBack();
+  };
+  return /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
+    /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex items-center justify-between px-5 py-4", children: [
+      /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex items-center gap-2.5", children: [
+        /* @__PURE__ */ jsxRuntime.jsx(
+          "button",
+          {
+            onClick: onBack,
+            className: "text-muted-foreground hover:text-foreground flex h-6 w-6 cursor-pointer items-center justify-center transition-colors",
+            children: /* @__PURE__ */ jsxRuntime.jsx(ChevronLeft, {})
+          }
+        ),
+        /* @__PURE__ */ jsxRuntime.jsx("span", { className: "text-foreground text-xl leading-6 font-medium", children: "Select Token" })
+      ] }),
+      onClose && /* @__PURE__ */ jsxRuntime.jsx(
+        "button",
+        {
+          onClick: onClose,
+          className: "text-muted-foreground hover:text-foreground flex h-6 w-6 cursor-pointer items-center justify-center transition-colors",
+          children: /* @__PURE__ */ jsxRuntime.jsx(CloseIcon, {})
+        }
+      )
+    ] }),
+    /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex min-h-0 flex-1 gap-2", children: [
+      /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "bg-muted flex flex-1 flex-col overflow-hidden rounded-[10px] p-2", children: [
+        /* @__PURE__ */ jsxRuntime.jsx("div", { className: "px-4 pt-4 pb-2", children: /* @__PURE__ */ jsxRuntime.jsx("span", { className: "text-muted-foreground text-sm", children: "Network" }) }),
+        /* @__PURE__ */ jsxRuntime.jsx("div", { className: "mt-1 flex-1 overflow-y-auto", children: chains.map((chain) => {
+          const isSelected = selectedChainId === chain.id;
+          return /* @__PURE__ */ jsxRuntime.jsxs(
+            "button",
+            {
+              onClick: () => setSelectedChainId(chain.id),
+              className: cn(
+                "hover:bg-secondary flex w-full cursor-pointer items-center gap-2 rounded-lg px-3 py-2.5 text-left transition-colors",
+                isSelected && "bg-secondary"
+              ),
+              children: [
+                /* @__PURE__ */ jsxRuntime.jsx("div", { className: "h-[18px] w-[18px] overflow-hidden rounded-full", children: getChainIcon(chain.id, 18) }),
+                /* @__PURE__ */ jsxRuntime.jsx("span", { className: "text-foreground flex-1 text-sm", children: chain.name })
+              ]
+            },
+            chain.id
+          );
+        }) })
+      ] }),
+      /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "bg-muted flex flex-[2] flex-col overflow-hidden rounded-[10px] p-2", children: [
+        /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex flex-col gap-1", children: [
+          /* @__PURE__ */ jsxRuntime.jsx("div", { className: "px-4 pt-4 pb-2", children: /* @__PURE__ */ jsxRuntime.jsx("span", { className: "text-muted-foreground text-sm", children: "Token" }) }),
+          /* @__PURE__ */ jsxRuntime.jsx("div", { className: "px-3", children: /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "border-border bg-input flex items-center gap-2.5 rounded-lg border px-3 py-2.5", children: [
+            /* @__PURE__ */ jsxRuntime.jsx("span", { className: "text-muted-foreground", children: /* @__PURE__ */ jsxRuntime.jsx(SearchIcon, {}) }),
+            /* @__PURE__ */ jsxRuntime.jsx(
+              "input",
+              {
+                type: "text",
+                placeholder: "Search",
+                value: tokenSearch,
+                onChange: (e) => setTokenSearch(e.target.value),
+                className: "text-foreground placeholder:text-muted-foreground flex-1 bg-transparent text-sm outline-none"
+              }
+            )
+          ] }) })
+        ] }),
+        /* @__PURE__ */ jsxRuntime.jsx("div", { className: "mt-2 flex-1 overflow-y-auto", children: filteredTokens.map((token) => /* @__PURE__ */ jsxRuntime.jsx(
+          TokenRow,
+          {
+            token,
+            isSelected: selectedTokenId === token.id,
+            onClick: () => handleTokenSelect(token)
+          },
+          token.id
+        )) })
+      ] })
+    ] })
+  ] });
+}
+function ModalBody({
+  onClose,
+  onViewChange,
+  onTransactionPendingChange,
+  showLockedFunds = true,
+  defaultTab = "deposit",
+  onDepositSuccess
+}) {
+  const { defaultToken, tokensStatus } = usePrivanaContext();
+  const [selectedToken, setSelectedToken] = react.useState(defaultToken);
+  const [activeTab, setActiveTab] = react.useState(defaultTab);
+  const [currentView, setCurrentView] = react.useState("main");
+  const [isTransactionPending, setIsTransactionPending] = react.useState(false);
+  react.useEffect(() => {
+    if (!selectedToken && defaultToken) {
+      setSelectedToken(defaultToken);
+    }
+  }, [selectedToken, defaultToken]);
+  const handleTransactionPendingChange = (isPending) => {
+    setIsTransactionPending(isPending);
+    onTransactionPendingChange?.(isPending);
+  };
+  const handleViewChange = (view) => {
+    setCurrentView(view);
+    onViewChange?.(view);
+  };
+  const handleTokenSelect = (token) => {
+    setSelectedToken(token);
+  };
+  if (tokensStatus === "loading" || !selectedToken) {
+    return /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex flex-col gap-2 pb-4", children: [
+      /* @__PURE__ */ jsxRuntime.jsx("div", { className: "bg-secondary h-25 animate-pulse rounded-[10px]" }),
+      /* @__PURE__ */ jsxRuntime.jsx("div", { className: "bg-secondary h-11 animate-pulse rounded-[10px]" }),
+      /* @__PURE__ */ jsxRuntime.jsx("div", { className: "bg-secondary h-50 animate-pulse rounded-[10px]" })
+    ] });
+  }
+  if (currentView === "locked-funds") {
+    return /* @__PURE__ */ jsxRuntime.jsx(LockedFundsView, { onBack: () => handleViewChange("main"), onClose });
+  }
+  if (currentView === "balance-details") {
+    return /* @__PURE__ */ jsxRuntime.jsx(BalanceDetailsView, { onBack: () => handleViewChange("main"), onClose });
+  }
+  if (currentView === "select-token") {
+    return /* @__PURE__ */ jsxRuntime.jsx(
+      TokenSelectorView,
+      {
+        onBack: () => handleViewChange("main"),
+        onClose,
+        onSelect: handleTokenSelect,
+        selectedTokenId: selectedToken.id
+      }
+    );
+  }
+  return /* @__PURE__ */ jsxRuntime.jsx(jsxRuntime.Fragment, { children: /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex flex-col gap-2 pb-4", children: [
+    /* @__PURE__ */ jsxRuntime.jsx("div", { className: cn(isTransactionPending && "pointer-events-none"), children: /* @__PURE__ */ jsxRuntime.jsx(
+      BalanceCards,
+      {
+        selectedToken,
+        onLockedFundsClick: () => handleViewChange("locked-funds"),
+        onBalanceClick: () => handleViewChange("balance-details"),
+        showLockedFunds,
+        disabled: isTransactionPending
+      }
+    ) }),
+    /* @__PURE__ */ jsxRuntime.jsx("div", { className: cn(isTransactionPending && "pointer-events-none"), children: /* @__PURE__ */ jsxRuntime.jsx(Tabs, { activeTab, onTabChange: setActiveTab, disabled: isTransactionPending }) }),
+    /* @__PURE__ */ jsxRuntime.jsx("div", { className: "bg-muted rounded-[10px] p-5", children: activeTab === "deposit" ? /* @__PURE__ */ jsxRuntime.jsx(
+      DepositForm,
+      {
+        selectedToken,
+        onTokenSelect: () => handleViewChange("select-token"),
+        onPendingChange: handleTransactionPendingChange,
+        onSuccess: onDepositSuccess
+      }
+    ) : /* @__PURE__ */ jsxRuntime.jsx(
+      WithdrawForm,
+      {
+        selectedToken,
+        onTokenSelect: () => handleViewChange("select-token"),
+        onPendingChange: handleTransactionPendingChange
+      }
+    ) })
+  ] }) });
+}
+function PrivanaModal({
+  open,
+  onClose,
+  showLockedFunds,
+  defaultTab,
+  onDepositSuccess
+}) {
+  const [isTransactionPending, setIsTransactionPending] = react.useState(false);
+  const titleId = react.useId();
+  const descId = react.useId();
+  const handleOpenChange = (isOpen) => {
+    if (!isOpen && isTransactionPending) {
+      return;
+    }
+    if (!isOpen) {
+      onClose();
+    }
+  };
+  return /* @__PURE__ */ jsxRuntime.jsx(Dialog, { open, onOpenChange: handleOpenChange, children: /* @__PURE__ */ jsxRuntime.jsxs(
+    DialogContent,
+    {
+      "data-privana": true,
+      showCloseButton: false,
+      className: "bg-card flex w-[560px] max-w-[95vw] flex-col gap-2 overflow-hidden rounded-2xl border-0 p-2",
+      overlayClassName: isTransactionPending ? "cursor-not-allowed" : void 0,
+      "aria-labelledby": titleId,
+      "aria-describedby": descId,
+      children: [
+        /* @__PURE__ */ jsxRuntime.jsxs(DialogHeader, { children: [
+          /* @__PURE__ */ jsxRuntime.jsx(DialogTitle, { id: titleId, className: "sr-only", children: "Privana" }),
+          /* @__PURE__ */ jsxRuntime.jsx(DialogDescription, { id: descId, className: "sr-only", children: "Deposit or withdraw tokens from your Flexvault" }),
+          /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex items-center justify-between px-5 py-4", children: [
+            /* @__PURE__ */ jsxRuntime.jsx("span", { className: "text-foreground text-xl leading-6 font-medium", children: "Privana" }),
+            onClose && /* @__PURE__ */ jsxRuntime.jsx(
+              "button",
+              {
+                onClick: onClose,
+                className: "text-muted-foreground hover:text-foreground flex h-6 w-6 cursor-pointer items-center justify-center transition-colors",
+                children: /* @__PURE__ */ jsxRuntime.jsx(CloseIcon, {})
+              }
+            )
+          ] })
+        ] }),
+        /* @__PURE__ */ jsxRuntime.jsx(
+          ModalBody,
+          {
+            onClose: isTransactionPending ? void 0 : onClose,
+            onTransactionPendingChange: setIsTransactionPending,
+            showLockedFunds,
+            defaultTab,
+            onDepositSuccess
+          }
+        )
+      ]
+    }
+  ) });
+}
+function PrivanaInlineModal({
+  className,
+  showLockedFunds,
+  defaultTab,
+  onDepositSuccess
+}) {
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    "div",
+    {
+      "data-privana": true,
+      className: cn(
+        "bg-card flex w-[560px] max-w-full flex-col gap-2 overflow-hidden rounded-2xl p-2 shadow-lg",
+        className
+      ),
+      children: /* @__PURE__ */ jsxRuntime.jsx(
+        ModalBody,
+        {
+          showLockedFunds,
+          defaultTab,
+          onDepositSuccess
+        }
+      )
+    }
+  );
+}
+function PrivanaButton({
+  children,
+  className,
+  variant = "outline",
+  size = "default",
+  asChild = false,
+  renderButton,
+  hideWhenDisconnected = true,
+  showLockedFunds = true,
+  defaultTab,
+  onDepositSuccess,
+  ...buttonProps
+}) {
+  const [modalOpen, setModalOpen] = react.useState(false);
+  const { isConnected } = wagmi.useAccount();
+  if (hideWhenDisconnected && !isConnected) {
+    return null;
+  }
+  const handleClick = () => setModalOpen(true);
+  const buttonElement = renderButton ? renderButton({ onClick: handleClick, isOpen: modalOpen }) : /* @__PURE__ */ jsxRuntime.jsx(
+    Button,
+    {
+      variant,
+      size,
+      asChild,
+      className: cn(className),
+      onClick: handleClick,
+      disabled: !isConnected,
+      ...buttonProps,
+      children: children ?? "Privana"
+    }
+  );
+  return /* @__PURE__ */ jsxRuntime.jsxs("span", { "data-privana": true, className: "contents", children: [
+    buttonElement,
+    /* @__PURE__ */ jsxRuntime.jsx(
+      PrivanaModal,
+      {
+        open: modalOpen,
+        onClose: () => setModalOpen(false),
+        showLockedFunds,
+        defaultTab,
+        onDepositSuccess
+      }
+    )
+  ] });
+}
+function Skeleton({ className, ...props }) {
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    "div",
+    {
+      "data-slot": "skeleton",
+      className: cn("bg-accent animate-pulse rounded-md", className),
+      ...props
+    }
+  );
+}
+
+exports.AccountingApiError = AccountingApiError;
+exports.Button = Button;
+exports.HOSTED_AUTH_CLOCK_SKEW_MS = HOSTED_AUTH_CLOCK_SKEW_MS;
+exports.HostedAuthError = HostedAuthError;
+exports.HostedAuthRequiredError = HostedAuthRequiredError;
+exports.HostedAuthStateMismatchError = HostedAuthStateMismatchError;
+exports.HttpClient = HttpClient;
+exports.LOCK_TYPES = LOCK_TYPES;
+exports.MODIFY_LOCK_TYPES = MODIFY_LOCK_TYPES;
+exports.NETWORK_CONFIG = NETWORK_CONFIG;
+exports.NetworkError = NetworkError;
+exports.PrivanaButton = PrivanaButton;
+exports.PrivanaClient = PrivanaClient;
+exports.PrivanaInlineModal = PrivanaInlineModal;
+exports.PrivanaModal = PrivanaModal;
+exports.PrivanaProvider = PrivanaProvider;
+exports.SUPPORTED_CHAINS = SUPPORTED_CHAINS;
+exports.Skeleton = Skeleton;
+exports.TRANSFER_LOCKED_TYPES = TRANSFER_LOCKED_TYPES;
+exports.TRANSFER_TYPES = TRANSFER_TYPES;
+exports.ValidationError = ValidationError;
+exports.WITHDRAW_FROM_LOCK_TYPES = WITHDRAW_FROM_LOCK_TYPES;
+exports.WITHDRAW_TYPES = WITHDRAW_TYPES;
+exports.applyRefreshResponse = applyRefreshResponse;
+exports.buildHostedAuthSession = buildHostedAuthSession;
+exports.buttonVariants = buttonVariants;
+exports.clearHostedAuthPendingTransaction = clearHostedAuthPendingTransaction;
+exports.createDomain = createDomain;
+exports.createHostedAuthPendingStorageKey = createHostedAuthPendingStorageKey;
+exports.createHostedAuthState = createHostedAuthState;
+exports.createHostedAuthStorageKey = createHostedAuthStorageKey;
+exports.createLockExpiry = createLockExpiry;
+exports.createPkceChallenge = createPkceChallenge;
+exports.createPkceVerifier = createPkceVerifier;
+exports.getAccountingContract = getAccountingContract;
+exports.getApiUrl = getApiUrl;
+exports.getChainById = getChainById;
+exports.getChainIcon = getChainIcon;
+exports.getChainId = getChainId;
+exports.getExplorerAddressUrl = getExplorerAddressUrl;
+exports.getTokenIcon = getTokenIcon;
+exports.isHostedAuthRefreshActive = isHostedAuthRefreshActive;
+exports.isHostedAuthSessionActive = isHostedAuthSessionActive;
+exports.normalizeAddress = normalizeAddress;
+exports.normalizeHex = normalizeHex;
+exports.parseHostedAuthCallback = parseHostedAuthCallback;
+exports.persistHostedAuthPendingTransaction = persistHostedAuthPendingTransaction;
+exports.readHostedAuthPendingTransaction = readHostedAuthPendingTransaction;
+exports.readStoredHostedAuthSession = readStoredHostedAuthSession;
+exports.signLockMessage = signLockMessage;
+exports.signModifyLockMessage = signModifyLockMessage;
+exports.signTransferLockedMessage = signTransferLockedMessage;
+exports.signTransferMessage = signTransferMessage;
+exports.signWithdrawFromLockMessage = signWithdrawFromLockMessage;
+exports.signWithdrawMessage = signWithdrawMessage;
+exports.stripHostedAuthCallbackParams = stripHostedAuthCallbackParams;
+exports.syncHostedAuthSessionToClient = syncHostedAuthSessionToClient;
+exports.useBalance = useBalance;
+exports.useBatchBalances = useBatchBalances;
+exports.useDeposit = useDeposit;
+exports.useExpiredLocks = useExpiredLocks;
+exports.useHistory = useHistory;
+exports.useHostedRedirectAuth = useHostedRedirectAuth;
+exports.useLockFunds = useLockFunds;
+exports.useLockedFunds = useLockedFunds;
+exports.useModifyLock = useModifyLock;
+exports.usePendingWithdrawals = usePendingWithdrawals;
+exports.usePrivanaClient = usePrivanaClient;
+exports.usePrivanaContext = usePrivanaContext;
+exports.useSafeAccount = useSafeAccount;
+exports.useSafePrivanaContext = useSafePrivanaContext;
+exports.useTokenInfo = useTokenInfo;
+exports.useTokenList = useTokenList;
+exports.useTotalLockedBalance = useTotalLockedBalance;
+exports.useTransfer = useTransfer;
+exports.useUnlockFunds = useUnlockFunds;
+exports.useWithdraw = useWithdraw;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map