@oasisprotocol/privana-sdk 0.2.1 → 0.4.0

package/dist/index.js

@@ -1,579 +1,15 @@
 "use client";
-import { createContext, useMemo, useState, useEffect, useRef, useCallback, useContext, useSyncExternalStore, useId } from 'react';
-import { zeroAddress, erc20Abi, hexToString } from 'viem';
-import { jsx, jsxs, Fragment } from 'react/jsx-runtime';
+import { usePrivanaContext, createHostedAuthPendingStorageKey, clearHostedAuthPendingTransaction, HostedAuthRequiredError, HostedAuthError, createPkceVerifier, createPkceChallenge, createHostedAuthState, persistHostedAuthPendingTransaction, parseHostedAuthCallback, readHostedAuthPendingTransaction, HostedAuthStateMismatchError, buildHostedAuthSession, useSafePrivanaContext, usePrivateReadRequest, formatTokenAmount, useDepositVerification, getTransactionReceipt, waitForTransactionReceipt, cn, Button, stripHostedAuthCallbackParams, AccountingApiError, getChainId2, shortenAddress, formatTimeRemaining, parseTokenAmount, getExplorerAddressUrl } from './chunk-ZVNC4FTJ.js';
+export { AccountingApiError, Button, HOSTED_AUTH_CLOCK_SKEW_MS, HostedAuthError, HostedAuthRequiredError, HostedAuthStateMismatchError, HttpClient, NETWORK_CONFIG, NetworkError, PrivanaClient, PrivanaProvider, SUPPORTED_CHAINS, SiweAuthProvider, ValidationError, applyRefreshResponse, buildHostedAuthSession, buttonVariants, clearHostedAuthPendingTransaction, createHostedAuthPendingStorageKey, createHostedAuthState, createHostedAuthStorageKey, createPkceChallenge, createPkceVerifier, getAccountingContract, getApiUrl, getChainById, getChainId, getExplorerAddressUrl, isHostedAuthRefreshActive, isHostedAuthSessionActive, normalizeAddress, normalizeHex, parseHostedAuthCallback, persistHostedAuthPendingTransaction, readHostedAuthPendingTransaction, readStoredHostedAuthSession, stripHostedAuthCallbackParams, syncHostedAuthSessionToClient, useDepositVerification, usePrivanaContext, useSafeAccount, useSafePrivanaContext, useSiweAuth } from './chunk-ZVNC4FTJ.js';
+import { useState, useRef, useMemo, useCallback, useContext, useEffect, useId } from 'react';
 import { QueryClientContext, useQuery, useQueryClient, useMutation, keepPreviousData } from '@tanstack/react-query';
-import { clsx } from 'clsx';
-import { twMerge } from 'tailwind-merge';
-import { createSiweMessage } from 'viem/siwe';
-import { WagmiContext, useAccount, useWalletClient, useConfig, useWriteContract, useSendTransaction, useChainId, useSwitchChain, useBalance as useBalance$1, useReadContract } from 'wagmi';
-import { watchAccount, getAccount, getWalletClient } from 'wagmi/actions';
-import { getTransactionReceipt as getTransactionReceipt$1, waitForTransactionReceipt as waitForTransactionReceipt$1, getTransaction, call } from 'viem/actions';
-import { Slot } from '@radix-ui/react-slot';
-import { cva } from 'class-variance-authority';
+import { useAccount, useWalletClient, useConfig, useWriteContract, useSendTransaction, useChainId, useSwitchChain, useBalance as useBalance$1, useReadContract } from 'wagmi';
+import { zeroAddress, erc20Abi } from 'viem';
 import * as DialogPrimitive from '@radix-ui/react-dialog';
 import { XIcon } from 'lucide-react';
+import { jsx, jsxs, Fragment } from 'react/jsx-runtime';
 import { toast } from 'sonner';
 
-// ../../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 {
@@ -769,294 +205,6 @@ async function signWithdrawFromLockMessage({
   });
   return signature;
 }
