@oasisprotocol/privana-sdk 0.4.4 → 0.5.1

package/dist/chunk-4IW4V7YJ.cjs

@@ -0,0 +1,3805 @@
+"use client";
+'use strict';
+
+var react = require('react');
+var wagmi = require('wagmi');
+var actions = require('wagmi/actions');
+var siwe = require('viem/siwe');
+var jsxRuntime = require('react/jsx-runtime');
+var viem = require('viem');
+var reactQuery = require('@tanstack/react-query');
+var reactSlot = require('@radix-ui/react-slot');
+var classVarianceAuthority = require('class-variance-authority');
+var clsx = require('clsx');
+var tailwindMerge = require('tailwind-merge');
+var utils = require('viem/utils');
+var actions$1 = require('viem/actions');
+var lucideReact = require('lucide-react');
+var moonpayReact = require('@moonpay/moonpay-react');
+
+// ../../shared/config.json
+var config_default = {
+  chains: [
+    {
+      id: 84532,
+      name: "Base Sepolia",
+      explorerUrl: "https://sepolia.basescan.org",
+      explorerName: "BaseScan"
+    },
+    {
+      id: 11155111,
+      name: "Ethereum Sepolia",
+      explorerUrl: "https://sepolia.etherscan.io",
+      explorerName: "Etherscan"
+    }
+  ],
+  networks: {
+    testnet: {
+      chainId: 23295,
+      name: "Sapphire Testnet",
+      accountingContract: "0xad3C76e4E621C0cfF7540479Ee9B0A945723A642",
+      apiUrl: "https://api.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,
+  explorerName: chain.explorerName
+}));
+function getChainById(chainId) {
+  return SUPPORTED_CHAINS.find((c) => c.id === chainId);
+}
+function getExplorerLabel(chainId) {
+  const chain = getChainById(chainId);
+  return `View on ${chain?.explorerName ?? "Explorer"}`;
+}
+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/auth/siwe.ts
+function buildSiweStatement(chainId) {
+  return `Sign in to Privana on chain ${chainId}`;
+}
+
+// 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 getPendingDeposits(request) {
+    const params = new URLSearchParams({ chain_id: String(request.chain_id) });
+    if (request.version !== void 0) params.set("version", String(request.version));
+    if (request.token_address !== void 0) {
+      params.set("token_address", normalizeAddress(request.token_address));
+    }
+    if (request.lookback_blocks !== void 0) {
+      params.set("lookback_blocks", String(request.lookback_blocks));
+    }
+    return this.http.get(
+      `/v1/accounting/deposits/pending?${params.toString()}`
+    );
+  }
+  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
+    });
+  }
+  async signOnRampUrl(request) {
+    return this.http.post("/v1/accounting/onramp/sign-url", {
+      url: request.url
+    });
+  }
+  async createOnRampIntent(request) {
+    return this.http.post("/v1/accounting/onramp/intent", {
+      wallet_address: request.wallet_address ? normalizeAddress(request.wallet_address) : void 0,
+      token_id: normalizeHex(request.token_id),
+      chain_id: request.chain_id,
+      moonpay_currency_code: request.moonpay_currency_code,
+      base_currency_code: request.base_currency_code,
+      base_currency_amount: request.base_currency_amount
+    });
+  }
+  async updateOnRamp(transactionId, request) {
+    return this.http.post(
+      `/v1/accounting/onramp/${encodeURIComponent(transactionId)}`,
+      {
+        wallet_address: request.wallet_address ? normalizeAddress(request.wallet_address) : void 0,
+        token_id: request.token_id ? normalizeHex(request.token_id) : void 0,
+        chain_id: request.chain_id,
+        moonpay_transaction_id: request.moonpay_transaction_id,
+        base_currency_code: request.base_currency_code,
+        base_currency_amount: request.base_currency_amount,
+        quote_currency_amount: request.quote_currency_amount,
+        on_chain_tx_hash: request.on_chain_tx_hash ? normalizeHex(request.on_chain_tx_hash) : void 0,
+        deposit_tx_hash: request.deposit_tx_hash ? normalizeHex(request.deposit_tx_hash) : void 0
+      }
+    );
+  }
+  async getPendingOnRamps() {
+    return this.http.get("/v1/accounting/onramp/pending");
+  }
+  setPrivateReadToken(token) {
+    this.http.removeHeader("Authorization");
+    this.http.setHeader(PRIVATE_READ_TOKEN_HEADER, token);
+  }
+  getPrivateReadToken() {
+    return this.http.getHeader(PRIVATE_READ_TOKEN_HEADER);
+  }
+  clearPrivateReadToken() {
+    this.http.removeHeader(PRIVATE_READ_TOKEN_HEADER);
+  }
+  setBearerToken(token) {
+    this.http.removeHeader(PRIVATE_READ_TOKEN_HEADER);
+    this.http.setHeader("Authorization", `Bearer ${token}`);
+  }
+  clearBearerToken() {
+    this.http.removeHeader("Authorization");
+  }
+};
+
+// src/sdk/signatures/eip712-types.ts
+function createDomain(chainId, verifyingContract) {
+  return {
+    name: "AccountingModule",
+    version: "1",
+    chainId,
+    verifyingContract
+  };
+}
+var LOCK_TYPES = {
+  Lock: [
+    { name: "serviceAddress", type: "address" },
+    { name: "tokenId", type: "bytes32" },
+    { name: "amount", type: "uint256" },
+    { name: "expiry", type: "uint256" },
+    { name: "nonce", type: "uint256" }
+  ]
+};
+var TRANSFER_TYPES = {
+  Transfer: [
+    { name: "toAddress", type: "address" },
+    { name: "tokenId", type: "bytes32" },
+    { name: "amount", type: "uint256" },
+    { name: "nonce", type: "uint256" }
+  ]
+};
+var TRANSFER_LOCKED_TYPES = {
+  TransferLocked: [
+    { name: "userAddress", type: "address" },
+    { name: "toAddress", type: "address" },
+    { name: "lockId", type: "uint256" },
+    { name: "amount", type: "uint256" },
+    { name: "nonce", type: "uint256" },
+    { name: "serviceAddress", type: "address" }
+  ]
+};
+var WITHDRAW_TYPES = {
+  Withdraw: [
+    { name: "tokenId", type: "bytes32" },
+    { name: "amount", type: "uint256" },
+    { name: "nonce", type: "uint256" }
+  ]
+};
+var MODIFY_LOCK_TYPES = {
+  ModifyLock: [
+    { name: "lockId", type: "uint256" },
+    { name: "amount", type: "uint256" },
+    { name: "newExpiry", type: "uint256" },
+    { name: "nonce", type: "uint256" }
+  ]
+};
+var WITHDRAW_FROM_LOCK_TYPES = {
+  WithdrawFromLock: [
+    { name: "userAddress", type: "address" },
+    { name: "toAddress", type: "address" },
+    { name: "lockId", type: "uint256" },
+    { name: "amount", type: "uint256" },
+    { name: "nonce", type: "uint256" }
+  ]
+};
+
+// src/sdk/signatures/sign-lock.ts
+async function signLockMessage({
+  walletClient,
+  chainId,
+  verifyingContract,
+  message
+}) {
+  const account = walletClient.account;
+  if (!account) {
+    throw new Error("No account connected to wallet client");
+  }
+  const domain = createDomain(chainId, verifyingContract);
+  const signature = await walletClient.signTypedData({
+    account,
+    domain,
+    types: LOCK_TYPES,
+    primaryType: "Lock",
+    message
+  });
+  return signature;
+}
+function createLockExpiry(minutesFromNow = 60) {
+  return BigInt(Math.floor(Date.now() / 1e3) + minutesFromNow * 60);
+}
+
+// src/sdk/signatures/sign-modify-lock.ts
+async function signModifyLockMessage({
+  walletClient,
+  chainId,
+  verifyingContract,
+  message
+}) {
+  const account = walletClient.account;
+  if (!account) {
+    throw new Error("No account connected to wallet client");
+  }
+  const domain = createDomain(chainId, verifyingContract);
+  const signature = await walletClient.signTypedData({
+    account,
+    domain,
+    types: MODIFY_LOCK_TYPES,
+    primaryType: "ModifyLock",
+    message
+  });
+  return signature;
+}
+
+// src/sdk/signatures/sign-transfer.ts
+async function signTransferMessage({
+  walletClient,
+  chainId,
+  verifyingContract,
+  message
+}) {
+  const account = walletClient.account;
+  if (!account) {
+    throw new Error("No account connected to wallet client");
+  }
+  const domain = createDomain(chainId, verifyingContract);
+  const signature = await walletClient.signTypedData({
+    account,
+    domain,
+    types: TRANSFER_TYPES,
+    primaryType: "Transfer",
+    message
+  });
+  return signature;
+}
+
+// src/sdk/signatures/sign-transfer-locked.ts
+async function signTransferLockedMessage({
+  walletClient,
+  chainId,
+  verifyingContract,
+  message
+}) {
+  const account = walletClient.account;
+  if (!account) {
+    throw new Error("No account connected to wallet client");
+  }
+  const domain = createDomain(chainId, verifyingContract);
+  const signature = await walletClient.signTypedData({
+    account,
+    domain,
+    types: TRANSFER_LOCKED_TYPES,
+    primaryType: "TransferLocked",
+    message
+  });
+  return signature;
+}
+
+// src/sdk/signatures/sign-withdraw.ts
+async function signWithdrawMessage({
+  walletClient,
+  chainId,
+  verifyingContract,
+  message
+}) {
+  const account = walletClient.account;
+  if (!account) {
+    throw new Error("No account connected to wallet client");
+  }
+  const domain = createDomain(chainId, verifyingContract);
+  const signature = await walletClient.signTypedData({
+    account,
+    domain,
+    types: WITHDRAW_TYPES,
+    primaryType: "Withdraw",
+    message
+  });
+  return signature;
+}
+
+// src/sdk/signatures/sign-withdraw-from-lock.ts
+async function signWithdrawFromLockMessage({
+  walletClient,
+  chainId,
+  verifyingContract,
+  message
+}) {
+  const account = walletClient.account;
+  if (!account) {
+    throw new Error("No account connected to wallet client");
+  }
+  const domain = createDomain(chainId, verifyingContract);
+  const signature = await walletClient.signTypedData({
+    account,
+    domain,
+    types: WITHDRAW_FROM_LOCK_TYPES,
+    primaryType: "WithdrawFromLock",
+    message
+  });
+  return signature;
+}
+var defaultResult = {
+  address: void 0,
+  isConnected: false,
+  status: "disconnected"
+};
+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.status !== account.status) {
+      cacheRef.current = {
+        address: account.address,
+        isConnected: account.isConnected,
+        status: account.status
+      };
+    }
+    return cacheRef.current;
+  }, [context]);
+  const getServerSnapshot = react.useCallback(() => defaultResult, []);
+  return react.useSyncExternalStore(subscribe, getSnapshot, getServerSnapshot);
+}
+
+// src/sdk/hooks/private-read-token-store.ts
+var AUTH_CLOCK_SKEW_MS = 3e4;
+var cache = /* @__PURE__ */ new Map();
+function createScopeKey(apiUrl, chainId, address) {
+  return `${apiUrl.replace(/\/$/, "")}:${chainId}:${address.toLowerCase()}`;
+}
+function getCachedPrivateReadToken(scopeKey) {
+  const cached = cache.get(scopeKey);
+  if (!cached) return null;
+  if (cached.expiresAt <= Date.now() + AUTH_CLOCK_SKEW_MS) {
+    cache.delete(scopeKey);
+    return null;
+  }
+  return cached.token;
+}
+function setCachedPrivateReadToken(scopeKey, token, expiresAt) {
+  cache.set(scopeKey, { token, expiresAt });
+}
+function deleteCachedPrivateReadToken(scopeKey) {
+  cache.delete(scopeKey);
+}
+var DEFAULT_SIWE_VALIDITY_MS = 24 * 60 * 60 * 1e3;
+var AUTH_REFRESH_SKEW_MS = 3e4;
+var SiweAuthContext = react.createContext(null);
+function SiweAuthProvider({
+  children,
+  client,
+  networkConfig,
+  autoLogin = true
+}) {
+  const wagmiContext = react.useContext(wagmi.WagmiContext);
+  const { address, isConnected, status } = useSafeAccount();
+  const [session, setSession] = react.useState(null);
+  const [tokens, setTokens] = react.useState(null);
+  const [isLoading, setIsLoading] = react.useState(false);
+  const [error, setError] = react.useState(null);
+  const [accessTokenExpiresAt, setAccessTokenExpiresAt] = react.useState(null);
+  const loginInFlight = react.useRef(false);
+  const autoAttemptedAddress = react.useRef(null);
+  const refreshInFlight = react.useRef(false);
+  const refreshDataRef = react.useRef(null);
+  const clearSession = react.useCallback(() => {
+    refreshDataRef.current = null;
+    setAccessTokenExpiresAt(null);
+    client.clearPrivateReadToken();
+    client.clearBearerToken();
+    setSession(null);
+    setTokens(null);
+    setError(null);
+    autoAttemptedAddress.current = null;
+  }, [client]);
+  const logout = react.useCallback(async () => {
+    setError(null);
+    const refreshToken = refreshDataRef.current?.refreshToken;
+    try {
+      if (refreshToken) {
+        await client.logoutJwtSession({ refresh_token: refreshToken });
+      }
+    } finally {
+      clearSession();
+      autoAttemptedAddress.current = address ?? null;
+    }
+  }, [clearSession, client, address]);
+  const login = react.useCallback(async () => {
+    if (!wagmiContext) throw new Error("WagmiProvider is required for SIWE auth");
+    if (!address) throw new Error("No wallet connected");
+    if (loginInFlight.current) return;
+    loginInFlight.current = true;
+    setIsLoading(true);
+    setError(null);
+    try {
+      const walletClient = await actions.getWalletClient(wagmiContext);
+      if (!walletClient) throw new Error("No wallet client available");
+      const [{ domain }, nonceRes] = await Promise.all([
+        client.getSiweDomain(),
+        client.getSiweNonce(address)
+      ]);
+      const issuedAt = /* @__PURE__ */ new Date();
+      const expirationTime = new Date(issuedAt.getTime() + DEFAULT_SIWE_VALIDITY_MS);
+      const uri = typeof window !== "undefined" && window.location.origin ? window.location.origin : networkConfig.apiUrl;
+      const message = siwe.createSiweMessage({
+        address,
+        chainId: networkConfig.chainId,
+        domain,
+        uri,
+        version: "1",
+        nonce: nonceRes.nonce,
+        statement: buildSiweStatement(networkConfig.chainId),
+        issuedAt,
+        expirationTime
+      });
+      const signature = await walletClient.signMessage({
+        account: walletClient.account ?? address,
+        message
+      });
+      const res = await client.loginWithSiwe({ siwe_message: message, signature });
+      const loggedInAt = Date.now();
+      client.setPrivateReadToken(res.siwe_token);
+      client.setBearerToken(res.jwt_access_token);
+      refreshDataRef.current = {
+        refreshToken: res.jwt_refresh_token,
+        refreshExpiresAt: loggedInAt + res.jwt_refresh_expires_in * 1e3
+      };
+      setCachedPrivateReadToken(
+        createScopeKey(networkConfig.apiUrl, networkConfig.chainId, address),
+        res.siwe_token,
+        expirationTime.getTime()
+      );
+      setSession({ address: res.address });
+      setTokens({
+        siwe_token: res.siwe_token,
+        jwt_access_token: res.jwt_access_token,
+        jwt_refresh_token: res.jwt_refresh_token,
+        address: res.address
+      });
+      setAccessTokenExpiresAt(loggedInAt + res.jwt_expires_in * 1e3);
+    } catch (err) {
+      setError(err instanceof Error ? err : new Error("Sign-in failed"));
+      throw err;
+    } finally {
+      setIsLoading(false);
+      loginInFlight.current = false;
+    }
+  }, [wagmiContext, address, client, networkConfig.chainId, networkConfig.apiUrl]);
+  const refreshAccessToken = react.useCallback(async () => {
+    const data = refreshDataRef.current;
+    if (!data || refreshInFlight.current) return;
+    if (Date.now() >= data.refreshExpiresAt - AUTH_REFRESH_SKEW_MS) {
+      clearSession();
+      return;
+    }
+    refreshInFlight.current = true;
+    try {
+      const res = await client.refreshJwtSession({ refresh_token: data.refreshToken });
+      const refreshedAt = Date.now();
+      client.setBearerToken(res.token);
+      refreshDataRef.current = {
+        refreshToken: res.refresh_token,
+        refreshExpiresAt: refreshedAt + res.refresh_expires_in * 1e3
+      };
+      setTokens(
+        (prev) => prev ? { ...prev, jwt_access_token: res.token, jwt_refresh_token: res.refresh_token } : prev
+      );
+      setAccessTokenExpiresAt(refreshedAt + res.expires_in * 1e3);
+    } catch {
+      clearSession();
+    } finally {
+      refreshInFlight.current = false;
+    }
+  }, [client, clearSession]);
+  react.useEffect(() => {
+    if (accessTokenExpiresAt == null) return;
+    const delay = Math.max(accessTokenExpiresAt - AUTH_REFRESH_SKEW_MS - Date.now(), 0);
+    const timer = setTimeout(() => {
+      void refreshAccessToken();
+    }, delay);
+    return () => clearTimeout(timer);
+  }, [accessTokenExpiresAt, refreshAccessToken]);
+  react.useEffect(() => {
+    if (!autoLogin) return;
+    if (status === "connecting" || status === "reconnecting") return;
+    if (!isConnected && session) {
+      clearSession();
+      return;
+    }
+    if (isConnected && address && session && address.toLowerCase() !== session.address.toLowerCase()) {
+      clearSession();
+      return;
+    }
+    if (isConnected && address && !session && !isLoading && autoAttemptedAddress.current !== address) {
+      autoAttemptedAddress.current = address;
+      void login().catch(() => {
+      });
+    }
+  }, [autoLogin, status, isConnected, address, session, isLoading, login, clearSession]);
+  const value = react.useMemo(
+    () => ({
+      isAuthenticated: !!session,
+      isLoading,
+      error,
+      session,
+      accessToken: tokens?.jwt_access_token,
+      tokens,
+      login,
+      logout
+    }),
+    [session, isLoading, error, tokens, login, logout]
+  );
+  return /* @__PURE__ */ jsxRuntime.jsx(SiweAuthContext.Provider, { value, children });
+}
+function useSiweAuth() {
+  const ctx = react.useContext(SiweAuthContext);
+  if (!ctx) throw new Error("useSiweAuth must be used within SiweAuthProvider");
+  return ctx;
+}
+
+// src/sdk/moonpay-currency-codes.ts
+var MOONPAY_CURRENCY_CODE_BY_TOKEN_ID = {
+  // Sandbox MPT test token (Ethereum Sepolia).
+  "0xbd3a41ffd21be1cfcdca7a4e7755842a5b78c9443fb7ea008e6a7314f0caea87": "usdc"
+};
+function resolveMoonpayCurrencyCode(tokenId) {
+  return MOONPAY_CURRENCY_CODE_BY_TOKEN_ID[tokenId.toLowerCase()];
+}
+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,
+  serviceName,
+  serviceIcon,
+  hostedAuth,
+  siweAuth
+}) {
+  if (hostedAuth && siweAuth) {
+    throw new Error(
+      "PrivanaProvider: `hostedAuth` and `siweAuth` are mutually exclusive - provide only one. When both are set, private reads use hosted auth and the in-app SIWE login is ignored."
+    );
+  }
+  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,
+          moonpayCurrencyCode: resolveMoonpayCurrencyCode(t.token_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,
+      serviceName,
+      serviceIcon,
+      hostedAuthConfig,
+      hostedAuthSession,
+      setHostedAuthSession,
+      clearHostedAuthSession,
+      refreshHostedAuthSession
+    }),
+    [
+      client,
+      networkConfig,
+      enabledTokens,
+      getTokenById,
+      getChainById2,
+      resolvedChains,
+      tokensStatus,
+      tokensError,
+      pollingInterval,
+      serviceAddress,
+      serviceName,
+      serviceIcon,
+      hostedAuthConfig,
+      hostedAuthSession,
+      setHostedAuthSession,
+      clearHostedAuthSession,
+      refreshHostedAuthSession
+    ]
+  );
+  return /* @__PURE__ */ jsxRuntime.jsx(PrivanaContext.Provider, { value, children: siweAuth ? /* @__PURE__ */ jsxRuntime.jsx(
+    SiweAuthProvider,
+    {
+      client,
+      networkConfig,
+      autoLogin: typeof siweAuth === "object" ? siweAuth.autoLogin : void 0,
+      children
+    }
+  ) : 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/browser-storage.ts
+function storageCandidate(name) {
+  try {
+    if (typeof window === "undefined") return void 0;
+    return window[name] ?? void 0;
+  } catch {
+    return void 0;
+  }
+}
+function storageCandidates() {
+  return [storageCandidate("localStorage"), storageCandidate("sessionStorage")].filter(
+    (storage) => storage !== void 0
+  );
+}
+function canUseBrowserStorage() {
+  const probeKey = "privana:storage-probe";
+  for (const storage of storageCandidates()) {
+    try {
+      storage.setItem(probeKey, "1");
+      storage.removeItem(probeKey);
+      return true;
+    } catch {
+    }
+  }
+  return false;
+}
+function setBrowserStorageItem(key, value) {
+  let stored = false;
+  for (const storage of storageCandidates()) {
+    try {
+      storage.setItem(key, value);
+      stored = true;
+    } catch {
+    }
+  }
+  return stored;
+}
+function getBrowserStorageItem(key) {
+  for (const storage of storageCandidates()) {
+    try {
+      const value = storage.getItem(key);
+      if (value !== null) return value;
+    } catch {
+    }
+  }
+  return null;
+}
+function removeBrowserStorageItem(key) {
+  for (const storage of storageCandidates()) {
+    try {
+      storage.removeItem(key);
+    } catch {
+    }
+  }
+}
+
+// src/sdk/hooks/pending-lock.ts
+var DEFAULT_LOCK_DURATION_SECONDS = 259200;
+var DEFAULT_ONRAMP_LOCK_BUFFER = 0.02;
+var BUFFER_SCALE = 1000000n;
+function applyLockBuffer(amount, buffer = DEFAULT_ONRAMP_LOCK_BUFFER) {
+  if (!Number.isFinite(buffer) || buffer < 0 || buffer >= 1) {
+    throw new Error(`Lock buffer must be in [0, 1), got ${buffer}`);
+  }
+  const shave = BigInt(Math.max(0, Math.ceil(buffer * Number(BUFFER_SCALE) - 1e-6)));
+  return amount * (BUFFER_SCALE - shave) / BUFFER_SCALE;
+}
+function clampLockAmount(amount, maxAmount) {
+  return maxAmount !== void 0 && maxAmount < amount ? maxAmount : amount;
+}
+async function createSignedLockRequest({
+  client,
+  walletClient,
+  userAddress,
+  networkConfig,
+  serviceAddress,
+  tokenId,
+  amount,
+  lockDuration = DEFAULT_LOCK_DURATION_SECONDS
+}) {
+  if (amount <= 0n) {
+    throw new Error("Lock amount must be positive");
+  }
+  const expiry = BigInt(Math.floor(Date.now() / 1e3) + lockDuration);
+  const { nonce } = await client.getLockNonce(userAddress);
+  const signature = await signLockMessage({
+    walletClient,
+    chainId: networkConfig.chainId,
+    verifyingContract: networkConfig.accountingContract,
+    message: {
+      serviceAddress,
+      tokenId,
+      amount,
+      expiry,
+      nonce: BigInt(nonce)
+    }
+  });
+  return {
+    service_address: serviceAddress,
+    token_id: tokenId,
+    amount: amount.toString(),
+    expiry: expiry.toString(),
+    nonce: String(nonce),
+    signature
+  };
+}
+var EXPIRY_SLACK_SECONDS = 60;
+function isSignedLockUsable(payload) {
+  const expiry = Number(payload.expiry);
+  if (!Number.isFinite(expiry)) return false;
+  return expiry > Math.floor(Date.now() / 1e3) + EXPIRY_SLACK_SECONDS;
+}
+var PostDepositLockError = class _PostDepositLockError extends Error {
+  constructor(message, reason, signedAmount, creditedAmount, options) {
+    super(message, options);
+    this.reason = reason;
+    this.signedAmount = signedAmount;
+    this.creditedAmount = creditedAmount;
+    this.name = "PostDepositLockError";
+    Object.setPrototypeOf(this, _PostDepositLockError.prototype);
+  }
+};
+async function submitPendingLock({
+  client,
+  payload,
+  creditedAmount
+}) {
+  let signedAmount;
+  try {
+    signedAmount = BigInt(payload.amount);
+  } catch (err) {
+    throw new PostDepositLockError(
+      "Stored signed lock payload is malformed",
+      "submission-failed",
+      void 0,
+      creditedAmount,
+      { cause: err }
+    );
+  }
+  if (!isSignedLockUsable(payload)) {
+    throw new PostDepositLockError(
+      "Signed lock expired before the deposit was credited",
+      "expired",
+      signedAmount,
+      creditedAmount
+    );
+  }
+  if (creditedAmount !== void 0 && creditedAmount < signedAmount) {
+    throw new PostDepositLockError(
+      `Credited amount (${creditedAmount}) is below the signed lock amount (${signedAmount})`,
+      "credited-below-signed",
+      signedAmount,
+      creditedAmount
+    );
+  }
+  try {
+    return await client.lockFunds(payload);
+  } catch (err) {
+    throw new PostDepositLockError(
+      err instanceof Error ? err.message : "Lock submission failed",
+      "submission-failed",
+      signedAmount,
+      creditedAmount,
+      { cause: err }
+    );
+  }
+}
+function pendingLockKey(userAddress, correlationId) {
+  return `privana:pending-lock:${userAddress.toLowerCase()}:${correlationId}`;
+}
+function savePendingLock(userAddress, correlationId, payload) {
+  const record = { payload, savedAt: Date.now() };
+  const stored = setBrowserStorageItem(
+    pendingLockKey(userAddress, correlationId),
+    JSON.stringify(record)
+  );
+  if (!stored) {
+    throw new Error("Unable to persist signed lock for recovery");
+  }
+}
+function loadPendingLock(userAddress, correlationId) {
+  const key = pendingLockKey(userAddress, correlationId);
+  try {
+    const raw = getBrowserStorageItem(key);
+    if (!raw) return void 0;
+    const record = JSON.parse(raw);
+    if (!record?.payload?.signature) {
+      removeBrowserStorageItem(key);
+      return void 0;
+    }
+    return record.payload;
+  } catch {
+    return void 0;
+  }
+}
+function clearPendingLock(userAddress, correlationId) {
+  removeBrowserStorageItem(pendingLockKey(userAddress, correlationId));
+}
+var INITIAL_AUTH_BACKOFF_MS = 5e3;
+var MAX_AUTH_BACKOFF_MS = 6e4;
+var DEFAULT_SIWE_AUTH_VALIDITY_MS = 24 * 60 * 60 * 1e3;
+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 clearPrivateReadScope(scopeKey, client) {
+  deleteCachedPrivateReadToken(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: networkConfig.chainId,
+              domain,
+              expirationTime,
+              issuedAt,
+              nonce: nonceResponse.nonce,
+              statement: buildSiweStatement(networkConfig.chainId),
+              uri,
+              version: "1"
+            });
+            const signature = await walletClient.signMessage({
+              account: walletClient.account ?? walletAddress,
+              message
+            });
+            const login = await client.loginWithSiwe({
+              siwe_message: message,
+              signature
+            });
+            setCachedPrivateReadToken(scopeKey, login.siwe_token, 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-deposit-verification.ts
+function useDepositVerification(options = {}) {
+  const { client } = usePrivanaContext();
+  const queryClient = reactQuery.useQueryClient();
+  const { executePrivateRead } = usePrivateReadRequest();
+  const pollInterval = options.pollInterval ?? 5e3;
+  const finalityRetryInterval = options.finalityRetryInterval ?? pollInterval;
+  const pollTimeout = options.pollTimeout ?? 18e4;
+  const [isVerifying, setIsVerifying] = react.useState(false);
+  const [didTimeout, setDidTimeout] = react.useState(false);
+  const [verificationFailed, setVerificationFailed] = react.useState(false);
+  const [error, setError] = react.useState(null);
+  const [txHash, setTxHash] = react.useState();
+  const generationRef = react.useRef(0);
+  const pollIntervalRef = react.useRef(null);
+  const verificationContextRef = react.useRef(null);
+  const onCreditedRef = react.useRef(options.onCredited);
+  const onCheckTimeoutRef = react.useRef(options.onCheckTimeout);
+  const onErrorRef = react.useRef(options.onError);
+  const onCheckRetryRef = react.useRef(options.onCheckRetry);
+  react.useEffect(() => {
+    onCreditedRef.current = options.onCredited;
+    onCheckTimeoutRef.current = options.onCheckTimeout;
+    onErrorRef.current = options.onError;
+    onCheckRetryRef.current = options.onCheckRetry;
+  }, [options.onCredited, options.onCheckTimeout, options.onError, options.onCheckRetry]);
+  const stopPolling = react.useCallback(() => {
+    if (pollIntervalRef.current) {
+      clearTimeout(pollIntervalRef.current);
+      pollIntervalRef.current = null;
+    }
+  }, []);
+  const invalidateGeneration = react.useCallback(() => {
+    generationRef.current++;
+  }, []);
+  react.useEffect(() => {
+    return () => {
+      invalidateGeneration();
+      stopPolling();
+    };
+  }, [invalidateGeneration, stopPolling]);
+  const runVerification = react.useCallback(
+    async (ctx, generation) => {
+      const isStale = () => generation !== generationRef.current;
+      const { hash, chainId, amount, logIndex } = ctx;
+      setVerificationFailed(false);
+      setError(null);
+      setDidTimeout(false);
+      setIsVerifying(true);
+      const pollStartTime = Date.now();
+      const markVerificationFailed = (err) => {
+        setIsVerifying(false);
+        setError(err);
+        setVerificationFailed(true);
+        onErrorRef.current?.(err);
+      };
+      const markVerificationTimedOut = () => {
+        stopPolling();
+        setIsVerifying(false);
+        setDidTimeout(true);
+        onCheckTimeoutRef.current?.(hash);
+        queryClient.invalidateQueries({ queryKey: ["accounting-balance"] });
+      };
+      try {
+        let triggerResult;
+        while (!triggerResult) {
+          if (isStale()) return;
+          try {
+            const result = await executePrivateRead(
+              () => client.checkDeposit({
+                chain_id: chainId,
+                tx_hash: hash,
+                amount: amount.toString(),
+                log_index: logIndex
+              })
+            );
+            if (result.status === "error" && isInsufficientFinalityMessage(result.detail)) {
+              if (result.detail) onCheckRetryRef.current?.(result.detail);
+              if (Date.now() - pollStartTime > pollTimeout) {
+                markVerificationTimedOut();
+                return;
+              }
+              await sleep(finalityRetryInterval);
+              if (isStale()) return;
+              continue;
+            }
+            triggerResult = result;
+          } catch (err) {
+            if (isStale()) return;
+            if (!isInsufficientFinalityError(err)) {
+              throw err;
+            }
+            const message = err instanceof AccountingApiError && err.detail ? err.detail : err instanceof Error ? err.message : String(err);
+            onCheckRetryRef.current?.(message);
+            if (Date.now() - pollStartTime > pollTimeout) {
+              markVerificationTimedOut();
+              return;
+            }
+            await sleep(finalityRetryInterval);
+            if (isStale()) return;
+          }
+        }
+        if (isStale()) return;
+        if (triggerResult.status === "credited") {
+          setIsVerifying(false);
+          verificationContextRef.current = null;
+          queryClient.invalidateQueries({ queryKey: ["accounting-balance"] });
+          queryClient.invalidateQueries({ queryKey: ["accounting-history"] });
+          onCreditedRef.current?.(hash, triggerResult);
+          return;
+        }
+        if (triggerResult.status === "error") {
+          markVerificationFailed(new Error(triggerResult.detail ?? "Deposit verification failed"));
+          return;
+        }
+        const depositId = triggerResult.deposit_id;
+        if (!depositId) {
+          markVerificationFailed(new Error("Deposit check did not return a deposit id"));
+          return;
+        }
+        let consecutiveFailures = 0;
+        const checkStatus = async () => {
+          if (isStale()) return true;
+          if (Date.now() - pollStartTime > pollTimeout) {
+            markVerificationTimedOut();
+            return true;
+          }
+          try {
+            const result = await executePrivateRead(() => client.getDepositStatus(depositId));
+            if (isStale()) return true;
+            consecutiveFailures = 0;
+            if (result.status === "credited") {
+              stopPolling();
+              setIsVerifying(false);
+              verificationContextRef.current = null;
+              queryClient.invalidateQueries({ queryKey: ["accounting-balance"] });
+              queryClient.invalidateQueries({ queryKey: ["accounting-history"] });
+              onCreditedRef.current?.(hash, result);
+              return true;
+            }
+            if (result.status === "error") {
+              stopPolling();
+              markVerificationFailed(new Error(result.detail ?? "Deposit verification failed"));
+              return true;
+            }
+          } catch (err) {
+            if (isStale()) return true;
+            consecutiveFailures++;
+            console.warn("Error polling deposit status:", err);
+            if (consecutiveFailures >= 3) {
+              stopPolling();
+              markVerificationFailed(
+                err instanceof Error ? err : new Error("Deposit status polling failed")
+              );
+              return true;
+            }
+          }
+          return false;
+        };
+        const pollLoop = async () => {
+          const done = await checkStatus();
+          if (!done && !isStale() && pollIntervalRef.current !== null) {
+            pollIntervalRef.current = setTimeout(pollLoop, pollInterval);
+          }
+        };
+        pollIntervalRef.current = setTimeout(pollLoop, pollInterval);
+      } catch (err) {
+        if (isStale()) return;
+        stopPolling();
+        markVerificationFailed(
+          err instanceof Error ? err : new Error("Deposit verification failed")
+        );
+      }
+    },
+    [
+      client,
+      executePrivateRead,
+      finalityRetryInterval,
+      pollInterval,
+      pollTimeout,
+      queryClient,
+      stopPolling
+    ]
+  );
+  const verify = react.useCallback(
+    async (ctx) => {
+      generationRef.current++;
+      stopPolling();
+      verificationContextRef.current = ctx;
+      setTxHash(ctx.hash);
+      const generation = generationRef.current;
+      await runVerification(ctx, generation);
+    },
+    [runVerification, stopPolling]
+  );
+  const retryVerification = react.useCallback(async () => {
+    const ctx = verificationContextRef.current;
+    if (!ctx) {
+      throw new Error("No pending verification to retry");
+    }
+    generationRef.current++;
+    stopPolling();
+    const generation = generationRef.current;
+    await runVerification(ctx, generation);
+  }, [runVerification, stopPolling]);
+  const reset = react.useCallback(() => {
+    generationRef.current++;
+    stopPolling();
+    verificationContextRef.current = null;
+    setTxHash(void 0);
+    setIsVerifying(false);
+    setDidTimeout(false);
+    setVerificationFailed(false);
+    setError(null);
+  }, [stopPolling]);
+  return {
+    isVerifying,
+    didTimeout,
+    verificationFailed,
+    error,
+    txHash,
+    verify,
+    retryVerification,
+    reset
+  };
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function isInsufficientFinalityError(error) {
+  if (error instanceof AccountingApiError) {
+    return isInsufficientFinalityMessage(error.detail) || isInsufficientFinalityMessage(error.message);
+  }
+  return error instanceof Error && isInsufficientFinalityMessage(error.message);
+}
+function isInsufficientFinalityMessage(message) {
+  return message?.includes("Insufficient finality") ?? false;
+}
+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`;
+}
+function formatCountdown(secondsLeft) {
+  const clamped = Math.max(0, secondsLeft);
+  const minutes = Math.floor(clamped / 60);
+  const seconds = clamped % 60;
+  return `${minutes}m:${String(seconds).padStart(2, "0")}s`;
+}
+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 Skeleton({ className, ...props }) {
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    "div",
+    {
+      "data-slot": "skeleton",
+      className: cn("bg-secondary animate-pulse rounded-md", className),
+      ...props
+    }
+  );
+}
+
+// ../../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/version.js
+var version = "3.3.1";
+
+// ../../node_modules/@wagmi/core/dist/esm/utils/getVersion.js
+var getVersion = () => `@wagmi/core@${version}`;
+
+// ../../node_modules/@wagmi/core/dist/esm/errors/base.js
+var __classPrivateFieldGet = function(receiver, state, kind, f) {
+  if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+  return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _BaseError_instances;
+var _BaseError_walk;
+var BaseError = class _BaseError extends Error {
+  get docsBaseUrl() {
+    return "https://wagmi.sh/core";
+  }
+  get version() {
+    return getVersion();
+  }
+  constructor(shortMessage, options = {}) {
+    super();
+    _BaseError_instances.add(this);
+    Object.defineProperty(this, "details", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    Object.defineProperty(this, "docsPath", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    Object.defineProperty(this, "metaMessages", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    Object.defineProperty(this, "shortMessage", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    Object.defineProperty(this, "name", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: "WagmiCoreError"
+    });
+    const details = options.cause instanceof _BaseError ? options.cause.details : options.cause?.message ? options.cause.message : options.details;
+    const docsPath = options.cause instanceof _BaseError ? options.cause.docsPath || options.docsPath : options.docsPath;
+    this.message = [
+      shortMessage || "An error occurred.",
+      "",
+      ...options.metaMessages ? [...options.metaMessages, ""] : [],
+      ...docsPath ? [
+        `Docs: ${this.docsBaseUrl}${docsPath}.html${options.docsSlug ? `#${options.docsSlug}` : ""}`
+      ] : [],
+      ...details ? [`Details: ${details}`] : [],
+      `Version: ${this.version}`
+    ].join("\n");
+    if (options.cause)
+      this.cause = options.cause;
+    this.details = details;
+    this.docsPath = docsPath;
+    this.metaMessages = options.metaMessages;
+    this.shortMessage = shortMessage;
+  }
+  walk(fn) {
+    return __classPrivateFieldGet(this, _BaseError_instances, "m", _BaseError_walk).call(this, this, fn);
+  }
+};
+_BaseError_instances = /* @__PURE__ */ new WeakSet(), _BaseError_walk = function _BaseError_walk2(err, fn) {
+  if (fn?.(err))
+    return err;
+  if (err.cause)
+    return __classPrivateFieldGet(this, _BaseError_instances, "m", _BaseError_walk2).call(this, err.cause, fn);
+  return err;
+};
+
+// ../../node_modules/@wagmi/core/dist/esm/errors/config.js
+var ConnectorNotConnectedError = class extends BaseError {
+  constructor() {
+    super("Connector not connected.");
+    Object.defineProperty(this, "name", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: "ConnectorNotConnectedError"
+    });
+  }
+};
+var ConnectorAccountNotFoundError = class extends BaseError {
+  constructor({ address, connector }) {
+    super(`Account "${address}" not found for connector "${connector.name}".`);
+    Object.defineProperty(this, "name", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: "ConnectorAccountNotFoundError"
+    });
+  }
+};
+var ConnectorChainMismatchError = class extends BaseError {
+  constructor({ connectionChainId, connectorChainId }) {
+    super(`The current chain of the connector (id: ${connectorChainId}) does not match the connection's chain (id: ${connectionChainId}).`, {
+      metaMessages: [
+        `Current Chain ID:  ${connectorChainId}`,
+        `Expected Chain ID: ${connectionChainId}`
+      ]
+    });
+    Object.defineProperty(this, "name", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: "ConnectorChainMismatchError"
+    });
+  }
+};
+var ConnectorUnavailableReconnectingError = class extends BaseError {
+  constructor({ connector }) {
+    super(`Connector "${connector.name}" unavailable while reconnecting.`, {
+      details: [
+        "During the reconnection step, the only connector methods guaranteed to be available are: `id`, `name`, `type`, `uid`.",
+        "All other methods are not guaranteed to be available until reconnection completes and connectors are fully restored.",
+        "This error commonly occurs for connectors that asynchronously inject after reconnection has already started."
+      ].join(" ")
+    });
+    Object.defineProperty(this, "name", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: "ConnectorUnavailableReconnectingError"
+    });
+  }
+};
+async function getConnectorClient(config, parameters = {}) {
+  const { assertChainId = true } = parameters;
+  let connection;
+  if (parameters.connector) {
+    const { connector: connector2 } = parameters;
+    if (config.state.status === "reconnecting" && !connector2.getAccounts && !connector2.getChainId)
+      throw new ConnectorUnavailableReconnectingError({ connector: connector2 });
+    const [accounts, chainId2] = await Promise.all([
+      connector2.getAccounts().catch((e) => {
+        if (parameters.account === null)
+          return [];
+        throw e;
+      }),
+      connector2.getChainId()
+    ]);
+    connection = {
+      accounts,
+      chainId: chainId2,
+      connector: connector2
+    };
+  } else
+    connection = config.state.connections.get(config.state.current);
+  if (!connection)
+    throw new ConnectorNotConnectedError();
+  const chainId = parameters.chainId ?? connection.chainId;
+  const connectorChainId = await connection.connector.getChainId();
+  if (assertChainId && connectorChainId !== chainId)
+    throw new ConnectorChainMismatchError({
+      connectionChainId: chainId,
+      connectorChainId
+    });
+  const connector = connection.connector;
+  if (connector.getClient)
+    return connector.getClient({ chainId });
+  const account = utils.parseAccount(parameters.account ?? connection.accounts[0]);
+  if (account)
+    account.address = utils.getAddress(account.address);
+  if (parameters.account && !connection.accounts.some((x) => x.toLowerCase() === account.address.toLowerCase()))
+    throw new ConnectorAccountNotFoundError({
+      address: account.address,
+      connector
+    });
+  const chain = config.chains.find((chain2) => chain2.id === chainId);
+  const provider = await connection.connector.getProvider({ chainId });
+  return viem.createClient({
+    account,
+    chain,
+    name: "Connector Client",
+    transport: (opts) => viem.custom(provider)({ ...opts, retryCount: 0 })
+  });
+}
+
+// ../../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 getWalletClient3(config, parameters = {}) {
+  const client = await getConnectorClient(config, parameters);
+  return client.extend(viem.walletActions);
+}
+async function waitForTransactionReceipt(config, parameters) {
+  const { chainId, timeout = 0, ...rest } = parameters;
+  const client = config.getClient({ chainId });
+  const action = getAction(client, actions$1.waitForTransactionReceipt, "waitForTransactionReceipt");
+  const receipt = await action({ ...rest, timeout });
+  if (receipt.status === "reverted") {
+    const action_getTransaction = getAction(client, actions$1.getTransaction, "getTransaction");
+    const { from: account, ...txn } = await action_getTransaction({
+      hash: receipt.transactionHash
+    });
+    const action_call = getAction(client, actions$1.call, "call");
+    const code = await action_call({
+      ...txn,
+      account,
+      data: txn.input,
+      gasPrice: txn.type !== "eip1559" ? txn.gasPrice : void 0,
+      maxFeePerGas: txn.type === "eip1559" ? txn.maxFeePerGas : void 0,
+      maxPriorityFeePerGas: txn.type === "eip1559" ? txn.maxPriorityFeePerGas : void 0
+    });
+    const reason = code?.data ? viem.hexToString(`0x${code.data.substring(138)}`) : "unknown reason";
+    throw new Error(reason);
+  }
+  return {
+    ...receipt,
+    chainId: client.chain.id
+  };
+}
+function useEnsureCorrectChain() {
+  const config = wagmi.useConfig();
+  const chainId = wagmi.useChainId();
+  const { switchChainAsync } = wagmi.useSwitchChain();
+  const waitUntilOnChain = react.useCallback(
+    async (expectedChainId, timeoutMs, pollIntervalMs = 250) => {
+      const startedAt = Date.now();
+      while (Date.now() - startedAt < timeoutMs) {
+        const currentChainId = getChainId2(config);
+        if (currentChainId === expectedChainId) return true;
+        await new Promise((resolve) => setTimeout(resolve, pollIntervalMs));
+      }
+      return false;
+    },
+    [config]
+  );
+  const ensureCorrectChain = react.useCallback(
+    async (targetChainId) => {
+      const currentChainId = getChainId2(config);
+      if (currentChainId === targetChainId) return false;
+      let switchErrorMessage;
+      try {
+        const timeoutPromise = new Promise((_, reject) => {
+          setTimeout(() => reject(new Error("Chain switch timeout")), 3e3);
+        });
+        await Promise.race([switchChainAsync({ chainId: targetChainId }), timeoutPromise]);
+      } catch (error) {
+        if (error instanceof Error && error.message.includes("Unsupported Chain")) {
+          console.warn("Got 'Unsupported Chain' error, chain may have switched anyway.");
+        } else {
+          switchErrorMessage = error instanceof Error ? error.message : "Unknown chain switch error";
+        }
+      }
+      const settled = await waitUntilOnChain(targetChainId, 2e4);
+      if (settled) return true;
+      if (switchErrorMessage) {
+        throw new Error(
+          `Failed to switch to chain (Chain ID: ${targetChainId}): ${switchErrorMessage}`
+        );
+      }
+      throw new Error(`Chain switch did not settle in time (expected ${targetChainId}).`);
+    },
+    [config, switchChainAsync, waitUntilOnChain]
+  );
+  const isOnChain = react.useCallback((targetChainId) => chainId === targetChainId, [chainId]);
+  return {
+    chainId,
+    ensureCorrectChain,
+    isOnChain
+  };
+}
+
+// src/sdk/hooks/use-fiat-on-ramp.ts
+var DEFAULT_DELIVERY_TIMEOUT_MS = 12e4;
+var DEFAULT_VERIFICATION_TIMEOUT_MS = 10 * 6e4;
+var DEFAULT_FINALITY_RETRY_INTERVAL_MS = 15e3;
+var ERC20_TRANSFER_EVENT = viem.parseAbiItem(
+  "event Transfer(address indexed from, address indexed to, uint256 value)"
+);
+function useFiatOnRamp(options) {
+  const {
+    tokenId,
+    postDepositLock,
+    onCredited,
+    onLockSubmitted,
+    onLockFailed,
+    onError,
+    onDebugEvent
+  } = options;
+  const deliveryTimeout = options.deliveryTimeout ?? DEFAULT_DELIVERY_TIMEOUT_MS;
+  const deliveryPollInterval = options.deliveryPollInterval ?? 3e3;
+  const verificationTimeout = options.verificationTimeout ?? DEFAULT_VERIFICATION_TIMEOUT_MS;
+  const finalityRetryInterval = options.finalityRetryInterval ?? DEFAULT_FINALITY_RETRY_INTERVAL_MS;
+  const { address } = wagmi.useAccount();
+  const { data: walletClient } = wagmi.useWalletClient();
+  const { client, enabledTokens, networkConfig, serviceAddress } = usePrivanaContext();
+  const { executePrivateRead, privateReadReady } = usePrivateReadRequest();
+  const { ensureCorrectChain } = useEnsureCorrectChain();
+  const wagmiConfig = wagmi.useConfig();
+  const queryClient = reactQuery.useQueryClient();
+  const selectedToken = enabledTokens.find((t) => t.id.toLowerCase() === tokenId.toLowerCase());
+  const [status, setStatus] = react.useState("idle");
+  const [pending, setPending] = react.useState([]);
+  const [error, setError] = react.useState(null);
+  const [depositAddress, setDepositAddress] = react.useState();
+  const [minDepositBaseUnits, setMinDepositBaseUnits] = react.useState();
+  const [activeIntentId, setActiveIntentId] = react.useState(null);
+  const [activeVerificationId, setActiveVerificationId] = react.useState(null);
+  const [finalityProgress, setFinalityProgress] = react.useState({});
+  const onCreditedRef = react.useRef(onCredited);
+  const onLockSubmittedRef = react.useRef(onLockSubmitted);
+  const onLockFailedRef = react.useRef(onLockFailed);
+  const onErrorRef = react.useRef(onError);
+  const onDebugEventRef = react.useRef(onDebugEvent);
+  const statusRef = react.useRef(status);
+  const activeIntentIdRef = react.useRef(null);
+  const activeVerificationRecordRef = react.useRef(null);
+  const activeVerificationKeyRef = react.useRef(null);
+  const activeVerificationAmountRef = react.useRef(null);
+  const lockOwnerRef = react.useRef(null);
+  const triggeredVerificationKeysRef = react.useRef(/* @__PURE__ */ new Set());
+  const activeVerificationDoneRef = react.useRef(null);
+  const closeReconcilePromiseRef = react.useRef(null);
+  const purchaseInitiatedRef = react.useRef(false);
+  react.useEffect(() => {
+    onCreditedRef.current = onCredited;
+    onLockSubmittedRef.current = onLockSubmitted;
+    onLockFailedRef.current = onLockFailed;
+    onErrorRef.current = onError;
+    onDebugEventRef.current = onDebugEvent;
+  }, [onCredited, onLockSubmitted, onLockFailed, onError, onDebugEvent]);
+  react.useEffect(() => {
+    statusRef.current = status;
+  }, [status]);
+  react.useEffect(() => {
+    activeIntentIdRef.current = activeIntentId;
+  }, [activeIntentId]);
+  react.useEffect(() => {
+    activeIntentIdRef.current = null;
+    setActiveIntentId(null);
+  }, [tokenId]);
+  const emitDebug = react.useCallback(
+    (event, payload) => {
+      onDebugEventRef.current?.({
+        at: (/* @__PURE__ */ new Date()).toISOString(),
+        event,
+        status: statusRef.current,
+        tokenId,
+        payload
+      });
+    },
+    [tokenId]
+  );
+  react.useEffect(() => {
+    emitDebug("private-read-state", { privateReadReady });
+  }, [emitDebug, privateReadReady]);
+  react.useEffect(() => {
+    if (!privateReadReady) {
+      emitDebug("deposit-address:skip", { reason: "private-read-not-ready" });
+      setDepositAddress(void 0);
+      setMinDepositBaseUnits(void 0);
+      return;
+    }
+    let cancelled = false;
+    void (async () => {
+      try {
+        emitDebug("deposit-address:request");
+        const resp = await executePrivateRead(() => client.getDepositAddress());
+        if (cancelled) return;
+        setDepositAddress(resp.deposit_address);
+        const token = enabledTokens.find((t) => t.id.toLowerCase() === tokenId.toLowerCase());
+        const mins = token ? resp.min_deposit?.[String(token.chainId)] : void 0;
+        if (mins?.erc20) setMinDepositBaseUnits(BigInt(mins.erc20));
+        emitDebug("deposit-address:success", {
+          depositAddress: resp.deposit_address,
+          selectedToken: token ? summariseToken(token) : null,
+          minDepositBaseUnits: mins?.erc20 ?? null
+        });
+      } catch (err) {
+        if (!cancelled) {
+          emitDebug("deposit-address:error", errorPayload(err));
+          console.warn("Failed to fetch Privana deposit address:", err);
+        }
+      }
+    })();
+    return () => {
+      cancelled = true;
+    };
+  }, [client, emitDebug, enabledTokens, executePrivateRead, privateReadReady, tokenId]);
+  const refreshPending = react.useCallback(async () => {
+    if (!privateReadReady) {
+      emitDebug("pending:skip", { reason: "private-read-not-ready" });
+      setPending([]);
+      return;
+    }
+    try {
+      emitDebug("pending:request");
+      const { pending: rows } = await executePrivateRead(() => client.getPendingOnRamps());
+      setPending(rows);
+      emitDebug("pending:success", {
+        count: rows.length,
+        rows: rows.map(summariseOnRampRecord)
+      });
+    } catch (err) {
+      emitDebug("pending:error", errorPayload(err));
+      console.warn("Failed to load pending on-ramps:", err);
+    }
+  }, [client, emitDebug, executePrivateRead, privateReadReady]);
+  react.useEffect(() => {
+    refreshPending();
+  }, [refreshPending]);
+  const clearActiveVerification = react.useCallback((expectedKey) => {
+    const key = activeVerificationKeyRef.current;
+    if (expectedKey != null && key !== null && key !== expectedKey) return;
+    if (key) triggeredVerificationKeysRef.current.delete(key);
+    activeVerificationKeyRef.current = null;
+    activeVerificationRecordRef.current = null;
+    activeVerificationAmountRef.current = null;
+    setActiveVerificationId(null);
+    activeVerificationDoneRef.current?.();
+    activeVerificationDoneRef.current = null;
+  }, []);
+  const submitPendingLockAfterCredit = react.useCallback(
+    async (transactionId, userAddress) => {
+      const signedLock = loadPendingLock(userAddress, transactionId);
+      if (!signedLock) {
+        clearPendingLock(userAddress, transactionId);
+        if (!postDepositLock || transactionId !== activeIntentIdRef.current) return;
+        const error2 = new PostDepositLockError(
+          "No persisted signed lock found for this on-ramp",
+          "not-found"
+        );
+        emitDebug("lock:not-found", { transactionId });
+        (onLockFailedRef.current ?? onErrorRef.current)?.(error2);
+        return;
+      }
+      const creditedAmount = activeVerificationAmountRef.current ?? void 0;
+      try {
+        const result = await submitPendingLock({ client, payload: signedLock, creditedAmount });
+        queryClient.invalidateQueries({ queryKey: ["accounting-balance"] });
+        queryClient.invalidateQueries({ queryKey: ["accounting-locked-funds"] });
+        queryClient.invalidateQueries({ queryKey: ["accounting-total-locked-balance"] });
+        queryClient.invalidateQueries({ queryKey: ["accounting-history"] });
+        emitDebug("lock:submitted", {
+          transactionId,
+          amount: signedLock.amount,
+          submissionId: result.submission_id
+        });
+        onLockSubmittedRef.current?.(result);
+      } catch (err) {
+        const error2 = err instanceof PostDepositLockError ? err : new PostDepositLockError(
+          err instanceof Error ? err.message : "Lock submission failed",
+          "submission-failed",
+          BigInt(signedLock.amount),
+          creditedAmount,
+          { cause: err }
+        );
+        emitDebug("lock:failed", {
+          transactionId,
+          reason: error2.reason,
+          message: error2.message
+        });
+        (onLockFailedRef.current ?? onErrorRef.current)?.(error2);
+      } finally {
+        clearPendingLock(userAddress, transactionId);
+      }
+    },
+    [client, emitDebug, postDepositLock, queryClient]
+  );
+  const { verify } = useDepositVerification({
+    pollTimeout: verificationTimeout,
+    pollInterval: options.verificationPollInterval,
+    finalityRetryInterval,
+    onCheckRetry: (message) => {
+      const record = activeVerificationRecordRef.current;
+      if (!record) return;
+      emitDebug("verification:check-retry", {
+        message,
+        record: summariseOnRampRecord(record)
+      });
+      setFinalityProgress((prev) => ({ ...prev, [record.transaction_id]: message }));
+    },
+    onCredited: (depositTxHash) => {
+      const record = activeVerificationRecordRef.current;
+      const verificationKey = record ? getOnRampVerificationKey(record) : null;
+      emitDebug("verification:credited", {
+        depositTxHash,
+        record: record ? summariseOnRampRecord(record) : null
+      });
+      if (record && activeIntentIdRef.current === record.transaction_id) {
+        setStatus("credited");
+      }
+      if (record) {
+        setFinalityProgress((prev) => {
+          if (!(record.transaction_id in prev)) return prev;
+          const next = { ...prev };
+          delete next[record.transaction_id];
+          return next;
+        });
+        const lockOwner = lockOwnerRef.current ?? address;
+        if (lockOwner) {
+          void submitPendingLockAfterCredit(record.transaction_id, lockOwner);
+        } else if (postDepositLock) {
+          emitDebug("lock:owner-unavailable", { transactionId: record.transaction_id });
+          (onLockFailedRef.current ?? onErrorRef.current)?.(
+            new PostDepositLockError(
+              "No wallet address available to look up the signed lock for this on-ramp",
+              "not-found"
+            )
+          );
+        }
+      }
+      void (async () => {
+        try {
+          if (record && depositTxHash.startsWith("0x")) {
+            emitDebug("onramp:mark-deposit-triggered-request", {
+              transactionId: record.transaction_id,
+              depositTxHash
+            });
+            const updated = await executePrivateRead(
+              () => client.updateOnRamp(record.transaction_id, {
+                deposit_tx_hash: depositTxHash
+              })
+            );
+            emitDebug("onramp:mark-deposit-triggered-success", {
+              record: summariseOnRampRecord(updated)
+            });
+          }
+        } catch (err) {
+          emitDebug("onramp:mark-deposit-triggered-error", errorPayload(err));
+          console.warn("Failed to mark on-ramp row complete:", err);
+        } finally {
+          await refreshPending();
+          clearActiveVerification(verificationKey);
+          if (record && activeIntentIdRef.current === record.transaction_id) {
+            activeIntentIdRef.current = null;
+            setActiveIntentId(null);
+          }
+        }
+      })();
+      onCreditedRef.current?.(depositTxHash);
+    },
+    onCheckTimeout: (depositTxHash) => {
+      const record = activeVerificationRecordRef.current;
+      const err = new Error(
+        "Privana verification is still pending. Retry from the pending on-ramp list if it does not complete."
+      );
+      emitDebug("verification:timeout", { depositTxHash, message: err.message });
+      clearActiveVerification();
+      if (!record || activeIntentIdRef.current === record.transaction_id) {
+        setStatus("failed");
+        setError(err);
+      }
+      void refreshPending();
+      onErrorRef.current?.(err);
+    },
+    onError: (err) => {
+      const record = activeVerificationRecordRef.current;
+      emitDebug("verification:error", errorPayload(err));
+      clearActiveVerification();
+      if (!record || activeIntentIdRef.current === record.transaction_id) {
+        setStatus("failed");
+        setError(err);
+      }
+      onErrorRef.current?.(err);
+    }
+  });
+  const prepareOnRampIntent = react.useCallback(
+    async ({
+      currencyCode,
+      baseCurrencyCode,
+      baseCurrencyAmount,
+      quoteCurrencyAmount
+    }) => {
+      try {
+        setError(null);
+        purchaseInitiatedRef.current = false;
+        const token = enabledTokens.find((t) => t.id.toLowerCase() === tokenId.toLowerCase());
+        if (!token) throw new Error(`Unknown token: ${tokenId}`);
+        if (!depositAddress) throw new Error("Privana deposit address is not ready");
+        let lockAmount;
+        if (postDepositLock) {
+          if (!address || !walletClient) throw new Error("Wallet not connected");
+          if (!quoteCurrencyAmount) {
+            throw new Error(
+              "postDepositLock requires quoteCurrencyAmount to derive the lock amount"
+            );
+          }
+          if (!canUseBrowserStorage()) {
+            throw new Error("Browser storage is required for locked on-ramp recovery");
+          }
+          const buffered = applyLockBuffer(
+            viem.parseUnits(quoteCurrencyAmount, token.decimals),
+            postDepositLock.buffer
+          );
+          lockAmount = clampLockAmount(buffered, postDepositLock.maxAmount);
+          if (lockAmount <= 0n) {
+            throw new Error(`Post-deposit lock amount must be positive, got ${lockAmount}`);
+          }
+          await ensureCorrectChain(networkConfig.chainId);
+        }
+        emitDebug("intent:create-request", {
+          tokenId,
+          chainId: token.chainId,
+          currencyCode,
+          baseCurrencyCode: baseCurrencyCode ?? null,
+          baseCurrencyAmount: baseCurrencyAmount ?? null,
+          quoteCurrencyAmount: quoteCurrencyAmount ?? null,
+          depositAddress
+        });
+        const record = await executePrivateRead(
+          () => client.createOnRampIntent({
+            wallet_address: depositAddress,
+            token_id: tokenId,
+            chain_id: token.chainId,
+            moonpay_currency_code: currencyCode,
+            base_currency_code: baseCurrencyCode,
+            base_currency_amount: baseCurrencyAmount
+          })
+        );
+        if (postDepositLock && address && walletClient && lockAmount !== void 0) {
+          const signingWalletClient = await getWalletClient3(wagmiConfig, {
+            chainId: networkConfig.chainId
+          });
+          const signedLock = await createSignedLockRequest({
+            client,
+            walletClient: signingWalletClient,
+            userAddress: address,
+            networkConfig,
+            serviceAddress: requireServiceAddress(postDepositLock.serviceAddress ?? serviceAddress),
+            tokenId,
+            amount: lockAmount,
+            lockDuration: postDepositLock.lockDuration
+          });
+          savePendingLock(address, record.transaction_id, signedLock);
+          lockOwnerRef.current = address;
+          emitDebug("intent:lock-signed", {
+            transactionId: record.transaction_id,
+            amount: signedLock.amount,
+            expiry: signedLock.expiry
+          });
+        }
+        activeIntentIdRef.current = record.transaction_id;
+        setActiveIntentId(record.transaction_id);
+        emitDebug("intent:create-success", {
+          record: summariseOnRampRecord(record)
+        });
+        return record;
+      } catch (err) {
+        const e = err instanceof Error ? err : new Error("Failed to create on-ramp intent");
+        setStatus("failed");
+        setError(e);
+        emitDebug("intent:create-error", errorPayload(e));
+        onErrorRef.current?.(e);
+        throw e;
+      }
+    },
+    [
+      address,
+      client,
+      depositAddress,
+      emitDebug,
+      enabledTokens,
+      ensureCorrectChain,
+      executePrivateRead,
+      networkConfig,
+      postDepositLock,
+      serviceAddress,
+      tokenId,
+      wagmiConfig,
+      walletClient
+    ]
+  );
+  const registerOnRampTokenMapping = react.useCallback(
+    async (moonpayTransactionId) => {
+      const token = enabledTokens.find((t) => t.id.toLowerCase() === tokenId.toLowerCase());
+      if (!token) {
+        emitDebug("register-token-mapping:skip", {
+          moonpayTransactionId,
+          reason: "selected-token-not-found"
+        });
+        return;
+      }
+      const transactionId = activeIntentIdRef.current ?? moonpayTransactionId;
+      try {
+        emitDebug("register-token-mapping:request", {
+          transactionId,
+          moonpayTransactionId,
+          tokenId,
+          chainId: token.chainId
+        });
+        const record = await executePrivateRead(
+          () => client.updateOnRamp(transactionId, {
+            token_id: tokenId,
+            chain_id: token.chainId,
+            moonpay_transaction_id: transactionId === moonpayTransactionId ? void 0 : moonpayTransactionId
+          })
+        );
+        emitDebug("register-token-mapping:success", {
+          transactionId,
+          moonpayTransactionId,
+          record: summariseOnRampRecord(record)
+        });
+      } catch (err) {
+        emitDebug("register-token-mapping:error", {
+          transactionId,
+          moonpayTransactionId,
+          ...errorPayload(err)
+        });
+        console.warn("Failed to register on-ramp token mapping:", err);
+      }
+    },
+    [client, emitDebug, enabledTokens, executePrivateRead, tokenId]
+  );
+  const handleTransactionCreated = react.useCallback(
+    async (props) => {
+      emitDebug("moonpay:onTransactionCreated", summariseMoonPayEventProps(props));
+      purchaseInitiatedRef.current = true;
+      await registerOnRampTokenMapping(props.id);
+    },
+    [emitDebug, registerOnRampTokenMapping]
+  );
+  const signUrl = react.useCallback(
+    async (url) => {
+      setError(null);
+      try {
+        emitDebug("moonpay:onUrlSignatureRequested", summariseMoonPayUrl(url));
+        const { signature } = await executePrivateRead(() => client.signOnRampUrl({ url }));
+        setStatus("awaiting-purchase");
+        emitDebug("sign-url:success", {
+          signatureLength: signature.length
+        });
+        return signature;
+      } catch (err) {
+        const e = err instanceof Error ? err : new Error("Failed to sign on-ramp URL");
+        setStatus("failed");
+        setError(e);
+        emitDebug("sign-url:error", errorPayload(e));
+        onErrorRef.current?.(e);
+        throw err;
+      }
+    },
+    [client, emitDebug, executePrivateRead]
+  );
+  const waitForOnChainHash = react.useCallback(
+    async (transactionId) => {
+      const startTime = Date.now();
+      emitDebug("delivery-poll:start", {
+        transactionId,
+        deliveryTimeout,
+        deliveryPollInterval
+      });
+      while (Date.now() - startTime < deliveryTimeout) {
+        try {
+          const { pending: rows } = await executePrivateRead(() => client.getPendingOnRamps());
+          setPending(rows);
+          const record = rows.find((r) => matchesOnRampTransaction(r, transactionId));
+          emitDebug("delivery-poll:tick", {
+            transactionId,
+            count: rows.length,
+            matchingRecord: record ? summariseOnRampRecord(record) : null
+          });
+          if (record?.on_chain_tx_hash && record.quote_currency_amount) {
+            emitDebug("delivery-poll:success", {
+              transactionId,
+              record: summariseOnRampRecord(record)
+            });
+            return record;
+          }
+        } catch (err) {
+          emitDebug("delivery-poll:error", {
+            transactionId,
+            ...errorPayload(err)
+          });
+          console.warn("Polling pending on-ramps failed:", err);
+        }
+        await new Promise((r) => setTimeout(r, deliveryPollInterval));
+      }
+      emitDebug("delivery-poll:timeout", { transactionId });
+      return null;
+    },
+    [client, deliveryPollInterval, deliveryTimeout, emitDebug, executePrivateRead]
+  );
+  const triggerVerification = react.useCallback(
+    async (record) => {
+      const verificationKey = getOnRampVerificationKey(record);
+      if (triggeredVerificationKeysRef.current.has(verificationKey)) {
+        emitDebug("verification:skip-duplicate", {
+          verificationKey,
+          record: summariseOnRampRecord(record)
+        });
+        return;
+      }
+      const supersededKey = activeVerificationKeyRef.current;
+      if (supersededKey && supersededKey !== verificationKey) {
+        triggeredVerificationKeysRef.current.delete(supersededKey);
+      }
+      activeVerificationDoneRef.current?.();
+      activeVerificationDoneRef.current = null;
+      triggeredVerificationKeysRef.current.add(verificationKey);
+      activeVerificationKeyRef.current = verificationKey;
+      activeVerificationRecordRef.current = record;
+      setActiveVerificationId(record.transaction_id);
+      setFinalityProgress((prev) => {
+        if (!(record.transaction_id in prev)) return prev;
+        const next = { ...prev };
+        delete next[record.transaction_id];
+        return next;
+      });
+      emitDebug("verification:start", {
+        verificationKey,
+        record: summariseOnRampRecord(record)
+      });
+      try {
+        if (!record.on_chain_tx_hash || !record.quote_currency_amount) {
+          throw new Error("On-ramp record missing on-chain tx hash or delivered amount");
+        }
+        if (record.chain_id === void 0 || !record.wallet_address) {
+          throw new Error("On-ramp record missing chain id or wallet address");
+        }
+        const recordTokenId = record.token_id;
+        if (!recordTokenId) {
+          throw new Error("On-ramp record missing token id");
+        }
+        const token = enabledTokens.find((t) => t.id.toLowerCase() === recordTokenId.toLowerCase());
+        if (!token) throw new Error(`Unknown token: ${recordTokenId}`);
+        if (token.chainId !== record.chain_id) {
+          throw new Error(
+            `Token ${recordTokenId} is on chain ${token.chainId} but record is on chain ${record.chain_id}`
+          );
+        }
+        const amount = await resolveDeliveredAmount({
+          onChainTxHash: record.on_chain_tx_hash,
+          chainId: record.chain_id,
+          walletAddress: record.wallet_address,
+          token,
+          fallbackAmount: record.quote_currency_amount,
+          wagmiConfig,
+          emitDebug
+        });
+        if (minDepositBaseUnits !== void 0 && amount < minDepositBaseUnits) {
+          emitDebug("verification:below-minimum", {
+            quoteCurrencyAmount: record.quote_currency_amount,
+            minDepositBaseUnits: String(minDepositBaseUnits)
+          });
+          throw new Error(
+            `Delivered amount (${record.quote_currency_amount}) is below the minimum deposit.`
+          );
+        }
+        activeVerificationAmountRef.current = amount;
+        if (activeIntentIdRef.current === record.transaction_id) {
+          setStatus("verifying");
+        }
+        emitDebug("verification:check-deposit-request", {
+          hash: record.on_chain_tx_hash,
+          chainId: record.chain_id,
+          amount: amount.toString()
+        });
+        await verify({
+          hash: record.on_chain_tx_hash,
+          chainId: record.chain_id,
+          amount
+        });
+      } catch (err) {
+        triggeredVerificationKeysRef.current.delete(verificationKey);
+        if (activeVerificationKeyRef.current === verificationKey) {
+          activeVerificationKeyRef.current = null;
+          activeVerificationRecordRef.current = null;
+          activeVerificationAmountRef.current = null;
+          setActiveVerificationId(null);
+        }
+        throw err;
+      }
+    },
+    [emitDebug, enabledTokens, minDepositBaseUnits, verify, wagmiConfig]
+  );
+  const handleTransactionCompleted = react.useCallback(
+    async (props) => {
+      emitDebug("moonpay:onTransactionCompleted", summariseMoonPayEventProps(props));
+      try {
+        setStatus("awaiting-delivery");
+        await registerOnRampTokenMapping(props.id);
+        const transactionId = activeIntentIdRef.current ?? props.id;
+        const record = await waitForOnChainHash(transactionId);
+        if (!record) {
+          const err = new Error(
+            "Backend has not yet confirmed delivery. You can finish from the pending list."
+          );
+          emitDebug("moonpay:completed-without-backend-row", {
+            transactionId,
+            moonpayTransactionId: props.id,
+            message: err.message
+          });
+          setStatus("failed");
+          setError(err);
+          onErrorRef.current?.(err);
+          return;
+        }
+        await triggerVerification(record);
+      } catch (err) {
+        const e = err instanceof Error ? err : new Error("Verification failed");
+        emitDebug("moonpay:onTransactionCompleted-error", errorPayload(e));
+        setStatus("failed");
+        setError(e);
+        onErrorRef.current?.(e);
+      }
+    },
+    [emitDebug, registerOnRampTokenMapping, triggerVerification, waitForOnChainHash]
+  );
+  const handleWidgetClosed = react.useCallback(async () => {
+    if (closeReconcilePromiseRef.current) return closeReconcilePromiseRef.current;
+    closeReconcilePromiseRef.current = (async () => {
+      const previousStatus = statusRef.current;
+      const transactionId = activeIntentIdRef.current;
+      emitDebug("moonpay:widget-closed-reconcile", {
+        previousStatus,
+        transactionId
+      });
+      if (!transactionId) {
+        await refreshPending();
+        return;
+      }
+      if (!purchaseInitiatedRef.current) {
+        emitDebug("moonpay:widget-closed-without-purchase", {
+          previousStatus,
+          transactionId
+        });
+        if (address) clearPendingLock(address, transactionId);
+        await refreshPending();
+        if (previousStatus === "awaiting-purchase" || previousStatus === "awaiting-delivery") {
+          setStatus("idle");
+        }
+        return;
+      }
+      try {
+        setStatus("awaiting-delivery");
+        const record = await waitForOnChainHash(transactionId);
+        if (record) {
+          await triggerVerification(record);
+          return;
+        }
+        await refreshPending();
+        if (previousStatus === "awaiting-purchase" || previousStatus === "awaiting-delivery") {
+          setStatus("idle");
+        }
+      } catch (err) {
+        const e = err instanceof Error ? err : new Error("On-ramp reconciliation failed");
+        emitDebug("moonpay:widget-closed-reconcile-error", errorPayload(e));
+        setStatus("failed");
+        setError(e);
+        onErrorRef.current?.(e);
+      }
+    })();
+    try {
+      await closeReconcilePromiseRef.current;
+    } finally {
+      closeReconcilePromiseRef.current = null;
+    }
+  }, [address, emitDebug, refreshPending, triggerVerification, waitForOnChainHash]);
+  const finishPendingVerification = react.useCallback(
+    async (record) => {
+      try {
+        emitDebug("pending:finish-verification", {
+          record: summariseOnRampRecord(record)
+        });
+        await triggerVerification(record);
+      } catch (err) {
+        const e = err instanceof Error ? err : new Error("Verification failed");
+        emitDebug("pending:finish-verification-error", errorPayload(e));
+        setStatus("failed");
+        setError(e);
+        onErrorRef.current?.(e);
+        throw e;
+      }
+    },
+    [emitDebug, triggerVerification]
+  );
+  const triggerVerificationRef = react.useRef(triggerVerification);
+  react.useEffect(() => {
+    triggerVerificationRef.current = triggerVerification;
+  }, [triggerVerification]);
+  react.useEffect(() => {
+    let cancelled = false;
+    void (async () => {
+      for (const record of pending) {
+        if (cancelled) break;
+        if (!record.on_chain_tx_hash || !record.quote_currency_amount) continue;
+        const key = getOnRampVerificationKey(record);
+        if (triggeredVerificationKeysRef.current.has(key)) continue;
+        try {
+          await triggerVerificationRef.current(record);
+        } catch {
+          continue;
+        }
+        if (activeVerificationKeyRef.current === key) {
+          await new Promise((resolve) => {
+            activeVerificationDoneRef.current = resolve;
+          });
+        }
+      }
+    })();
+    return () => {
+      cancelled = true;
+    };
+  }, [pending]);
+  return {
+    status,
+    activeIntentId,
+    pending,
+    activeVerificationId,
+    error,
+    finalityProgress,
+    depositAddress,
+    minDepositBaseUnits,
+    selectedToken,
+    prepareOnRampIntent,
+    signUrl,
+    handleTransactionCreated,
+    handleTransactionCompleted,
+    finishPendingVerification,
+    handleWidgetClosed,
+    refreshPending
+  };
+}
+function summariseToken(token) {
+  return {
+    tokenId: token.id,
+    chainId: token.chainId,
+    symbol: token.symbol ?? null,
+    decimals: token.decimals ?? null
+  };
+}
+function summariseOnRampRecord(record) {
+  return {
+    transaction_id: record.transaction_id,
+    external_transaction_id: record.external_transaction_id ?? null,
+    moonpay_transaction_id: record.moonpay_transaction_id ?? null,
+    status: record.status,
+    wallet_address: record.wallet_address,
+    token_id: record.token_id,
+    chain_id: record.chain_id,
+    moonpay_currency_code: record.moonpay_currency_code ?? null,
+    quote_currency_amount: record.quote_currency_amount ?? null,
+    on_chain_tx_hash: record.on_chain_tx_hash ?? null,
+    deposit_tx_hash: record.deposit_tx_hash ?? null,
+    deposit_triggered_at: record.deposit_triggered_at ?? null,
+    credited_at: record.credited_at ?? null
+  };
+}
+async function resolveDeliveredAmount({
+  onChainTxHash,
+  chainId,
+  walletAddress,
+  token,
+  fallbackAmount,
+  wagmiConfig,
+  emitDebug
+}) {
+  if (token.contract === viem.zeroAddress) {
+    return viem.parseUnits(fallbackAmount, token.decimals);
+  }
+  let receiptError;
+  try {
+    const receipt = await waitForTransactionReceipt(wagmiConfig, {
+      hash: onChainTxHash,
+      chainId,
+      timeout: 6e4,
+      pollingInterval: 4e3
+    });
+    let delivered = 0n;
+    for (const log of receipt.logs) {
+      if (log.address.toLowerCase() !== token.contract.toLowerCase()) continue;
+      try {
+        const decoded = viem.decodeEventLog({
+          abi: [ERC20_TRANSFER_EVENT],
+          data: log.data,
+          topics: log.topics
+        });
+        if (decoded.eventName !== "Transfer") continue;
+        const to = decoded.args.to.toLowerCase();
+        if (to !== walletAddress.toLowerCase()) continue;
+        delivered += decoded.args.value;
+      } catch {
+      }
+    }
+    if (delivered > 0n) {
+      emitDebug("verification:amount-from-receipt", {
+        amount: delivered.toString(),
+        tokenAddress: token.contract,
+        walletAddress,
+        moonpayQuoteCurrencyAmount: fallbackAmount
+      });
+      return delivered;
+    }
+    emitDebug("verification:amount-from-receipt-missing", {
+      tokenAddress: token.contract,
+      walletAddress,
+      moonpayQuoteCurrencyAmount: fallbackAmount
+    });
+  } catch (err) {
+    emitDebug("verification:amount-from-receipt-error", errorPayload(err));
+    receiptError = err;
+  }
+  const errorDetail = receiptError instanceof Error ? receiptError.message : receiptError === void 0 ? `no ${token.symbol} Transfer to ${walletAddress} found` : String(receiptError);
+  throw new Error(
+    `Unable to derive delivered ${token.symbol} amount from ${onChainTxHash}: ${errorDetail}`
+  );
+}
+function matchesOnRampTransaction(record, transactionId) {
+  return record.transaction_id === transactionId || record.external_transaction_id === transactionId || record.moonpay_transaction_id === transactionId;
+}
+function getOnRampVerificationKey(record) {
+  return record.on_chain_tx_hash ?? record.transaction_id;
+}
+function requireServiceAddress(serviceAddress) {
+  if (!serviceAddress) {
+    throw new Error("Service address not configured");
+  }
+  return serviceAddress;
+}
+function summariseMoonPayEventProps(props) {
+  return {
+    id: props.id,
+    externalTransactionId: props.externalTransactionId,
+    status: props.status,
+    walletAddress: props.walletAddress,
+    walletAddressTag: props.walletAddressTag,
+    baseCurrencyAmount: props.baseCurrencyAmount,
+    quoteCurrencyAmount: props.quoteCurrencyAmount,
+    baseCurrency: props.baseCurrency,
+    quoteCurrency: props.quoteCurrency,
+    createdAt: props.createdAt
+  };
+}
+function summariseMoonPayUrl(url) {
+  try {
+    const parsed = new URL(url);
+    const params = parsed.searchParams;
+    return {
+      origin: parsed.origin,
+      pathname: parsed.pathname,
+      apiKeyPrefix: params.get("apiKey")?.slice(0, 8) ?? null,
+      currencyCode: params.get("currencyCode"),
+      baseCurrencyCode: params.get("baseCurrencyCode"),
+      baseCurrencyAmount: params.get("baseCurrencyAmount"),
+      walletAddress: params.get("walletAddress"),
+      externalCustomerId: params.get("externalCustomerId"),
+      externalTransactionId: params.get("externalTransactionId"),
+      redirectURL: params.get("redirectURL"),
+      signaturePresent: params.has("signature")
+    };
+  } catch {
+    return { parseError: true, length: url.length };
+  }
+}
+function errorPayload(err) {
+  if (err instanceof Error) {
+    return {
+      name: err.name,
+      message: err.message,
+      stack: err.stack?.split("\n").slice(0, 4).join("\n")
+    };
+  }
+  return { message: String(err) };
+}
+function useMoonPayBuyWidget({
+  variant,
+  visible,
+  autoStart,
+  canBuy,
+  openWidget,
+  refreshPending,
+  theme,
+  themeId,
+  colorCode,
+  baseCurrencyCode,
+  baseCurrencyAmount,
+  quoteCurrencyAmount,
+  lockAmount,
+  paymentMethod,
+  currencyCode,
+  depositAddress,
+  externalCustomerId,
+  externalTransactionId,
+  onClose,
+  onCloseOverlay,
+  onReady,
+  onUrlSignatureRequested,
+  onTransactionCreated,
+  onTransactionCompleted
+}) {
+  const autoStartedRef = react.useRef(false);
+  react.useEffect(() => {
+    if (!autoStart || autoStartedRef.current || !canBuy) return;
+    autoStartedRef.current = true;
+    void openWidget();
+  }, [autoStart, canBuy, openWidget]);
+  react.useEffect(() => {
+    if (variant !== "embedded" || !visible) return;
+    const id = setInterval(() => void refreshPending(), 5e3);
+    return () => clearInterval(id);
+  }, [variant, visible, refreshPending]);
+  const callbacksRef = react.useRef({
+    onClose,
+    onCloseOverlay,
+    onReady,
+    onUrlSignatureRequested,
+    onTransactionCreated,
+    onTransactionCompleted
+  });
+  react.useEffect(() => {
+    callbacksRef.current = {
+      onClose,
+      onCloseOverlay,
+      onReady,
+      onUrlSignatureRequested,
+      onTransactionCreated,
+      onTransactionCompleted
+    };
+  });
+  const overlayNode = react.useMemo(
+    () => variant === "overlay" ? buildOverlayNode() : void 0,
+    [variant]
+  );
+  return react.useMemo(() => {
+    if (!visible || !depositAddress || !externalTransactionId) return null;
+    return /* @__PURE__ */ jsxRuntime.jsx(
+      moonpayReact.MoonPayBuyWidget,
+      {
+        variant,
+        visible: true,
+        theme,
+        themeId,
+        colorCode,
+        overlayNode,
+        baseCurrencyCode,
+        baseCurrencyAmount,
+        quoteCurrencyAmount,
+        lockAmount: lockAmount ? "true" : void 0,
+        paymentMethod,
+        currencyCode,
+        walletAddress: depositAddress,
+        externalCustomerId,
+        externalTransactionId,
+        onClose: () => callbacksRef.current.onClose(),
+        onCloseOverlay: () => callbacksRef.current.onCloseOverlay(),
+        onReady: () => callbacksRef.current.onReady(),
+        onUrlSignatureRequested: (url) => callbacksRef.current.onUrlSignatureRequested(url),
+        onTransactionCreated: (props) => callbacksRef.current.onTransactionCreated(props),
+        onTransactionCompleted: (props) => callbacksRef.current.onTransactionCompleted(props)
+      }
+    );
+  }, [
+    visible,
+    depositAddress,
+    externalTransactionId,
+    variant,
+    theme,
+    themeId,
+    colorCode,
+    overlayNode,
+    baseCurrencyCode,
+    baseCurrencyAmount,
+    quoteCurrencyAmount,
+    lockAmount,
+    paymentMethod,
+    currencyCode,
+    externalCustomerId
+  ]);
+}
+function buildOverlayNode() {
+  if (typeof document === "undefined") return void 0;
+  const wrap = document.createElement("div");
+  wrap.style.cssText = "display:flex;flex-direction:column;align-items:center;gap:12px";
+  wrap.innerHTML = `<svg xmlns="http://www.w3.org/2000/svg" width="139" height="20.61" viewBox="0 0 139 20.61"><path d="M15.08,20.61L10.49,20.61L10.49,0.00L17.96,0.00L18.81,0.02L19.62,0.10L20.38,0.22L21.11,0.39L21.79,0.60L22.43,0.87L23.03,1.18L23.58,1.53L24.08,1.92L24.53,2.35L24.93,2.82L25.29,3.33L25.59,3.88L25.84,4.47L26.03,5.09L26.17,5.75L26.25,6.44L26.28,7.17L26.28,7.17L26.28,7.62L26.25,8.33L26.17,9.01L26.03,9.66L25.84,10.27L25.59,10.86L25.29,11.41L24.93,11.93L24.53,12.40L24.08,12.83L23.58,13.23L23.03,13.58L22.43,13.89L21.79,14.15L21.11,14.37L20.38,14.54L19.62,14.66L18.81,14.73L17.96,14.76L17.96,14.76L15.08,14.76L15.08,20.61ZM18.19,3.98L15.08,3.98L15.08,10.78L18.19,10.78L18.53,10.77L18.87,10.73L19.18,10.68L19.48,10.59L19.76,10.49L20.02,10.36L20.27,10.21L20.50,10.04L20.70,9.85L20.89,9.64L21.06,9.42L21.21,9.17L21.34,8.91L21.45,8.63L21.53,8.34L21.59,8.04L21.62,7.72L21.63,7.39L21.63,7.39L21.62,7.05L21.59,6.72L21.53,6.40L21.45,6.10L21.34,5.82L21.21,5.56L21.06,5.31L20.89,5.09L20.70,4.88L20.50,4.69L20.27,4.53L20.02,4.38L19.76,4.26L19.48,4.16L19.18,4.08L18.87,4.02L18.53,3.99L18.19,3.98L18.19,3.98ZM31.76,20.61L27.16,20.61L27.16,0.00L35.20,0.00L36.03,0.02L36.82,0.09L37.58,0.19L38.30,0.34L38.98,0.53L39.62,0.77L40.23,1.05L40.78,1.37L41.28,1.73L41.74,2.13L42.15,2.57L42.51,3.05L42.82,3.58L43.07,4.15L43.26,4.76L43.40,5.42L43.49,6.12L43.52,6.86L43.52,6.86L43.52,7.31L43.49,8.04L43.40,8.73L43.26,9.38L43.07,9.98L42.82,10.54L42.51,11.06L42.51,11.06L42.15,11.53L41.75,11.97L41.30,12.36L40.80,12.72L40.26,13.03L39.68,13.30L39.68,13.30L44.89,20.61L39.57,20.61L35.12,14.06L31.76,14.06L31.76,20.61ZM35.56,3.89L31.76,3.89L31.76,10.44L35.56,10.44L35.89,10.43L36.21,10.40L36.51,10.34L36.79,10.26L37.06,10.16L37.31,10.04L37.55,9.89L37.77,9.73L37.97,9.55L38.15,9.35L38.32,9.13L38.46,8.89L38.59,8.64L38.69,8.37L38.77,8.09L38.82,7.79L38.86,7.49L38.87,7.17L38.86,6.85L38.82,6.54L38.77,6.25L38.69,5.97L38.59,5.70L38.46,5.45L38.32,5.21L38.15,4.99L37.97,4.79L37.77,4.61L37.55,4.44L37.31,4.30L37.06,4.17L36.79,4.07L36.51,3.99L36.21,3.94L35.89,3.90L35.56,3.89L35.56,3.89ZM50.25,20.61L45.66,20.61L45.66,0.17L50.25,0.17L50.25,20.61ZM64.88,20.61L57.41,20.61L51.19,0.17L55.92,0.17L60.71,16.88L61.66,16.88L66.09,0.17L70.68,0.17L64.88,20.61ZM71.44,20.61L66.85,20.61L73.60,0.17L81.02,0.17L88.02,20.61L83.26,20.61L81.61,15.54L73.07,15.54L71.44,20.61ZM74.27,11.73L80.35,11.73L77.80,3.92L76.76,3.92L74.27,11.73ZM92.94,20.61L88.68,20.61L88.68,0.17L96.21,0.17L103.91,16.88L104.30,16.88L104.30,0.17L108.62,0.17L108.62,20.61L101.03,20.61L93.33,3.89L92.94,3.89L92.94,20.61ZM113.87,20.61L109.28,20.61L116.02,0.17L123.44,0.17L130.44,20.61L125.68,20.61L124.03,15.54L115.49,15.54L113.87,20.61ZM116.70,11.73L122.77,11.73L120.22,3.92L119.19,3.92L116.70,11.73Z" fill="#ffffff"/></svg><span>Your secure checkout is loading</span>`;
+  return wrap;
+}
+function FiatOnRampForm({
+  tokenId,
+  currencyCode,
+  baseCurrencyCode = "usd",
+  defaultBaseCurrencyAmount = "100",
+  quoteCurrencyAmount,
+  tokenSymbol,
+  theme,
+  themeId,
+  colorCode,
+  variant = "overlay",
+  autoStart = false,
+  lockAmount,
+  paymentMethod,
+  postDepositLock,
+  onCredited,
+  onLockSubmitted,
+  onLockFailed,
+  onError,
+  onDebugEvent
+}) {
+  const { address } = wagmi.useAccount();
+  const [visible, setVisible] = react.useState(false);
+  const [isPreparing, setIsPreparing] = react.useState(false);
+  const [rowError, setRowError] = react.useState(null);
+  const [lockError, setLockError] = react.useState(null);
+  const [lockSettled, setLockSettled] = react.useState(false);
+  const {
+    status,
+    activeIntentId,
+    pending,
+    activeVerificationId,
+    error,
+    finalityProgress,
+    depositAddress,
+    minDepositBaseUnits,
+    selectedToken,
+    prepareOnRampIntent,
+    signUrl,
+    handleTransactionCreated,
+    handleTransactionCompleted,
+    finishPendingVerification,
+    handleWidgetClosed,
+    refreshPending
+  } = useFiatOnRamp({
+    tokenId,
+    postDepositLock,
+    onCredited,
+    // Lock callbacks aren't intent-keyed, so a resumed background row's lock
+    // can settle these flags while a newer purchase is still locking — a
+    // transient overpromise that the newer lock's own outcome then corrects.
+    onLockSubmitted: (response) => {
+      setLockError(null);
+      setLockSettled(true);
+      onLockSubmitted?.(response);
+    },
+    onLockFailed: (err) => {
+      setLockError(err.message);
+      onLockFailed?.(err);
+    },
+    onError,
+    onDebugEvent
+  });
+  const decimals = selectedToken?.decimals;
+  const displaySymbol = tokenSymbol ?? selectedToken?.symbol ?? currencyCode.toUpperCase();
+  const emitFormDebug = react.useCallback(
+    (event, payload) => {
+      onDebugEvent?.({
+        at: (/* @__PURE__ */ new Date()).toISOString(),
+        event,
+        status,
+        tokenId,
+        payload
+      });
+    },
+    [onDebugEvent, status, tokenId]
+  );
+  const minFiatGate = minDepositBaseUnits !== void 0 && decimals !== void 0 ? Number(viem.formatUnits(minDepositBaseUnits, decimals)) * 1.05 : void 0;
+  const { units: quoteBaseUnits, failed: quoteParseFailed } = (() => {
+    if (!quoteCurrencyAmount || decimals === void 0) return { units: void 0, failed: false };
+    try {
+      return { units: viem.parseUnits(quoteCurrencyAmount, decimals), failed: false };
+    } catch {
+      return { units: void 0, failed: true };
+    }
+  })();
+  const isBelowMin = quoteBaseUnits !== void 0 && minDepositBaseUnits !== void 0 ? quoteBaseUnits < minDepositBaseUnits : minFiatGate !== void 0 && Number(defaultBaseCurrencyAmount) < minFiatGate;
+  const isBusy = isPreparing || status === "awaiting-purchase";
+  const lockPending = !!postDepositLock && status === "credited" && !lockSettled && !lockError;
+  const isInitializing = !!address && !depositAddress;
+  const isPrePurchase = status === "idle" || status === "awaiting-purchase";
+  const isVerifying = status === "awaiting-delivery" || status === "verifying";
+  const blockReasons = react.useMemo(
+    () => [
+      !address ? "wallet-not-connected" : null,
+      !depositAddress ? "deposit-address-not-loaded" : null,
+      isBusy ? `busy:${isPreparing ? "preparing" : status}` : null,
+      visible ? "widget-open" : null,
+      isBelowMin ? "below-minimum" : null,
+      quoteParseFailed ? "invalid-quote-amount" : null
+    ].filter((reason) => Boolean(reason)),
+    [address, depositAddress, isBelowMin, isBusy, isPreparing, quoteParseFailed, status, visible]
+  );
+  const canBuy = blockReasons.length === 0;
+  const handleOpen = react.useCallback(async () => {
+    if (!canBuy) {
+      emitFormDebug("form:open-blocked", {
+        reasons: blockReasons,
+        currencyCode,
+        tokenSymbol: displaySymbol,
+        tokenDecimals: decimals ?? null,
+        baseCurrencyCode,
+        defaultBaseCurrencyAmount,
+        depositAddress: depositAddress ?? null,
+        walletAddress: address ?? null,
+        status
+      });
+      return;
+    }
+    setIsPreparing(true);
+    setLockError(null);
+    setLockSettled(false);
+    emitFormDebug("form:open-click", {
+      currencyCode,
+      tokenSymbol: displaySymbol,
+      tokenDecimals: decimals ?? null,
+      baseCurrencyCode,
+      defaultBaseCurrencyAmount,
+      depositAddress: depositAddress ?? null,
+      walletConnected: Boolean(address)
+    });
+    try {
+      const intent = await prepareOnRampIntent({
+        currencyCode,
+        baseCurrencyCode,
+        baseCurrencyAmount: defaultBaseCurrencyAmount,
+        quoteCurrencyAmount
+      });
+      emitFormDebug("form:intent-ready", {
+        transactionId: intent.transaction_id,
+        externalTransactionId: intent.external_transaction_id ?? null
+      });
+      setVisible(true);
+    } catch (err) {
+      const error2 = err instanceof Error ? err : new Error("Failed to prepare MoonPay on-ramp");
+      emitFormDebug("form:intent-error", {
+        name: error2.name,
+        message: error2.message
+      });
+    } finally {
+      setIsPreparing(false);
+    }
+  }, [
+    address,
+    baseCurrencyCode,
+    blockReasons,
+    canBuy,
+    currencyCode,
+    decimals,
+    displaySymbol,
+    defaultBaseCurrencyAmount,
+    quoteCurrencyAmount,
+    depositAddress,
+    emitFormDebug,
+    prepareOnRampIntent,
+    status
+  ]);
+  const handleClose = react.useCallback(async () => {
+    emitFormDebug("moonpay:onClose");
+    setVisible(false);
+    await handleWidgetClosed();
+  }, [emitFormDebug, handleWidgetClosed]);
+  const handleCloseOverlay = react.useCallback(async () => {
+    emitFormDebug("moonpay:onCloseOverlay");
+    setVisible(false);
+    await handleWidgetClosed();
+  }, [emitFormDebug, handleWidgetClosed]);
+  const handleReady = react.useCallback(async () => {
+    emitFormDebug("moonpay:onReady");
+  }, [emitFormDebug]);
+  const widgetElement = useMoonPayBuyWidget({
+    variant,
+    visible,
+    autoStart,
+    canBuy,
+    openWidget: handleOpen,
+    refreshPending,
+    theme,
+    themeId,
+    colorCode,
+    baseCurrencyCode,
+    baseCurrencyAmount: defaultBaseCurrencyAmount,
+    quoteCurrencyAmount,
+    lockAmount,
+    paymentMethod,
+    currencyCode,
+    depositAddress,
+    externalCustomerId: address?.toLowerCase(),
+    externalTransactionId: activeIntentId,
+    onClose: handleClose,
+    onCloseOverlay: handleCloseOverlay,
+    onReady: handleReady,
+    onUrlSignatureRequested: signUrl,
+    onTransactionCreated: handleTransactionCreated,
+    onTransactionCompleted: handleTransactionCompleted
+  });
+  react.useEffect(() => {
+    if (variant !== "embedded" || !visible) return;
+    if (isVerifying || status === "credited") {
+      setVisible(false);
+      void refreshPending();
+    }
+  }, [variant, visible, isVerifying, status, refreshPending]);
+  return /* @__PURE__ */ jsxRuntime.jsxs("div", { "data-privana": true, className: "flex flex-col gap-4", children: [
+    pending.length > 0 && /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex flex-col gap-2", children: [
+      /* @__PURE__ */ jsxRuntime.jsx("p", { className: "text-foreground text-sm font-medium", children: "Validating purchases" }),
+      pending.map((record) => {
+        const progress = parseFinalityProgress(finalityProgress[record.transaction_id]);
+        const hasProgress = !!finalityProgress[record.transaction_id];
+        const isStalled = !hasProgress && Date.now() / 1e3 - (record.updated_at ?? 0) > 60;
+        const isActivelyVerifying = record.transaction_id === activeVerificationId;
+        const showRetry = rowError?.id === record.transaction_id || isStalled && !isActivelyVerifying;
+        return /* @__PURE__ */ jsxRuntime.jsxs(
+          "div",
+          {
+            className: "border-border flex flex-col gap-1 rounded-md border p-2",
+            children: [
+              /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex items-center justify-between gap-2", children: [
+                /* @__PURE__ */ jsxRuntime.jsxs("p", { className: "text-muted-foreground flex items-center gap-1 text-xs", children: [
+                  /* @__PURE__ */ jsxRuntime.jsx(lucideReact.Loader2, { className: "size-3 animate-spin", "aria-hidden": true }),
+                  progress ?? "Verifying\u2026"
+                ] }),
+                /* @__PURE__ */ jsxRuntime.jsxs("p", { className: "text-muted-foreground text-xs", children: [
+                  record.quote_currency_amount ?? "?",
+                  " ",
+                  displaySymbol
+                ] })
+              ] }),
+              rowError?.id === record.transaction_id && /* @__PURE__ */ jsxRuntime.jsx("p", { className: "text-destructive text-xs", children: rowError.message }),
+              showRetry && /* @__PURE__ */ jsxRuntime.jsx(
+                Button,
+                {
+                  type: "button",
+                  variant: "outline",
+                  size: "sm",
+                  onClick: async () => {
+                    setRowError(null);
+                    try {
+                      await finishPendingVerification(record);
+                    } catch (err) {
+                      setRowError({
+                        id: record.transaction_id,
+                        message: err instanceof Error ? err.message : "Verification failed"
+                      });
+                    }
+                  },
+                  children: "Retry"
+                }
+              )
+            ]
+          },
+          record.transaction_id
+        );
+      })
+    ] }),
+    status === "credited" && !lockPending && !lockError && /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex flex-col items-center gap-2 py-8 text-center", children: [
+      /* @__PURE__ */ jsxRuntime.jsx(lucideReact.CircleCheckIcon, { className: "text-primary size-8", "aria-hidden": true }),
+      /* @__PURE__ */ jsxRuntime.jsx("p", { className: "text-foreground text-sm font-medium", children: "Purchase credited" }),
+      /* @__PURE__ */ jsxRuntime.jsxs("p", { className: "text-muted-foreground text-sm", children: [
+        "Your ",
+        displaySymbol,
+        " deposit is now available in your balance."
+      ] })
+    ] }),
+    lockPending && /* @__PURE__ */ jsxRuntime.jsxs("p", { className: "text-muted-foreground flex items-center gap-2 text-sm", children: [
+      /* @__PURE__ */ jsxRuntime.jsx(lucideReact.Loader2, { className: "size-4 animate-spin", "aria-hidden": true }),
+      "Purchase credited \u2014 locking your funds\u2026"
+    ] }),
+    autoStart ? !visible && isPrePurchase && /* @__PURE__ */ jsxRuntime.jsx(Skeleton, { className: "h-[656px] w-full rounded-md" }) : isInitializing ? /* @__PURE__ */ jsxRuntime.jsx(Skeleton, { className: "h-9 w-full rounded-md" }) : /* @__PURE__ */ jsxRuntime.jsxs(Button, { type: "button", onClick: handleOpen, disabled: !canBuy, children: [
+      (isBusy || visible) && /* @__PURE__ */ jsxRuntime.jsx(lucideReact.Loader2, { className: "animate-spin", "aria-hidden": true }),
+      "Buy"
+    ] }),
+    widgetElement,
+    error && /* @__PURE__ */ jsxRuntime.jsx("p", { className: "text-destructive text-sm", role: "alert", children: error.message }),
+    lockError && /* @__PURE__ */ jsxRuntime.jsxs("p", { className: "text-destructive text-sm", role: "alert", children: [
+      "Purchase credited to your account, but locking the funds to a service failed: ",
+      lockError
+    ] }),
+    isBelowMin && minFiatGate !== void 0 && /* @__PURE__ */ jsxRuntime.jsxs("p", { className: "text-destructive text-sm", role: "alert", children: [
+      "Minimum purchase is ~$",
+      minFiatGate.toFixed(2),
+      "."
+    ] }),
+    isVerifying && pending.length === 0 && /* @__PURE__ */ jsxRuntime.jsxs("p", { className: "text-muted-foreground flex items-center gap-2 text-sm", children: [
+      /* @__PURE__ */ jsxRuntime.jsx(lucideReact.Loader2, { className: "size-4 animate-spin", "aria-hidden": true }),
+      "Verifying your purchase\u2026"
+    ] })
+  ] });
+}
+function parseFinalityProgress(message) {
+  if (!message) return null;
+  const match = message.match(/(\d+\/\d+)\s+confirmations/i);
+  return match ? `${match[1]} confirmations` : null;
+}
+
+exports.AccountingApiError = AccountingApiError;
+exports.Button = Button;
+exports.DEFAULT_LOCK_DURATION_SECONDS = DEFAULT_LOCK_DURATION_SECONDS;
+exports.DEFAULT_ONRAMP_LOCK_BUFFER = DEFAULT_ONRAMP_LOCK_BUFFER;
+exports.FiatOnRampForm = FiatOnRampForm;
+exports.HOSTED_AUTH_CLOCK_SKEW_MS = HOSTED_AUTH_CLOCK_SKEW_MS;
+exports.HostedAuthError = HostedAuthError;
+exports.HostedAuthRequiredError = HostedAuthRequiredError;
+exports.HostedAuthStateMismatchError = HostedAuthStateMismatchError;
+exports.HttpClient = HttpClient;
+exports.LOCK_TYPES = LOCK_TYPES;
+exports.MODIFY_LOCK_TYPES = MODIFY_LOCK_TYPES;
+exports.NETWORK_CONFIG = NETWORK_CONFIG;
+exports.NetworkError = NetworkError;
+exports.PostDepositLockError = PostDepositLockError;
+exports.PrivanaClient = PrivanaClient;
+exports.PrivanaProvider = PrivanaProvider;
+exports.SUPPORTED_CHAINS = SUPPORTED_CHAINS;
+exports.SiweAuthProvider = SiweAuthProvider;
+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.applyLockBuffer = applyLockBuffer;
+exports.applyRefreshResponse = applyRefreshResponse;
+exports.buildHostedAuthSession = buildHostedAuthSession;
+exports.buildSiweStatement = buildSiweStatement;
+exports.buttonVariants = buttonVariants;
+exports.canUseBrowserStorage = canUseBrowserStorage;
+exports.clampLockAmount = clampLockAmount;
+exports.clearHostedAuthPendingTransaction = clearHostedAuthPendingTransaction;
+exports.clearPendingLock = clearPendingLock;
+exports.cn = cn;
+exports.createDomain = createDomain;
+exports.createHostedAuthPendingStorageKey = createHostedAuthPendingStorageKey;
+exports.createHostedAuthState = createHostedAuthState;
+exports.createHostedAuthStorageKey = createHostedAuthStorageKey;
+exports.createLockExpiry = createLockExpiry;
+exports.createPkceChallenge = createPkceChallenge;
+exports.createPkceVerifier = createPkceVerifier;
+exports.createSignedLockRequest = createSignedLockRequest;
+exports.formatCountdown = formatCountdown;
+exports.formatTimeRemaining = formatTimeRemaining;
+exports.formatTokenAmount = formatTokenAmount;
+exports.getAccountingContract = getAccountingContract;
+exports.getApiUrl = getApiUrl;
+exports.getBrowserStorageItem = getBrowserStorageItem;
+exports.getChainById = getChainById;
+exports.getChainId = getChainId;
+exports.getExplorerAddressUrl = getExplorerAddressUrl;
+exports.getExplorerLabel = getExplorerLabel;
+exports.getTransactionReceipt = getTransactionReceipt;
+exports.getWalletClient = getWalletClient3;
+exports.isHostedAuthRefreshActive = isHostedAuthRefreshActive;
+exports.isHostedAuthSessionActive = isHostedAuthSessionActive;
+exports.isSignedLockUsable = isSignedLockUsable;
+exports.loadPendingLock = loadPendingLock;
+exports.normalizeAddress = normalizeAddress;
+exports.normalizeHex = normalizeHex;
+exports.parseHostedAuthCallback = parseHostedAuthCallback;
+exports.parseTokenAmount = parseTokenAmount;
+exports.persistHostedAuthPendingTransaction = persistHostedAuthPendingTransaction;
+exports.readHostedAuthPendingTransaction = readHostedAuthPendingTransaction;
+exports.readStoredHostedAuthSession = readStoredHostedAuthSession;
+exports.removeBrowserStorageItem = removeBrowserStorageItem;
+exports.savePendingLock = savePendingLock;
+exports.setBrowserStorageItem = setBrowserStorageItem;
+exports.shortenAddress = shortenAddress;
+exports.signLockMessage = signLockMessage;
+exports.signModifyLockMessage = signModifyLockMessage;
+exports.signTransferLockedMessage = signTransferLockedMessage;
+exports.signTransferMessage = signTransferMessage;
+exports.signWithdrawFromLockMessage = signWithdrawFromLockMessage;
+exports.signWithdrawMessage = signWithdrawMessage;
+exports.stripHostedAuthCallbackParams = stripHostedAuthCallbackParams;
+exports.submitPendingLock = submitPendingLock;
+exports.syncHostedAuthSessionToClient = syncHostedAuthSessionToClient;
+exports.useDepositVerification = useDepositVerification;
+exports.useEnsureCorrectChain = useEnsureCorrectChain;
+exports.useFiatOnRamp = useFiatOnRamp;
+exports.usePrivanaContext = usePrivanaContext;
+exports.usePrivateReadRequest = usePrivateReadRequest;
+exports.useSafeAccount = useSafeAccount;
+exports.useSafePrivanaContext = useSafePrivanaContext;
+exports.useSiweAuth = useSiweAuth;
+exports.waitForTransactionReceipt = waitForTransactionReceipt;
+//# sourceMappingURL=chunk-4IW4V7YJ.cjs.map
+//# sourceMappingURL=chunk-4IW4V7YJ.cjs.map