@oasisprotocol/privana-sdk 0.2.1 → 0.4.0

package/dist/index.cjs

@@ -1,20 +1,14 @@
 "use client";
 'use strict';
 
+var chunkRDMJGMI3_cjs = require('./chunk-RDMJGMI3.cjs');
 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 viem = require('viem');
 var DialogPrimitive = require('@radix-ui/react-dialog');
 var lucideReact = require('lucide-react');
+var jsxRuntime = require('react/jsx-runtime');
 var sonner = require('sonner');
 
 function _interopNamespace(e) {
@@ -37,565 +31,6 @@ function _interopNamespace(e) {
 
 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://testnet.privana.finance"
-    },
-    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 {
@@ -791,309 +226,21 @@ async function signWithdrawFromLockMessage({
   });
   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();
+  const { client } = chunkRDMJGMI3_cjs.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 chunkRDMJGMI3_cjs.AccountingApiError && error.detail) {
+    return new chunkRDMJGMI3_cjs.HostedAuthError(error.detail);
   }
   if (error instanceof Error) {
     return error;
   }
-  return new HostedAuthError("Hosted authentication failed.");
+  return new chunkRDMJGMI3_cjs.HostedAuthError("Hosted authentication failed.");
 }
 function useHostedRedirectAuth() {
   const {
@@ -1104,30 +251,30 @@ function useHostedRedirectAuth() {
     setHostedAuthSession,
     clearHostedAuthSession,
     refreshHostedAuthSession
-  } = usePrivanaContext();
+  } = chunkRDMJGMI3_cjs.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,
+    () => hostedAuthConfig ? chunkRDMJGMI3_cjs.createHostedAuthPendingStorageKey(client.getBaseUrl(), hostedAuthConfig) : null,
     [client, hostedAuthConfig]
   );
   const clearPendingLogin = react.useCallback(() => {
     if (!pendingStorageKey || typeof window === "undefined") return;
-    clearHostedAuthPendingTransaction(window.sessionStorage, pendingStorageKey);
+    chunkRDMJGMI3_cjs.clearHostedAuthPendingTransaction(window.sessionStorage, pendingStorageKey);
   }, [pendingStorageKey]);
   const login = react.useCallback(async () => {
     if (!hostedAuthConfig) {
-      throw new HostedAuthRequiredError(
+      throw new chunkRDMJGMI3_cjs.HostedAuthRequiredError(
         "Hosted redirect authentication is not configured for this provider."
       );
     }
     if (typeof window === "undefined") {
-      throw new HostedAuthError("Hosted redirect authentication requires a browser environment.");
+      throw new chunkRDMJGMI3_cjs.HostedAuthError("Hosted redirect authentication requires a browser environment.");
     }
     if (!pendingStorageKey) {
-      throw new HostedAuthError("Hosted redirect authentication storage is not configured.");
+      throw new chunkRDMJGMI3_cjs.HostedAuthError("Hosted redirect authentication storage is not configured.");
     }
     if (loginInflight.current) {
       return loginInflight.current;
@@ -1136,10 +283,10 @@ function useHostedRedirectAuth() {
       setIsLoading(true);
       setError(null);
       try {
-        const verifier = createPkceVerifier();
-        const codeChallenge = await createPkceChallenge(verifier);
-        const state = createHostedAuthState();
-        persistHostedAuthPendingTransaction(window.sessionStorage, pendingStorageKey, {
+        const verifier = chunkRDMJGMI3_cjs.createPkceVerifier();
+        const codeChallenge = await chunkRDMJGMI3_cjs.createPkceChallenge(verifier);
+        const state = chunkRDMJGMI3_cjs.createHostedAuthState();
+        chunkRDMJGMI3_cjs.persistHostedAuthPendingTransaction(window.sessionStorage, pendingStorageKey, {
           codeVerifier: verifier,
           state
         });
@@ -1168,15 +315,15 @@ function useHostedRedirectAuth() {
   }, [clearPendingLogin, client, hostedAuthConfig, networkConfig.chainId, pendingStorageKey]);
   const completeLogin = react.useCallback(async () => {
     if (!hostedAuthConfig) {
-      throw new HostedAuthRequiredError(
+      throw new chunkRDMJGMI3_cjs.HostedAuthRequiredError(
         "Hosted redirect authentication is not configured for this provider."
       );
     }
     if (typeof window === "undefined") {
-      throw new HostedAuthError("Hosted redirect authentication requires a browser environment.");
+      throw new chunkRDMJGMI3_cjs.HostedAuthError("Hosted redirect authentication requires a browser environment.");
     }
     if (!pendingStorageKey) {
-      throw new HostedAuthError("Hosted redirect authentication storage is not configured.");
+      throw new chunkRDMJGMI3_cjs.HostedAuthError("Hosted redirect authentication storage is not configured.");
     }
     if (completionInflight.current) {
       return completionInflight.current;
@@ -1186,30 +333,30 @@ function useHostedRedirectAuth() {
       setError(null);
       const callbackUrl = new URL(window.location.href);
       const cleanupCallbackUrl = () => {
-        window.history.replaceState(null, "", stripHostedAuthCallbackParams(callbackUrl));
+        window.history.replaceState(null, "", chunkRDMJGMI3_cjs.stripHostedAuthCallbackParams(callbackUrl));
       };
       try {
-        const callback = parseHostedAuthCallback(callbackUrl, hostedAuthConfig.redirectUri);
+        const callback = chunkRDMJGMI3_cjs.parseHostedAuthCallback(callbackUrl, hostedAuthConfig.redirectUri);
         if (!callback) {
           return null;
         }
-        const pending = readHostedAuthPendingTransaction(window.sessionStorage, pendingStorageKey);
+        const pending = chunkRDMJGMI3_cjs.readHostedAuthPendingTransaction(window.sessionStorage, pendingStorageKey);
         if (!pending) {
           clearPendingLogin();
           cleanupCallbackUrl();
-          throw new HostedAuthError(
+          throw new chunkRDMJGMI3_cjs.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();
+          throw new chunkRDMJGMI3_cjs.HostedAuthStateMismatchError();
         }
         if ("error" in callback) {
           clearPendingLogin();
           cleanupCallbackUrl();
-          throw new HostedAuthError(
+          throw new chunkRDMJGMI3_cjs.HostedAuthError(
             callback.errorDescription || callback.error || "Hosted authentication failed."
           );
         }
@@ -1224,7 +371,7 @@ function useHostedRedirectAuth() {
               client_id: hostedAuthConfig.clientId,
               redirect_uri: hostedAuthConfig.redirectUri
             });
-            const session = buildHostedAuthSession(response, hostedAuthConfig);
+            const session = chunkRDMJGMI3_cjs.buildHostedAuthSession(response, hostedAuthConfig);
             setHostedAuthSession(session);
             clearPendingLogin();
             cleanupCallbackUrl();
@@ -1269,7 +416,7 @@ function useHostedRedirectAuth() {
     try {
       return await refreshHostedAuthSession();
     } catch (refreshError) {
-      const normalizedError = refreshError instanceof Error ? refreshError : new HostedAuthError("Hosted authentication refresh failed.");
+      const normalizedError = refreshError instanceof Error ? refreshError : new chunkRDMJGMI3_cjs.HostedAuthError("Hosted authentication refresh failed.");
       setError(normalizedError);
       throw normalizedError;
     } finally {
@@ -1287,288 +434,14 @@ function useHostedRedirectAuth() {
     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 accountingContext = chunkRDMJGMI3_cjs.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 { executePrivateRead, privateReadAddress, privateReadQueryScope, privateReadReady } = chunkRDMJGMI3_cjs.usePrivateReadRequest();
   const tokenId = options.tokenId ?? defaultToken?.id;
   const query = reactQuery.useQuery({
     queryKey: ["accounting-balance", ...privateReadQueryScope, tokenId],
@@ -1585,7 +458,7 @@ function useBalance(options = {}) {
   return {
     balance: balanceWei,
     balanceWei,
-    balanceFormatted: formatTokenAmount(balanceWei),
+    balanceFormatted: chunkRDMJGMI3_cjs.formatTokenAmount(balanceWei),
     tokenSymbol: query.data?.token_symbol ?? "",
     chainId: query.data?.chain_id ?? "",
     isLoading: query.isPending || query.isLoading,
@@ -1595,8 +468,8 @@ function useBalance(options = {}) {
   };
 }
 function useBatchBalances(options) {
-  const { client, pollingInterval } = usePrivanaContext();
-  const { executePrivateRead, privateReadAddress, privateReadQueryScope, privateReadReady } = usePrivateReadRequest();
+  const { client, pollingInterval } = chunkRDMJGMI3_cjs.usePrivanaContext();
+  const { executePrivateRead, privateReadAddress, privateReadQueryScope, privateReadReady } = chunkRDMJGMI3_cjs.usePrivateReadRequest();
   const query = reactQuery.useQuery({
     queryKey: ["accounting-batch-balances", ...privateReadQueryScope, options.tokenIds],
     queryFn: async () => {
@@ -1614,55 +487,6 @@ function useBatchBalances(options) {
     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 getTransactionReceipt(config, parameters) {
-  const { chainId, ...rest } = parameters;
-  const client = config.getClient({ chainId });
-  const action = getAction(client, actions$1.getTransactionReceipt, "getTransactionReceipt");
-  return action(rest);
-}
-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();
@@ -1671,7 +495,7 @@ function useEnsureCorrectChain() {
     async (expectedChainId, timeoutMs, pollIntervalMs = 250) => {
       const startedAt = Date.now();
       while (Date.now() - startedAt < timeoutMs) {
-        const currentChainId = getChainId2(config);
+        const currentChainId = chunkRDMJGMI3_cjs.getChainId2(config);
         if (currentChainId === expectedChainId) return true;
         await new Promise((resolve) => setTimeout(resolve, pollIntervalMs));
       }
@@ -1681,7 +505,7 @@ function useEnsureCorrectChain() {
   );
   const ensureCorrectChain = react.useCallback(
     async (targetChainId) => {
-      const currentChainId = getChainId2(config);
+      const currentChainId = chunkRDMJGMI3_cjs.getChainId2(config);
       if (currentChainId === targetChainId) return false;
       let switchErrorMessage;
       try {
@@ -1748,24 +572,19 @@ function clearPendingDeposit(address) {
 }
 function useDeposit(options = {}) {
   const { address } = wagmi.useAccount();
-  const { client, enabledTokens, getChainById: getChainById2 } = usePrivanaContext();
+  const { client, enabledTokens, getChainById: getChainById2 } = chunkRDMJGMI3_cjs.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 { executePrivateRead } = chunkRDMJGMI3_cjs.usePrivateReadRequest();
   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 [receiptFailed, setReceiptFailed] = 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);
@@ -1785,6 +604,28 @@ function useDeposit(options = {}) {
     options.onCheckTimeout,
     options.onError
   ]);
+  const {
+    isVerifying,
+    didTimeout,
+    verificationFailed: innerVerificationFailed,
+    error: verificationError,
+    verify,
+    reset: resetVerification
+  } = chunkRDMJGMI3_cjs.useDepositVerification({
+    pollInterval: options.pollInterval,
+    pollTimeout: options.pollTimeout,
+    onCredited: (hash, response) => {
+      verificationContextRef.current = null;
+      if (address) clearPendingDeposit(address);
+      onCreditedRef.current?.(hash, response);
+    },
+    onCheckTimeout: (hash) => {
+      onCheckTimeoutRef.current?.(hash);
+    },
+    onError: (err) => {
+      onErrorRef.current?.(err);
+    }
+  });
   const addressMutation = reactQuery.useMutation({
     mutationFn: async () => {
       if (!address) throw new Error("No wallet connected");
@@ -1819,149 +660,24 @@ function useDeposit(options = {}) {
   react.useEffect(() => {
     return () => {
       invalidateGeneration();
-      if (pollIntervalRef.current) {
-        clearTimeout(pollIntervalRef.current);
-        pollIntervalRef.current = null;
-      }
     };
   }, [invalidateGeneration]);
   const resumedAddressRef = react.useRef(void 0);
-  const stopPolling = react.useCallback(() => {
-    if (pollIntervalRef.current) {
-      clearTimeout(pollIntervalRef.current);
-      pollIntervalRef.current = null;
-    }
-  }, []);
   const reset = react.useCallback(() => {
     generationRef.current++;
-    stopPolling();
+    resetVerification();
     if (address) clearPendingDeposit(address);
     verificationContextRef.current = null;
     setDepositAddress(null);
     setTxHash(void 0);
     setIsSwitchingChain(false);
     setIsWaitingForConfirmation(false);
-    setIsWaitingForProcessing(false);
-    setDidTimeout(false);
-    setVerificationFailed(false);
+    setReceiptFailed(false);
     setDepositError(null);
     addressMutation.reset();
     resetWriteContract();
     resetSendTransaction();
-  }, [address, 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;
-          if (address) clearPendingDeposit(address);
-          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;
-              if (address) clearPendingDeposit(address);
-              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")
-        );
-      }
-    },
-    [address, 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]);
+  }, [address, addressMutation, resetWriteContract, resetSendTransaction, resetVerification]);
   react.useEffect(() => {
     if (!address || resumedAddressRef.current === address) return;
     const persisted = loadPendingDeposit(address);
@@ -1983,12 +699,12 @@ function useDeposit(options = {}) {
       try {
         let confirmed = false;
         try {
-          await getTransactionReceipt(config, { hash, chainId: persisted.chainId });
+          await chunkRDMJGMI3_cjs.getTransactionReceipt(config, { hash, chainId: persisted.chainId });
           confirmed = true;
         } catch {
         }
         if (!confirmed) {
-          await waitForTransactionReceipt(config, {
+          await chunkRDMJGMI3_cjs.waitForTransactionReceipt(config, {
             hash,
             chainId: persisted.chainId,
             confirmations
@@ -1998,19 +714,17 @@ function useDeposit(options = {}) {
         setIsWaitingForConfirmation(false);
         onDepositSuccessRef.current?.(hash);
         queryClient.invalidateQueries({ queryKey: ["readContract"] });
-        await runVerification(ctx, generation);
+        await verify(ctx);
       } 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);
+        setReceiptFailed(true);
         onErrorRef.current?.(error2);
       }
     })();
-  }, [address, config, confirmations, queryClient, runVerification, stopPolling]);
+  }, [address, config, confirmations, queryClient, verify]);
   const deposit = react.useCallback(
     async (params) => {
       if (verificationContextRef.current) {
@@ -2077,7 +791,7 @@ function useDeposit(options = {}) {
         try {
           setIsWaitingForConfirmation(true);
           try {
-            await waitForTransactionReceipt(config, {
+            await chunkRDMJGMI3_cjs.waitForTransactionReceipt(config, {
               hash,
               chainId: sourceChain.id,
               confirmations
@@ -2088,15 +802,13 @@ function useDeposit(options = {}) {
           if (isStale()) return;
           onDepositSuccessRef.current?.(hash);
           queryClient.invalidateQueries({ queryKey: ["readContract"] });
-          await runVerification(ctx, generation);
+          await verify(ctx);
         } 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);
+          setReceiptFailed(true);
           onErrorRef.current?.(error2);
         }
       } catch (err) {
@@ -2118,13 +830,21 @@ function useDeposit(options = {}) {
       queryClient,
       writeContractAsync,
       sendTransactionAsync,
-      stopPolling,
       reset,
-      runVerification
+      verify
     ]
   );
-  const isPending = addressMutation.isPending || isSwitchingChain || isSendingTx || isWaitingForConfirmation || isWaitingForProcessing;
-  const error = addressMutation.error || sendError || depositError;
+  const retryVerification = react.useCallback(async () => {
+    const ctx = verificationContextRef.current;
+    if (!ctx) {
+      throw new Error("No pending deposit to verify");
+    }
+    setReceiptFailed(false);
+    setDepositError(null);
+    await verify(ctx);
+  }, [verify]);
+  const isPending = addressMutation.isPending || isSwitchingChain || isSendingTx || isWaitingForConfirmation || isVerifying;
+  const error = addressMutation.error || sendError || depositError || verificationError;
   return {
     depositAddress,
     txHash,
@@ -2132,9 +852,9 @@ function useDeposit(options = {}) {
     isSwitchingChain,
     isSendingTransaction: isSendingTx,
     isWaitingForConfirmation,
-    isWaitingForProcessing,
+    isWaitingForProcessing: isVerifying,
     didTimeout,
-    verificationFailed,
+    verificationFailed: innerVerificationFailed || receiptFailed,
     isPending,
     error,
     deposit,
@@ -2145,7 +865,7 @@ function useDeposit(options = {}) {
 function useWithdraw(options = {}) {
   const { address } = wagmi.useAccount();
   const { data: walletClient } = wagmi.useWalletClient();
-  const { client, networkConfig } = usePrivanaContext();
+  const { client, networkConfig } = chunkRDMJGMI3_cjs.usePrivanaContext();
   const queryClient = reactQuery.useQueryClient();
   const { chainId, ensureCorrectChain } = useEnsureCorrectChain();
   const pollInterval = options.pollInterval ?? 3e3;
@@ -2344,7 +1064,7 @@ function useWithdraw(options = {}) {
 function useLockFunds(options = {}) {
   const { address } = wagmi.useAccount();
   const { data: walletClient } = wagmi.useWalletClient();
-  const { client, networkConfig, serviceAddress } = usePrivanaContext();
+  const { client, networkConfig, serviceAddress } = chunkRDMJGMI3_cjs.usePrivanaContext();
   const queryClient = reactQuery.useQueryClient();
   const mutation = reactQuery.useMutation({
     mutationFn: async (params) => {
@@ -2403,7 +1123,7 @@ function useLockFunds(options = {}) {
 }
 function useUnlockFunds(options = {}) {
   const { address } = wagmi.useAccount();
-  const { client } = usePrivanaContext();
+  const { client } = chunkRDMJGMI3_cjs.usePrivanaContext();
   const queryClient = reactQuery.useQueryClient();
   const unlockMutation = reactQuery.useMutation({
     mutationFn: async (params) => {
@@ -2471,7 +1191,7 @@ function useUnlockFunds(options = {}) {
 function useTransfer(options = {}) {
   const { address } = wagmi.useAccount();
   const { data: walletClient } = wagmi.useWalletClient();
-  const { client, networkConfig, serviceAddress } = usePrivanaContext();
+  const { client, networkConfig, serviceAddress } = chunkRDMJGMI3_cjs.usePrivanaContext();
   const queryClient = reactQuery.useQueryClient();
   const transferMutation = reactQuery.useMutation({
     mutationFn: async (params) => {
@@ -2576,8 +1296,8 @@ function useTransfer(options = {}) {
   };
 }
 function useLockedFunds(options = {}) {
-  const { client, pollingInterval, serviceAddress } = usePrivanaContext();
-  const { executePrivateRead, privateReadAddress, privateReadQueryScope, privateReadReady } = usePrivateReadRequest();
+  const { client, pollingInterval, serviceAddress } = chunkRDMJGMI3_cjs.usePrivanaContext();
+  const { executePrivateRead, privateReadAddress, privateReadQueryScope, privateReadReady } = chunkRDMJGMI3_cjs.usePrivateReadRequest();
   const query = reactQuery.useQuery({
     queryKey: ["accounting-locked-funds", ...privateReadQueryScope, serviceAddress ?? null],
     queryFn: async () => {
@@ -2599,8 +1319,8 @@ function useLockedFunds(options = {}) {
   };
 }
 function useTotalLockedBalance(options = {}) {
-  const { client, pollingInterval, defaultToken } = usePrivanaContext();
-  const { executePrivateRead, privateReadAddress, privateReadQueryScope, privateReadReady } = usePrivateReadRequest();
+  const { client, pollingInterval, defaultToken } = chunkRDMJGMI3_cjs.usePrivanaContext();
+  const { executePrivateRead, privateReadAddress, privateReadQueryScope, privateReadReady } = chunkRDMJGMI3_cjs.usePrivateReadRequest();
   const tokenId = options.tokenId ?? defaultToken?.id;
   const query = reactQuery.useQuery({
     queryKey: ["accounting-total-locked-balance", ...privateReadQueryScope, tokenId],
@@ -2621,8 +1341,8 @@ function useTotalLockedBalance(options = {}) {
   };
 }
 function useExpiredLocks(options = {}) {
-  const { client, pollingInterval } = usePrivanaContext();
-  const { executePrivateRead, privateReadAddress, privateReadQueryScope, privateReadReady } = usePrivateReadRequest();
+  const { client, pollingInterval } = chunkRDMJGMI3_cjs.usePrivanaContext();
+  const { executePrivateRead, privateReadAddress, privateReadQueryScope, privateReadReady } = chunkRDMJGMI3_cjs.usePrivateReadRequest();
   const query = reactQuery.useQuery({
     queryKey: ["accounting-expired-locks", ...privateReadQueryScope],
     queryFn: async () => {
@@ -2644,7 +1364,7 @@ function useExpiredLocks(options = {}) {
 }
 function usePendingWithdrawals(options = {}) {
   const { address, isConnected } = wagmi.useAccount();
-  const { client, pollingInterval } = usePrivanaContext();
+  const { client, pollingInterval } = chunkRDMJGMI3_cjs.usePrivanaContext();
   const query = reactQuery.useQuery({
     queryKey: ["accounting-pending-withdrawals", address],
     queryFn: async () => {
@@ -2680,8 +1400,8 @@ function usePendingWithdrawals(options = {}) {
   };
 }
 function useHistory(options = {}) {
-  const { client, pollingInterval } = usePrivanaContext();
-  const { executePrivateRead, privateReadAddress, privateReadQueryScope, privateReadReady } = usePrivateReadRequest();
+  const { client, pollingInterval } = chunkRDMJGMI3_cjs.usePrivanaContext();
+  const { executePrivateRead, privateReadAddress, privateReadQueryScope, privateReadReady } = chunkRDMJGMI3_cjs.usePrivateReadRequest();
   const offset = options.offset ?? -1;
   const limit = options.limit ?? 50;
   const query = reactQuery.useQuery({
@@ -2705,7 +1425,7 @@ function useHistory(options = {}) {
   };
 }
 function useTokenInfo(options = {}) {
-  const { client } = usePrivanaContext();
+  const { client } = chunkRDMJGMI3_cjs.usePrivanaContext();
   const { tokenId } = options;
   const query = reactQuery.useQuery({
     queryKey: ["accounting-token-info", tokenId],
@@ -2725,7 +1445,7 @@ function useTokenInfo(options = {}) {
   };
 }
 function useTokenList(options = {}) {
-  const { client } = usePrivanaContext();
+  const { client } = chunkRDMJGMI3_cjs.usePrivanaContext();
   const query = reactQuery.useQuery({
     queryKey: ["accounting-token-list"],
     queryFn: () => client.listTokens(),
@@ -2743,7 +1463,7 @@ function useTokenList(options = {}) {
 function useModifyLock(options = {}) {
   const { address } = wagmi.useAccount();
   const { data: walletClient } = wagmi.useWalletClient();
-  const { client, networkConfig } = usePrivanaContext();
+  const { client, networkConfig } = chunkRDMJGMI3_cjs.usePrivanaContext();
   const queryClient = reactQuery.useQueryClient();
   const mutation = reactQuery.useMutation({
     mutationFn: async (params) => {
@@ -2794,52 +1514,6 @@ function useModifyLock(options = {}) {
     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 });
 }
@@ -2855,7 +1529,7 @@ function DialogOverlay({
     {
       "data-slot": "dialog-overlay",
       "data-privana": true,
-      className: cn(
+      className: chunkRDMJGMI3_cjs.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
       ),
@@ -2877,7 +1551,7 @@ function DialogContent({
       {
         "data-slot": "dialog-content",
         "data-privana": true,
-        className: cn(
+        className: chunkRDMJGMI3_cjs.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
         ),
@@ -2905,7 +1579,7 @@ function DialogHeader({ className, ...props }) {
     "div",
     {
       "data-slot": "dialog-header",
-      className: cn("flex flex-col gap-2 text-center sm:text-left", className),
+      className: chunkRDMJGMI3_cjs.cn("flex flex-col gap-2 text-center sm:text-left", className),
       ...props
     }
   );
@@ -2915,7 +1589,7 @@ function DialogTitle({ className, ...props }) {
     DialogPrimitive__namespace.Title,
     {
       "data-slot": "dialog-title",
-      className: cn("text-lg leading-none font-semibold", className),
+      className: chunkRDMJGMI3_cjs.cn("text-lg leading-none font-semibold", className),
       ...props
     }
   );
@@ -2928,7 +1602,7 @@ function DialogDescription({
     DialogPrimitive__namespace.Description,
     {
       "data-slot": "dialog-description",
-      className: cn("text-muted-foreground text-sm", className),
+      className: chunkRDMJGMI3_cjs.cn("text-muted-foreground text-sm", className),
       ...props
     }
   );
@@ -3283,7 +1957,7 @@ function DepositForm({
   onSuccess
 }) {
   const { isConnected, address } = wagmi.useAccount();
-  const { chains, getChainById: getChainById2 } = usePrivanaContext();
+  const { chains, getChainById: getChainById2 } = chunkRDMJGMI3_cjs.usePrivanaContext();
   const [amount, setAmount] = react.useState("");
   const [showSuccess, setShowSuccess] = react.useState(false);
   const [showTimeout, setShowTimeout] = react.useState(false);
@@ -3308,7 +1982,7 @@ function DepositForm({
     }
   });
   const walletBalance = isNative ? nativeBalanceData?.value : erc20Balance;
-  const formattedWalletBalance = walletBalance ? formatTokenAmount(walletBalance.toString(), selectedToken.decimals) : "0.00";
+  const formattedWalletBalance = walletBalance ? chunkRDMJGMI3_cjs.formatTokenAmount(walletBalance.toString(), selectedToken.decimals) : "0.00";
   const handleMaxClick = () => {
     if (formattedWalletBalance && parseFloat(formattedWalletBalance) > 0) {
       setAmount(formattedWalletBalance.replace(/[\s\u2009]/g, ""));
@@ -3316,7 +1990,7 @@ function DepositForm({
   };
   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 exceedsBalance = hasValidAmount && !tooManyDecimals && walletBalance != null && chunkRDMJGMI3_cjs.parseTokenAmount(amount, selectedToken.decimals) > walletBalance;
   const {
     txHash,
     isGettingAddress,
@@ -3401,7 +2075,7 @@ function DepositForm({
   const handleSubmit = async () => {
     if (!amount || !selectedToken || exceedsBalance) return;
     setCancelled(false);
-    const amountInWei = parseTokenAmount(amount, selectedToken.decimals);
+    const amountInWei = chunkRDMJGMI3_cjs.parseTokenAmount(amount, selectedToken.decimals);
     await deposit({
       tokenId: selectedToken.id,
       amount: amountInWei
@@ -3504,7 +2178,7 @@ function DepositForm({
                 setAmount(value);
               }
             },
-            className: cn(
+            className: chunkRDMJGMI3_cjs.cn(
               "text-foreground flex-1 bg-transparent text-sm outline-none",
               "placeholder:text-muted-foreground/50"
             )
@@ -3531,7 +2205,7 @@ function DepositForm({
       {
         onClick: handleSubmit,
         disabled: !isConnected || !hasValidAmount || tooManyDecimals || !!exceedsBalance || isPending,
-        className: cn(
+        className: chunkRDMJGMI3_cjs.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"
@@ -3548,7 +2222,7 @@ function WithdrawForm({
   onUnsafeToCloseChange
 }) {
   const { isConnected, address } = wagmi.useAccount();
-  const { chains, getChainById: getChainById2 } = usePrivanaContext();
+  const { chains, getChainById: getChainById2 } = chunkRDMJGMI3_cjs.usePrivanaContext();
   const [amount, setAmount] = react.useState("");
   const [showSuccess, setShowSuccess] = react.useState(false);
   const [showTimeout, setShowTimeout] = react.useState(false);
@@ -3561,7 +2235,7 @@ function WithdrawForm({
   } = useBalance({
     tokenId: selectedToken.id
   });
-  const formattedBalance = formatTokenAmount(balanceWei, selectedToken.decimals);
+  const formattedBalance = chunkRDMJGMI3_cjs.formatTokenAmount(balanceWei, selectedToken.decimals);
   const { withdraw, isPending, currentStep, error, reset } = useWithdraw({
     onProcessingSuccess: () => {
       setAmount("");
@@ -3572,7 +2246,7 @@ function WithdrawForm({
       setShowTimeout(true);
     }
   });
-  const explorerUrl = address && targetChain ? getExplorerAddressUrl(targetChain.id, address) : void 0;
+  const explorerUrl = address && targetChain ? chunkRDMJGMI3_cjs.getExplorerAddressUrl(targetChain.id, address) : void 0;
   const getStepStatus = (step, after) => {
     if (currentStep === step) return "active";
     if (after.includes(currentStep)) return "completed";
@@ -3616,7 +2290,7 @@ function WithdrawForm({
   const handleWithdraw = async () => {
     if (!amount || !selectedToken || exceedsBalance) return;
     setCancelled(false);
-    const amountInWei = parseTokenAmount(amount, selectedToken.decimals);
+    const amountInWei = chunkRDMJGMI3_cjs.parseTokenAmount(amount, selectedToken.decimals);
     await withdraw({
       tokenId: selectedToken.id,
       amount: amountInWei
@@ -3629,7 +2303,7 @@ function WithdrawForm({
   };
   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 exceedsBalance = hasValidAmount && !tooManyDecimals && !isBalanceLoading && !isBalanceError && chunkRDMJGMI3_cjs.parseTokenAmount(amount, selectedToken.decimals) > BigInt(balanceWei);
   const getButtonText = () => {
     if (!isConnected) return "Connect Wallet";
     return "Withdraw";
@@ -3712,7 +2386,7 @@ function WithdrawForm({
                 setAmount(value);
               }
             },
-            className: cn(
+            className: chunkRDMJGMI3_cjs.cn(
               "text-foreground flex-1 bg-transparent text-sm outline-none",
               "placeholder:text-muted-foreground/50"
             )
@@ -3739,7 +2413,7 @@ function WithdrawForm({
       {
         onClick: handleWithdraw,
         disabled: !isConnected || !hasValidAmount || tooManyDecimals || !!exceedsBalance || isPending,
-        className: cn(
+        className: chunkRDMJGMI3_cjs.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"
@@ -3794,7 +2468,7 @@ function ChevronDown({ collapsed }) {
       width: "12",
       height: "6",
       viewBox: "0 0 12 6",
-      className: cn("transition-transform", collapsed && "-rotate-90"),
+      className: chunkRDMJGMI3_cjs.cn("transition-transform", collapsed && "-rotate-90"),
       children: /* @__PURE__ */ jsxRuntime.jsx(
         "path",
         {
@@ -3820,15 +2494,15 @@ function BalanceCards({
     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.00";
-  return /* @__PURE__ */ jsxRuntime.jsxs("div", { className: cn("flex gap-2", disabled && "opacity-50"), children: [
+  const formattedBalance = chunkRDMJGMI3_cjs.formatTokenAmount(balanceWei, selectedToken.decimals);
+  const formattedLocked = showLockedFunds ? chunkRDMJGMI3_cjs.formatTokenAmount(String(totalLocked), selectedToken.decimals) : "0.00";
+  return /* @__PURE__ */ jsxRuntime.jsxs("div", { className: chunkRDMJGMI3_cjs.cn("flex gap-2", disabled && "opacity-50"), children: [
     /* @__PURE__ */ jsxRuntime.jsxs(
       "button",
       {
         onClick: onBalanceClick,
         disabled,
-        className: cn(
+        className: chunkRDMJGMI3_cjs.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"
         ),
@@ -3849,7 +2523,7 @@ function BalanceCards({
       {
         onClick: onLockedFundsClick,
         disabled,
-        className: cn(
+        className: chunkRDMJGMI3_cjs.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"
         ),
@@ -3875,7 +2549,7 @@ function Tabs({
   return /* @__PURE__ */ jsxRuntime.jsxs(
     "div",
     {
-      className: cn(
+      className: chunkRDMJGMI3_cjs.cn(
         "bg-muted relative flex gap-2 overflow-hidden rounded-[10px] p-1",
         disabled && "opacity-50"
       ),
@@ -3883,7 +2557,7 @@ function Tabs({
         /* @__PURE__ */ jsxRuntime.jsx(
           "div",
           {
-            className: cn(
+            className: chunkRDMJGMI3_cjs.cn(
               "bg-input absolute top-1 bottom-1 left-1 w-[calc(50%-8px)] rounded-md transition-transform duration-200",
               activeTab === "withdraw" && "translate-x-[calc(100%+8px)]"
             )
@@ -3894,7 +2568,7 @@ function Tabs({
           {
             onClick: () => !disabled && onTabChange("deposit"),
             disabled,
-            className: cn(
+            className: chunkRDMJGMI3_cjs.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"
@@ -3907,7 +2581,7 @@ function Tabs({
           {
             onClick: () => !disabled && onTabChange("withdraw"),
             disabled,
-            className: cn(
+            className: chunkRDMJGMI3_cjs.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"
@@ -3920,14 +2594,14 @@ function Tabs({
   );
 }
 function LockedFundsView({ onBack }) {
-  const { getTokenById } = usePrivanaContext();
+  const { getTokenById } = chunkRDMJGMI3_cjs.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);
+      const serviceName = chunkRDMJGMI3_cjs.shortenAddress(lock.service_address);
       if (!sectionMap[lock.service_address]) {
         sectionMap[lock.service_address] = {
           title: `Service ${serviceName}`,
@@ -3936,9 +2610,9 @@ function LockedFundsView({ onBack }) {
       }
       sectionMap[lock.service_address].items.push({
         lockId: lock.lock_id,
-        amount: formatTokenAmount(String(lock.amount), getTokenById(lock.token_id)?.decimals ?? 18),
+        amount: chunkRDMJGMI3_cjs.formatTokenAmount(String(lock.amount), getTokenById(lock.token_id)?.decimals ?? 18),
         serviceAddress: lock.service_address,
-        time: lock.is_expired ? "Click to unlock" : formatTimeRemaining(lock.expiry),
+        time: lock.is_expired ? "Click to unlock" : chunkRDMJGMI3_cjs.formatTimeRemaining(lock.expiry),
         isExpired: lock.is_expired
       });
     });
@@ -3985,7 +2659,7 @@ function LockedFundsView({ onBack }) {
         !collapsedSections[section.title] && section.items.map((item) => /* @__PURE__ */ jsxRuntime.jsxs(
           "div",
           {
-            className: cn(
+            className: chunkRDMJGMI3_cjs.cn(
               "flex items-center justify-between gap-3 rounded-lg p-3",
               item.isExpired && "bg-secondary"
             ),
@@ -3999,7 +2673,7 @@ function LockedFundsView({ onBack }) {
                   ] }),
                   /* @__PURE__ */ jsxRuntime.jsxs("span", { className: "text-muted-foreground text-xs", children: [
                     "Service: ",
-                    shortenAddress(item.serviceAddress)
+                    chunkRDMJGMI3_cjs.shortenAddress(item.serviceAddress)
                   ] })
                 ] })
               ] }),
@@ -4040,7 +2714,7 @@ function BalanceTokenRow({ token }) {
   const { balanceWei, isLoading } = useBalance({
     tokenId: token.id
   });
-  const formattedBalance = formatTokenAmount(balanceWei, token.decimals);
+  const formattedBalance = chunkRDMJGMI3_cjs.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 }),
@@ -4048,7 +2722,7 @@ function BalanceTokenRow({ token }) {
   ] });
 }
 function BalanceDetailsView({ onBack }) {
-  const { enabledTokens, chains } = usePrivanaContext();
+  const { enabledTokens, chains } = chunkRDMJGMI3_cjs.usePrivanaContext();
   const [selectedChainId, setSelectedChainId] = react.useState(chains[0]?.id ?? 84532);
   const chainTokens = react.useMemo(() => {
     return enabledTokens.filter((t) => t.chainId === selectedChainId);
@@ -4074,7 +2748,7 @@ function BalanceDetailsView({ onBack }) {
             "button",
             {
               onClick: () => setSelectedChainId(chain.id),
-              className: cn(
+              className: chunkRDMJGMI3_cjs.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"
               ),
@@ -4115,12 +2789,12 @@ function TokenRow({
     query: { enabled: !!address && !isNative }
   });
   const walletBalance = isNative ? nativeBalanceData?.value : erc20Balance;
-  const formattedBalance = walletBalance ? formatTokenAmount(walletBalance.toString(), token.decimals) : "0.00";
+  const formattedBalance = walletBalance ? chunkRDMJGMI3_cjs.formatTokenAmount(walletBalance.toString(), token.decimals) : "0.00";
   return /* @__PURE__ */ jsxRuntime.jsxs(
     "button",
     {
       onClick,
-      className: cn(
+      className: chunkRDMJGMI3_cjs.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"
       ),
@@ -4137,7 +2811,7 @@ function TokenSelectorView({
   onSelect,
   selectedTokenId
 }) {
-  const { enabledTokens, chains } = usePrivanaContext();
+  const { enabledTokens, chains } = chunkRDMJGMI3_cjs.usePrivanaContext();
   const [selectedChainId, setSelectedChainId] = react.useState(chains[0]?.id ?? 84532);
   const chainTokens = react.useMemo(() => {
     return enabledTokens.filter((t) => t.chainId === selectedChainId);
@@ -4167,7 +2841,7 @@ function TokenSelectorView({
             "button",
             {
               onClick: () => setSelectedChainId(chain.id),
-              className: cn(
+              className: chunkRDMJGMI3_cjs.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"
               ),
@@ -4202,7 +2876,7 @@ function ModalBody({
   defaultTab = "deposit",
   onDepositSuccess
 }) {
-  const { defaultToken, tokensStatus } = usePrivanaContext();
+  const { defaultToken, tokensStatus } = chunkRDMJGMI3_cjs.usePrivanaContext();
   const [selectedToken, setSelectedToken] = react.useState(defaultToken);
   const [activeTab, setActiveTab] = react.useState(defaultTab);
   const [currentView, setCurrentView] = react.useState("main");
@@ -4260,7 +2934,7 @@ function ModalBody({
     );
   }
   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(isInteractionPending && "pointer-events-none"), children: /* @__PURE__ */ jsxRuntime.jsx(
+    /* @__PURE__ */ jsxRuntime.jsx("div", { className: chunkRDMJGMI3_cjs.cn(isInteractionPending && "pointer-events-none"), children: /* @__PURE__ */ jsxRuntime.jsx(
       BalanceCards,
       {
         selectedToken,
@@ -4270,7 +2944,7 @@ function ModalBody({
         disabled: isInteractionPending
       }
     ) }),
-    /* @__PURE__ */ jsxRuntime.jsx("div", { className: cn(isInteractionPending && "pointer-events-none"), children: /* @__PURE__ */ jsxRuntime.jsx(Tabs, { activeTab, onTabChange: setActiveTab, disabled: isInteractionPending }) }),
+    /* @__PURE__ */ jsxRuntime.jsx("div", { className: chunkRDMJGMI3_cjs.cn(isInteractionPending && "pointer-events-none"), children: /* @__PURE__ */ jsxRuntime.jsx(Tabs, { activeTab, onTabChange: setActiveTab, disabled: isInteractionPending }) }),
     /* @__PURE__ */ jsxRuntime.jsx("div", { className: "bg-muted rounded-[10px] p-5", children: activeTab === "deposit" ? /* @__PURE__ */ jsxRuntime.jsx(
       DepositForm,
       {
@@ -4331,7 +3005,7 @@ function PrivanaModal({
                 onClick: handleClose,
                 disabled: isCloseBlocked,
                 "aria-label": "Close",
-                className: cn(
+                className: chunkRDMJGMI3_cjs.cn(
                   "absolute top-6 right-5 z-20 flex h-6 w-6 items-center justify-center transition-colors",
                   isCloseBlocked ? "text-muted-foreground/40 cursor-not-allowed" : "text-muted-foreground hover:text-foreground cursor-pointer"
                 ),
@@ -4387,7 +3061,7 @@ function PrivanaInlineModal({
     "div",
     {
       "data-privana": true,
-      className: cn(
+      className: chunkRDMJGMI3_cjs.cn(
         "bg-card flex w-[560px] max-w-full flex-col gap-2 overflow-hidden rounded-2xl p-2 shadow-lg",
         className
       ),
@@ -4422,12 +3096,12 @@ function PrivanaButton({
   }
   const handleClick = () => setModalOpen(true);
   const buttonElement = renderButton ? renderButton({ onClick: handleClick, isOpen: modalOpen }) : /* @__PURE__ */ jsxRuntime.jsx(
-    Button,
+    chunkRDMJGMI3_cjs.Button,
     {
       variant,
       size,
       asChild,
-      className: cn(className),
+      className: chunkRDMJGMI3_cjs.cn(className),
       onClick: handleClick,
       disabled: !isConnected,
       ...buttonProps,
@@ -4453,69 +3127,204 @@ function Skeleton({ className, ...props }) {
     "div",
     {
       "data-slot": "skeleton",
-      className: cn("bg-accent animate-pulse rounded-md", className),
+      className: chunkRDMJGMI3_cjs.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;
+Object.defineProperty(exports, "AccountingApiError", {
+  enumerable: true,
+  get: function () { return chunkRDMJGMI3_cjs.AccountingApiError; }
+});
+Object.defineProperty(exports, "Button", {
+  enumerable: true,
+  get: function () { return chunkRDMJGMI3_cjs.Button; }
+});
+Object.defineProperty(exports, "HOSTED_AUTH_CLOCK_SKEW_MS", {
+  enumerable: true,
+  get: function () { return chunkRDMJGMI3_cjs.HOSTED_AUTH_CLOCK_SKEW_MS; }
+});
+Object.defineProperty(exports, "HostedAuthError", {
+  enumerable: true,
+  get: function () { return chunkRDMJGMI3_cjs.HostedAuthError; }
+});
+Object.defineProperty(exports, "HostedAuthRequiredError", {
+  enumerable: true,
+  get: function () { return chunkRDMJGMI3_cjs.HostedAuthRequiredError; }
+});
+Object.defineProperty(exports, "HostedAuthStateMismatchError", {
+  enumerable: true,
+  get: function () { return chunkRDMJGMI3_cjs.HostedAuthStateMismatchError; }
+});
+Object.defineProperty(exports, "HttpClient", {
+  enumerable: true,
+  get: function () { return chunkRDMJGMI3_cjs.HttpClient; }
+});
+Object.defineProperty(exports, "NETWORK_CONFIG", {
+  enumerable: true,
+  get: function () { return chunkRDMJGMI3_cjs.NETWORK_CONFIG; }
+});
+Object.defineProperty(exports, "NetworkError", {
+  enumerable: true,
+  get: function () { return chunkRDMJGMI3_cjs.NetworkError; }
+});
+Object.defineProperty(exports, "PrivanaClient", {
+  enumerable: true,
+  get: function () { return chunkRDMJGMI3_cjs.PrivanaClient; }
+});
+Object.defineProperty(exports, "PrivanaProvider", {
+  enumerable: true,
+  get: function () { return chunkRDMJGMI3_cjs.PrivanaProvider; }
+});
+Object.defineProperty(exports, "SUPPORTED_CHAINS", {
+  enumerable: true,
+  get: function () { return chunkRDMJGMI3_cjs.SUPPORTED_CHAINS; }
+});
+Object.defineProperty(exports, "SiweAuthProvider", {
+  enumerable: true,
+  get: function () { return chunkRDMJGMI3_cjs.SiweAuthProvider; }
+});
+Object.defineProperty(exports, "ValidationError", {
+  enumerable: true,
+  get: function () { return chunkRDMJGMI3_cjs.ValidationError; }
+});
+Object.defineProperty(exports, "applyRefreshResponse", {
+  enumerable: true,
+  get: function () { return chunkRDMJGMI3_cjs.applyRefreshResponse; }
+});
+Object.defineProperty(exports, "buildHostedAuthSession", {
+  enumerable: true,
+  get: function () { return chunkRDMJGMI3_cjs.buildHostedAuthSession; }
+});
+Object.defineProperty(exports, "buttonVariants", {
+  enumerable: true,
+  get: function () { return chunkRDMJGMI3_cjs.buttonVariants; }
+});
+Object.defineProperty(exports, "clearHostedAuthPendingTransaction", {
+  enumerable: true,
+  get: function () { return chunkRDMJGMI3_cjs.clearHostedAuthPendingTransaction; }
+});
+Object.defineProperty(exports, "createHostedAuthPendingStorageKey", {
+  enumerable: true,
+  get: function () { return chunkRDMJGMI3_cjs.createHostedAuthPendingStorageKey; }
+});
+Object.defineProperty(exports, "createHostedAuthState", {
+  enumerable: true,
+  get: function () { return chunkRDMJGMI3_cjs.createHostedAuthState; }
+});
+Object.defineProperty(exports, "createHostedAuthStorageKey", {
+  enumerable: true,
+  get: function () { return chunkRDMJGMI3_cjs.createHostedAuthStorageKey; }
+});
+Object.defineProperty(exports, "createPkceChallenge", {
+  enumerable: true,
+  get: function () { return chunkRDMJGMI3_cjs.createPkceChallenge; }
+});
+Object.defineProperty(exports, "createPkceVerifier", {
+  enumerable: true,
+  get: function () { return chunkRDMJGMI3_cjs.createPkceVerifier; }
+});
+Object.defineProperty(exports, "getAccountingContract", {
+  enumerable: true,
+  get: function () { return chunkRDMJGMI3_cjs.getAccountingContract; }
+});
+Object.defineProperty(exports, "getApiUrl", {
+  enumerable: true,
+  get: function () { return chunkRDMJGMI3_cjs.getApiUrl; }
+});
+Object.defineProperty(exports, "getChainById", {
+  enumerable: true,
+  get: function () { return chunkRDMJGMI3_cjs.getChainById; }
+});
+Object.defineProperty(exports, "getChainId", {
+  enumerable: true,
+  get: function () { return chunkRDMJGMI3_cjs.getChainId; }
+});
+Object.defineProperty(exports, "getExplorerAddressUrl", {
+  enumerable: true,
+  get: function () { return chunkRDMJGMI3_cjs.getExplorerAddressUrl; }
+});
+Object.defineProperty(exports, "isHostedAuthRefreshActive", {
+  enumerable: true,
+  get: function () { return chunkRDMJGMI3_cjs.isHostedAuthRefreshActive; }
+});
+Object.defineProperty(exports, "isHostedAuthSessionActive", {
+  enumerable: true,
+  get: function () { return chunkRDMJGMI3_cjs.isHostedAuthSessionActive; }
+});
+Object.defineProperty(exports, "normalizeAddress", {
+  enumerable: true,
+  get: function () { return chunkRDMJGMI3_cjs.normalizeAddress; }
+});
+Object.defineProperty(exports, "normalizeHex", {
+  enumerable: true,
+  get: function () { return chunkRDMJGMI3_cjs.normalizeHex; }
+});
+Object.defineProperty(exports, "parseHostedAuthCallback", {
+  enumerable: true,
+  get: function () { return chunkRDMJGMI3_cjs.parseHostedAuthCallback; }
+});
+Object.defineProperty(exports, "persistHostedAuthPendingTransaction", {
+  enumerable: true,
+  get: function () { return chunkRDMJGMI3_cjs.persistHostedAuthPendingTransaction; }
+});
+Object.defineProperty(exports, "readHostedAuthPendingTransaction", {
+  enumerable: true,
+  get: function () { return chunkRDMJGMI3_cjs.readHostedAuthPendingTransaction; }
+});
+Object.defineProperty(exports, "readStoredHostedAuthSession", {
+  enumerable: true,
+  get: function () { return chunkRDMJGMI3_cjs.readStoredHostedAuthSession; }
+});
+Object.defineProperty(exports, "stripHostedAuthCallbackParams", {
+  enumerable: true,
+  get: function () { return chunkRDMJGMI3_cjs.stripHostedAuthCallbackParams; }
+});
+Object.defineProperty(exports, "syncHostedAuthSessionToClient", {
+  enumerable: true,
+  get: function () { return chunkRDMJGMI3_cjs.syncHostedAuthSessionToClient; }
+});
+Object.defineProperty(exports, "useDepositVerification", {
+  enumerable: true,
+  get: function () { return chunkRDMJGMI3_cjs.useDepositVerification; }
+});
+Object.defineProperty(exports, "usePrivanaContext", {
+  enumerable: true,
+  get: function () { return chunkRDMJGMI3_cjs.usePrivanaContext; }
+});
+Object.defineProperty(exports, "useSafeAccount", {
+  enumerable: true,
+  get: function () { return chunkRDMJGMI3_cjs.useSafeAccount; }
+});
+Object.defineProperty(exports, "useSafePrivanaContext", {
+  enumerable: true,
+  get: function () { return chunkRDMJGMI3_cjs.useSafePrivanaContext; }
+});
+Object.defineProperty(exports, "useSiweAuth", {
+  enumerable: true,
+  get: function () { return chunkRDMJGMI3_cjs.useSiweAuth; }
+});
 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;
@@ -4527,9 +3336,6 @@ 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;