-var PrivanaContext = 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 = 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 = useMemo(() => {
-    if (chains && chains.length > 0) return chains;
-    return SUPPORTED_CHAINS;
-  }, [chains]);
-  const client = useMemo(
-    () => new PrivanaClient({ baseUrl: networkConfig.apiUrl }),
-    [networkConfig.apiUrl]
-  );
-  const [allTokens, setAllTokens] = useState([]);
-  const [tokensStatus, setTokensStatus] = useState("loading");
-  const [tokensError, setTokensError] = useState();
-  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 ?? 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 = 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 = useMemo(
-    () => Object.fromEntries(enabledTokens.map((t) => [t.id.toLowerCase(), t])),
-    [enabledTokens]
-  );
-  const getTokenById = useMemo(() => (id) => tokenById[id.toLowerCase()], [tokenById]);
-  const chainById = useMemo(
-    () => Object.fromEntries(resolvedChains.map((c) => [c.id, c])),
-    [resolvedChains]
-  );
-  const getChainById2 = useMemo(() => (id) => chainById[id], [chainById]);
-  const hostedAuthConfig = 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 = useMemo(
-    () => hostedAuthConfig ? createHostedAuthStorageKey(networkConfig.apiUrl, hostedAuthConfig) : null,
-    [hostedAuthConfig, networkConfig.apiUrl]
-  );
-  const [hostedAuthSession, setHostedAuthSessionState] = useState(null);
-  const hostedAuthSessionRef = useRef(null);
-  const hostedAuthStateVersionRef = useRef(0);
-  const hostedAuthRefreshInflight = useRef(null);
-  const clearHostedAuthSession = 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 = 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 = 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]);
-  useEffect(() => {
-    hostedAuthSessionRef.current = hostedAuthSession;
-  }, [hostedAuthSession]);
-  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]);
-  useEffect(() => {
-    syncHostedAuthSessionToClient(client, hostedAuthConfig, hostedAuthSession);
-  }, [client, hostedAuthConfig, hostedAuthSession]);
-  const value = 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__ */ jsx(PrivanaContext.Provider, { value, children });
-}
-function usePrivanaContext() {
-  const context = useContext(PrivanaContext);
-  if (!context) {
-    throw new Error("usePrivanaContext must be used within a PrivanaProvider");
-  }
-  return context;
-}
-function useSafePrivanaContext() {
-  return useContext(PrivanaContext);
-}
 
 // src/sdk/hooks/use-privana-client.ts
 function usePrivanaClient() {
@@ -1265,280 +413,6 @@ function useHostedRedirectAuth() {
     refresh
   };
 }
-function cn(...inputs) {
-  return twMerge(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 = useContext(WagmiContext);
-  const cacheRef = useRef(defaultResult);
-  const subscribe = useCallback(
-    (onChange) => {
-      if (!context) return () => {
-      };
-      return watchAccount(context, { onChange });
-    },
-    [context]
-  );
-  const getSnapshot = useCallback(() => {
-    if (!context) return defaultResult;
-    const account = 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 = useCallback(() => defaultResult, []);
-  return 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 = useContext(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 = 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 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 = 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 = 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 = useContext(QueryClientContext);
   const accountingContext = useSafePrivanaContext();
@@ -1592,55 +466,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, getTransactionReceipt$1, "getTransactionReceipt");
-  return action(rest);
-}
-async function waitForTransactionReceipt(config, parameters) {
-  const { chainId, timeout = 0, ...rest } = parameters;
-  const client = config.getClient({ chainId });
-  const action = getAction(client, waitForTransactionReceipt$1, "waitForTransactionReceipt");
-  const receipt = await action({ ...rest, timeout });
-  if (receipt.status === "reverted") {
-    const action_getTransaction = getAction(client, getTransaction, "getTransaction");
-    const { from: account, ...txn } = await action_getTransaction({
-      hash: receipt.transactionHash
-    });
-    const action_call = getAction(client, 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 ? hexToString(`0x${code.data.substring(138)}`) : "unknown reason";
-    throw new Error(reason);
-  }
-  return {
-    ...receipt,
-    chainId: client.chain.id
-  };
-}
 function useEnsureCorrectChain() {
   const config = useConfig();
   const chainId = useChainId();
@@ -1731,19 +556,14 @@ function useDeposit(options = {}) {
   const queryClient = useQueryClient();
   const config = useConfig();
   const { executePrivateRead } = usePrivateReadRequest();
-  const pollInterval = options.pollInterval ?? 5e3;
-  const pollTimeout = options.pollTimeout ?? 18e4;
   const confirmations = options.confirmations ?? 15;
   const [depositAddress, setDepositAddress] = useState(null);
   const [txHash, setTxHash] = useState();
   const [isSwitchingChain, setIsSwitchingChain] = useState(false);
   const [isWaitingForConfirmation, setIsWaitingForConfirmation] = useState(false);
-  const [isWaitingForProcessing, setIsWaitingForProcessing] = useState(false);
-  const [didTimeout, setDidTimeout] = useState(false);
-  const [verificationFailed, setVerificationFailed] = useState(false);
+  const [receiptFailed, setReceiptFailed] = useState(false);
   const [depositError, setDepositError] = useState(null);
   const generationRef = useRef(0);
-  const pollIntervalRef = useRef(null);
   const verificationContextRef = useRef(null);
   const onDepositAddressReceivedRef = useRef(options.onDepositAddressReceived);
   const onDepositSuccessRef = useRef(options.onDepositSuccess);
@@ -1763,6 +583,28 @@ function useDeposit(options = {}) {
     options.onCheckTimeout,
     options.onError
   ]);
+  const {
+    isVerifying,
+    didTimeout,
+    verificationFailed: innerVerificationFailed,
+    error: verificationError,
+    verify,
+    reset: resetVerification
+  } = 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 = useMutation({
     mutationFn: async () => {
       if (!address) throw new Error("No wallet connected");
@@ -1797,149 +639,24 @@ function useDeposit(options = {}) {
   useEffect(() => {
     return () => {
       invalidateGeneration();
-      if (pollIntervalRef.current) {
-        clearTimeout(pollIntervalRef.current);
-        pollIntervalRef.current = null;
-      }
     };
   }, [invalidateGeneration]);
   const resumedAddressRef = useRef(void 0);
-  const stopPolling = useCallback(() => {
-    if (pollIntervalRef.current) {
-      clearTimeout(pollIntervalRef.current);
-      pollIntervalRef.current = null;
-    }
-  }, []);
   const reset = 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 = 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 = 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]);
   useEffect(() => {
     if (!address || resumedAddressRef.current === address) return;
     const persisted = loadPendingDeposit(address);
@@ -1976,19 +693,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 = useCallback(
     async (params) => {
       if (verificationContextRef.current) {
@@ -2066,15 +781,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) {
@@ -2096,13 +809,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 = 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,
@@ -2110,9 +831,9 @@ function useDeposit(options = {}) {
     isSwitchingChain,
     isSendingTransaction: isSendingTx,
     isWaitingForConfirmation,
-    isWaitingForProcessing,
+    isWaitingForProcessing: isVerifying,
     didTimeout,
-    verificationFailed,
+    verificationFailed: innerVerificationFailed || receiptFailed,
     isPending,
     error,
     deposit,
@@ -2772,52 +1493,6 @@ function useModifyLock(options = {}) {
     reset: mutation.reset
   };
 }
-var buttonVariants = 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 ? Slot : "button";
-  return /* @__PURE__ */ jsx(
-    Comp,
-    {
-      "data-slot": "button",
-      "data-variant": variant,
-      "data-size": size,
-      className: cn(buttonVariants({ variant, size, className })),
-      ...props
-    }
-  );
-}
 function Dialog({ ...props }) {
   return /* @__PURE__ */ jsx(DialogPrimitive.Root, { "data-slot": "dialog", ...props });
 }
@@ -4437,6 +3112,6 @@ function Skeleton({ className, ...props }) {
   );
 }
 
-export { AccountingApiError, Button, HOSTED_AUTH_CLOCK_SKEW_MS, HostedAuthError, HostedAuthRequiredError, HostedAuthStateMismatchError, HttpClient, LOCK_TYPES, MODIFY_LOCK_TYPES, NETWORK_CONFIG, NetworkError, PrivanaButton, PrivanaClient, PrivanaInlineModal, PrivanaModal, PrivanaProvider, SUPPORTED_CHAINS, Skeleton, TRANSFER_LOCKED_TYPES, TRANSFER_TYPES, ValidationError, WITHDRAW_FROM_LOCK_TYPES, WITHDRAW_TYPES, applyRefreshResponse, buildHostedAuthSession, buttonVariants, clearHostedAuthPendingTransaction, createDomain, createHostedAuthPendingStorageKey, createHostedAuthState, createHostedAuthStorageKey, createLockExpiry, createPkceChallenge, createPkceVerifier, getAccountingContract, getApiUrl, getChainById, getChainIcon, getChainId, getExplorerAddressUrl, getTokenIcon, isHostedAuthRefreshActive, isHostedAuthSessionActive, normalizeAddress, normalizeHex, parseHostedAuthCallback, persistHostedAuthPendingTransaction, readHostedAuthPendingTransaction, readStoredHostedAuthSession, signLockMessage, signModifyLockMessage, signTransferLockedMessage, signTransferMessage, signWithdrawFromLockMessage, signWithdrawMessage, stripHostedAuthCallbackParams, syncHostedAuthSessionToClient, useBalance, useBatchBalances, useDeposit, useExpiredLocks, useHistory, useHostedRedirectAuth, useLockFunds, useLockedFunds, useModifyLock, usePendingWithdrawals, usePrivanaClient, usePrivanaContext, useSafeAccount, useSafePrivanaContext, useTokenInfo, useTokenList, useTotalLockedBalance, useTransfer, useUnlockFunds, useWithdraw };
+export { LOCK_TYPES, MODIFY_LOCK_TYPES, PrivanaButton, PrivanaInlineModal, PrivanaModal, Skeleton, TRANSFER_LOCKED_TYPES, TRANSFER_TYPES, WITHDRAW_FROM_LOCK_TYPES, WITHDRAW_TYPES, createDomain, createLockExpiry, getChainIcon, getTokenIcon, signLockMessage, signModifyLockMessage, signTransferLockedMessage, signTransferMessage, signWithdrawFromLockMessage, signWithdrawMessage, useBalance, useBatchBalances, useDeposit, useExpiredLocks, useHistory, useHostedRedirectAuth, useLockFunds, useLockedFunds, useModifyLock, usePendingWithdrawals, usePrivanaClient, useTokenInfo, useTokenList, useTotalLockedBalance, useTransfer, useUnlockFunds, useWithdraw };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map