@oasisprotocol/privana-sdk 0.5.0 → 0.5.1

package/dist/{chunk-54FC6TO3.js → chunk-SAJ7K5WT.js}

@@ -1,15 +1,16 @@
 "use client";
 import { createContext, useContext, useRef, useCallback, useSyncExternalStore, useState, useEffect, useMemo } from 'react';
-import { WagmiContext, useConfig, useAccount } from 'wagmi';
+import { WagmiContext, useConfig, useChainId, useSwitchChain, useAccount, useWalletClient } from 'wagmi';
 import { watchAccount, getAccount, getWalletClient } from 'wagmi/actions';
 import { createSiweMessage } from 'viem/siwe';
 import { jsx, jsxs } from 'react/jsx-runtime';
-import { parseAbiItem, zeroAddress, hexToString, parseUnits, decodeEventLog, formatUnits } from 'viem';
+import { parseAbiItem, zeroAddress, walletActions, hexToString, parseUnits, decodeEventLog, formatUnits, createClient, custom } from 'viem';
 import { useQueryClient } from '@tanstack/react-query';
 import { Slot } from '@radix-ui/react-slot';
 import { cva } from 'class-variance-authority';
 import { clsx } from 'clsx';
 import { twMerge } from 'tailwind-merge';
+import { parseAccount, getAddress } from 'viem/utils';
 import { getTransactionReceipt as getTransactionReceipt$1, waitForTransactionReceipt as waitForTransactionReceipt$1, getTransaction, call } from 'viem/actions';
 import { Loader2, CircleCheckIcon } from 'lucide-react';
 import { MoonPayBuyWidget } from '@moonpay/moonpay-react';
@@ -34,7 +35,7 @@ var config_default = {
     testnet: {
       chainId: 23295,
       name: "Sapphire Testnet",
-      accountingContract: "0xaF8e5de153A584528B57DD4B9B0195956BBDF571",
+      accountingContract: "0xad3C76e4E621C0cfF7540479Ee9B0A945723A642",
       apiUrl: "https://api.testnet.privana.finance"
     },
     mainnet: {
@@ -372,6 +373,19 @@ var PrivanaClient = class {
   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}`);
@@ -623,6 +637,202 @@ var PrivanaClient = class {
     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,
@@ -1168,6 +1378,205 @@ function usePrivanaContext() {
 function useSafePrivanaContext() {
   return 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;
@@ -1399,7 +1808,7 @@ function useDepositVerification(options = {}) {
   const runVerification = useCallback(
     async (ctx, generation) => {
       const isStale = () => generation !== generationRef.current;
-      const { hash, chainId, amount } = ctx;
+      const { hash, chainId, amount, logIndex } = ctx;
       setVerificationFailed(false);
       setError(null);
       setDidTimeout(false);
@@ -1427,7 +1836,8 @@ function useDepositVerification(options = {}) {
               () => client.checkDeposit({
                 chain_id: chainId,
                 tx_hash: hash,
-                amount: amount.toString()
+                amount: amount.toString(),
+                log_index: logIndex
               })
             );
             if (result.status === "error" && isInsufficientFinalityMessage(result.detail)) {
@@ -1632,6 +2042,12 @@ function formatTimeRemaining(expiryTimestamp) {
   }
   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 = 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",
   {
@@ -1700,6 +2116,198 @@ function getAction(client, actionFn, name) {
   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 = parseAccount(parameters.account ?? connection.accounts[0]);
+  if (account)
+    account.address = 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 createClient({
+    account,
+    chain,
+    name: "Connector Client",
+    transport: (opts) => custom(provider)({ ...opts, retryCount: 0 })
+  });
+}
+
 // ../../node_modules/@wagmi/core/dist/esm/actions/getChainId.js
 function getChainId2(config) {
   return config.state.chainId;
@@ -1710,6 +2318,10 @@ async function getTransactionReceipt(config, parameters) {
   const action = getAction(client, getTransactionReceipt$1, "getTransactionReceipt");
   return action(rest);
 }
+async function getWalletClient3(config, parameters = {}) {
+  const client = await getConnectorClient(config, parameters);
+  return client.extend(walletActions);
+}
 async function waitForTransactionReceipt(config, parameters) {
   const { chainId, timeout = 0, ...rest } = parameters;
   const client = config.getClient({ chainId });
@@ -1737,6 +2349,59 @@ async function waitForTransactionReceipt(config, parameters) {
     chainId: client.chain.id
   };
 }
+function useEnsureCorrectChain() {
+  const config = useConfig();
+  const chainId = useChainId();
+  const { switchChainAsync } = useSwitchChain();
+  const waitUntilOnChain = 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 = 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 = 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;
@@ -1744,14 +2409,26 @@ var ERC20_TRANSFER_EVENT = parseAbiItem(
   "event Transfer(address indexed from, address indexed to, uint256 value)"
 );
 function useFiatOnRamp(options) {
-  const { tokenId, onCredited, onError, onDebugEvent } = 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 { client, enabledTokens } = usePrivanaContext();
+  const { address } = useAccount();
+  const { data: walletClient } = useWalletClient();
+  const { client, enabledTokens, networkConfig, serviceAddress } = usePrivanaContext();
   const { executePrivateRead, privateReadReady } = usePrivateReadRequest();
+  const { ensureCorrectChain } = useEnsureCorrectChain();
   const wagmiConfig = useConfig();
+  const queryClient = useQueryClient();
   const selectedToken = enabledTokens.find((t) => t.id.toLowerCase() === tokenId.toLowerCase());
   const [status, setStatus] = useState("idle");
   const [pending, setPending] = useState([]);
@@ -1762,20 +2439,27 @@ function useFiatOnRamp(options) {
   const [activeVerificationId, setActiveVerificationId] = useState(null);
   const [finalityProgress, setFinalityProgress] = useState({});
   const onCreditedRef = useRef(onCredited);
+  const onLockSubmittedRef = useRef(onLockSubmitted);
+  const onLockFailedRef = useRef(onLockFailed);
   const onErrorRef = useRef(onError);
   const onDebugEventRef = useRef(onDebugEvent);
   const statusRef = useRef(status);
   const activeIntentIdRef = useRef(null);
   const activeVerificationRecordRef = useRef(null);
   const activeVerificationKeyRef = useRef(null);
+  const activeVerificationAmountRef = useRef(null);
+  const lockOwnerRef = useRef(null);
   const triggeredVerificationKeysRef = useRef(/* @__PURE__ */ new Set());
+  const activeVerificationDoneRef = useRef(null);
   const closeReconcilePromiseRef = useRef(null);
   const purchaseInitiatedRef = useRef(false);
   useEffect(() => {
     onCreditedRef.current = onCredited;
+    onLockSubmittedRef.current = onLockSubmitted;
+    onLockFailedRef.current = onLockFailed;
     onErrorRef.current = onError;
     onDebugEventRef.current = onDebugEvent;
-  }, [onCredited, onError, onDebugEvent]);
+  }, [onCredited, onLockSubmitted, onLockFailed, onError, onDebugEvent]);
   useEffect(() => {
     statusRef.current = status;
   }, [status]);
@@ -1856,13 +2540,64 @@ function useFiatOnRamp(options) {
   useEffect(() => {
     refreshPending();
   }, [refreshPending]);
-  const clearActiveVerification = useCallback(() => {
+  const clearActiveVerification = 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 = 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,
@@ -1878,6 +2613,7 @@ function useFiatOnRamp(options) {
     },
     onCredited: (depositTxHash) => {
       const record = activeVerificationRecordRef.current;
+      const verificationKey = record ? getOnRampVerificationKey(record) : null;
       emitDebug("verification:credited", {
         depositTxHash,
         record: record ? summariseOnRampRecord(record) : null
@@ -1892,6 +2628,18 @@ function useFiatOnRamp(options) {
           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 {
@@ -1914,7 +2662,7 @@ function useFiatOnRamp(options) {
           console.warn("Failed to mark on-ramp row complete:", err);
         } finally {
           await refreshPending();
-          clearActiveVerification();
+          clearActiveVerification(verificationKey);
           if (record && activeIntentIdRef.current === record.transaction_id) {
             activeIntentIdRef.current = null;
             setActiveIntentId(null);
@@ -1952,7 +2700,8 @@ function useFiatOnRamp(options) {
     async ({
       currencyCode,
       baseCurrencyCode,
-      baseCurrencyAmount
+      baseCurrencyAmount,
+      quoteCurrencyAmount
     }) => {
       try {
         setError(null);
@@ -1960,12 +2709,34 @@ function useFiatOnRamp(options) {
         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(
+            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(
@@ -1978,6 +2749,28 @@ function useFiatOnRamp(options) {
             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", {
@@ -1993,7 +2786,21 @@ function useFiatOnRamp(options) {
         throw e;
       }
     },
-    [client, depositAddress, emitDebug, enabledTokens, executePrivateRead, tokenId]
+    [
+      address,
+      client,
+      depositAddress,
+      emitDebug,
+      enabledTokens,
+      ensureCorrectChain,
+      executePrivateRead,
+      networkConfig,
+      postDepositLock,
+      serviceAddress,
+      tokenId,
+      wagmiConfig,
+      walletClient
+    ]
   );
   const registerOnRampTokenMapping = useCallback(
     async (moonpayTransactionId) => {
@@ -2115,6 +2922,12 @@ function useFiatOnRamp(options) {
         });
         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;
@@ -2165,6 +2978,7 @@ function useFiatOnRamp(options) {
             `Delivered amount (${record.quote_currency_amount}) is below the minimum deposit.`
           );
         }
+        activeVerificationAmountRef.current = amount;
         if (activeIntentIdRef.current === record.transaction_id) {
           setStatus("verifying");
         }
@@ -2183,6 +2997,7 @@ function useFiatOnRamp(options) {
         if (activeVerificationKeyRef.current === verificationKey) {
           activeVerificationKeyRef.current = null;
           activeVerificationRecordRef.current = null;
+          activeVerificationAmountRef.current = null;
           setActiveVerificationId(null);
         }
         throw err;
@@ -2241,6 +3056,7 @@ function useFiatOnRamp(options) {
           previousStatus,
           transactionId
         });
+        if (address) clearPendingLock(address, transactionId);
         await refreshPending();
         if (previousStatus === "awaiting-purchase" || previousStatus === "awaiting-delivery") {
           setStatus("idle");
@@ -2271,7 +3087,7 @@ function useFiatOnRamp(options) {
     } finally {
       closeReconcilePromiseRef.current = null;
     }
-  }, [emitDebug, refreshPending, triggerVerification, waitForOnChainHash]);
+  }, [address, emitDebug, refreshPending, triggerVerification, waitForOnChainHash]);
   const finishPendingVerification = useCallback(
     async (record) => {
       try {
@@ -2305,6 +3121,12 @@ function useFiatOnRamp(options) {
         try {
           await triggerVerificationRef.current(record);
         } catch {
+          continue;
+        }
+        if (activeVerificationKeyRef.current === key) {
+          await new Promise((resolve) => {
+            activeVerificationDoneRef.current = resolve;
+          });
         }
       }
     })();
@@ -2421,6 +3243,12 @@ function matchesOnRampTransaction(record, 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,
@@ -2478,6 +3306,7 @@ function useMoonPayBuyWidget({
   colorCode,
   baseCurrencyCode,
   baseCurrencyAmount,
+  quoteCurrencyAmount,
   lockAmount,
   paymentMethod,
   currencyCode,
@@ -2537,6 +3366,7 @@ function useMoonPayBuyWidget({
         overlayNode,
         baseCurrencyCode,
         baseCurrencyAmount,
+        quoteCurrencyAmount,
         lockAmount: lockAmount ? "true" : void 0,
         paymentMethod,
         currencyCode,
@@ -2562,6 +3392,7 @@ function useMoonPayBuyWidget({
     overlayNode,
     baseCurrencyCode,
     baseCurrencyAmount,
+    quoteCurrencyAmount,
     lockAmount,
     paymentMethod,
     currencyCode,
@@ -2580,6 +3411,7 @@ function FiatOnRampForm({
   currencyCode,
   baseCurrencyCode = "usd",
   defaultBaseCurrencyAmount = "100",
+  quoteCurrencyAmount,
   tokenSymbol,
   theme,
   themeId,
@@ -2588,7 +3420,10 @@ function FiatOnRampForm({
   autoStart = false,
   lockAmount,
   paymentMethod,
+  postDepositLock,
   onCredited,
+  onLockSubmitted,
+  onLockFailed,
   onError,
   onDebugEvent
 }) {
@@ -2596,6 +3431,8 @@ function FiatOnRampForm({
   const [visible, setVisible] = useState(false);
   const [isPreparing, setIsPreparing] = useState(false);
   const [rowError, setRowError] = useState(null);
+  const [lockError, setLockError] = useState(null);
+  const [lockSettled, setLockSettled] = useState(false);
   const {
     status,
     activeIntentId,
@@ -2613,7 +3450,25 @@ function FiatOnRampForm({
     finishPendingVerification,
     handleWidgetClosed,
     refreshPending
-  } = useFiatOnRamp({ tokenId, onCredited, onError, onDebugEvent });
+  } = 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 = useCallback(
@@ -2629,8 +3484,17 @@ function FiatOnRampForm({
     [onDebugEvent, status, tokenId]
   );
   const minFiatGate = minDepositBaseUnits !== void 0 && decimals !== void 0 ? Number(formatUnits(minDepositBaseUnits, decimals)) * 1.05 : void 0;
-  const isBelowMin = minFiatGate !== void 0 && Number(defaultBaseCurrencyAmount) < minFiatGate;
+  const { units: quoteBaseUnits, failed: quoteParseFailed } = (() => {
+    if (!quoteCurrencyAmount || decimals === void 0) return { units: void 0, failed: false };
+    try {
+      return { units: 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";
@@ -2640,9 +3504,10 @@ function FiatOnRampForm({
       !depositAddress ? "deposit-address-not-loaded" : null,
       isBusy ? `busy:${isPreparing ? "preparing" : status}` : null,
       visible ? "widget-open" : null,
-      isBelowMin ? "below-minimum" : null
+      isBelowMin ? "below-minimum" : null,
+      quoteParseFailed ? "invalid-quote-amount" : null
     ].filter((reason) => Boolean(reason)),
-    [address, depositAddress, isBelowMin, isBusy, isPreparing, status, visible]
+    [address, depositAddress, isBelowMin, isBusy, isPreparing, quoteParseFailed, status, visible]
   );
   const canBuy = blockReasons.length === 0;
   const handleOpen = useCallback(async () => {
@@ -2661,6 +3526,8 @@ function FiatOnRampForm({
       return;
     }
     setIsPreparing(true);
+    setLockError(null);
+    setLockSettled(false);
     emitFormDebug("form:open-click", {
       currencyCode,
       tokenSymbol: displaySymbol,
@@ -2674,7 +3541,8 @@ function FiatOnRampForm({
       const intent = await prepareOnRampIntent({
         currencyCode,
         baseCurrencyCode,
-        baseCurrencyAmount: defaultBaseCurrencyAmount
+        baseCurrencyAmount: defaultBaseCurrencyAmount,
+        quoteCurrencyAmount
       });
       emitFormDebug("form:intent-ready", {
         transactionId: intent.transaction_id,
@@ -2699,6 +3567,7 @@ function FiatOnRampForm({
     decimals,
     displaySymbol,
     defaultBaseCurrencyAmount,
+    quoteCurrencyAmount,
     depositAddress,
     emitFormDebug,
     prepareOnRampIntent,
@@ -2729,6 +3598,7 @@ function FiatOnRampForm({
     colorCode,
     baseCurrencyCode,
     baseCurrencyAmount: defaultBaseCurrencyAmount,
+    quoteCurrencyAmount,
     lockAmount,
     paymentMethod,
     currencyCode,
@@ -2801,7 +3671,7 @@ function FiatOnRampForm({
         );
       })
     ] }),
-    status === "credited" && /* @__PURE__ */ jsxs("div", { className: "flex flex-col items-center gap-2 py-8 text-center", children: [
+    status === "credited" && !lockPending && !lockError && /* @__PURE__ */ jsxs("div", { className: "flex flex-col items-center gap-2 py-8 text-center", children: [
       /* @__PURE__ */ jsx(CircleCheckIcon, { className: "text-primary size-8", "aria-hidden": true }),
       /* @__PURE__ */ jsx("p", { className: "text-foreground text-sm font-medium", children: "Purchase credited" }),
       /* @__PURE__ */ jsxs("p", { className: "text-muted-foreground text-sm", children: [
@@ -2810,12 +3680,20 @@ function FiatOnRampForm({
         " deposit is now available in your balance."
       ] })
     ] }),
+    lockPending && /* @__PURE__ */ jsxs("p", { className: "text-muted-foreground flex items-center gap-2 text-sm", children: [
+      /* @__PURE__ */ jsx(Loader2, { className: "size-4 animate-spin", "aria-hidden": true }),
+      "Purchase credited \u2014 locking your funds\u2026"
+    ] }),
     autoStart ? !visible && isPrePurchase && /* @__PURE__ */ jsx(Skeleton, { className: "h-[656px] w-full rounded-md" }) : isInitializing ? /* @__PURE__ */ jsx(Skeleton, { className: "h-9 w-full rounded-md" }) : /* @__PURE__ */ jsxs(Button, { type: "button", onClick: handleOpen, disabled: !canBuy, children: [
       (isBusy || visible) && /* @__PURE__ */ jsx(Loader2, { className: "animate-spin", "aria-hidden": true }),
       "Buy"
     ] }),
     widgetElement,
     error && /* @__PURE__ */ jsx("p", { className: "text-destructive text-sm", role: "alert", children: error.message }),
+    lockError && /* @__PURE__ */ 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__ */ jsxs("p", { className: "text-destructive text-sm", role: "alert", children: [
       "Minimum purchase is ~$",
       minFiatGate.toFixed(2),
@@ -2833,6 +3711,6 @@ function parseFinalityProgress(message) {
   return match ? `${match[1]} confirmations` : null;
 }
 
-export { AccountingApiError, Button, FiatOnRampForm, HOSTED_AUTH_CLOCK_SKEW_MS, HostedAuthError, HostedAuthRequiredError, HostedAuthStateMismatchError, HttpClient, NETWORK_CONFIG, NetworkError, PrivanaClient, PrivanaProvider, SUPPORTED_CHAINS, SiweAuthProvider, Skeleton, ValidationError, applyRefreshResponse, buildHostedAuthSession, buildSiweStatement, buttonVariants, clearHostedAuthPendingTransaction, cn, createHostedAuthPendingStorageKey, createHostedAuthState, createHostedAuthStorageKey, createPkceChallenge, createPkceVerifier, formatTimeRemaining, formatTokenAmount, getAccountingContract, getApiUrl, getChainById, getChainId, getChainId2, getExplorerAddressUrl, getExplorerLabel, getTransactionReceipt, isHostedAuthRefreshActive, isHostedAuthSessionActive, normalizeAddress, normalizeHex, parseHostedAuthCallback, parseTokenAmount, persistHostedAuthPendingTransaction, readHostedAuthPendingTransaction, readStoredHostedAuthSession, shortenAddress, stripHostedAuthCallbackParams, syncHostedAuthSessionToClient, useDepositVerification, useFiatOnRamp, usePrivanaContext, usePrivateReadRequest, useSafeAccount, useSafePrivanaContext, useSiweAuth, waitForTransactionReceipt };
-//# sourceMappingURL=chunk-54FC6TO3.js.map
-//# sourceMappingURL=chunk-54FC6TO3.js.map
+export { AccountingApiError, Button, DEFAULT_LOCK_DURATION_SECONDS, DEFAULT_ONRAMP_LOCK_BUFFER, FiatOnRampForm, HOSTED_AUTH_CLOCK_SKEW_MS, HostedAuthError, HostedAuthRequiredError, HostedAuthStateMismatchError, HttpClient, LOCK_TYPES, MODIFY_LOCK_TYPES, NETWORK_CONFIG, NetworkError, PostDepositLockError, PrivanaClient, PrivanaProvider, SUPPORTED_CHAINS, SiweAuthProvider, Skeleton, TRANSFER_LOCKED_TYPES, TRANSFER_TYPES, ValidationError, WITHDRAW_FROM_LOCK_TYPES, WITHDRAW_TYPES, applyLockBuffer, applyRefreshResponse, buildHostedAuthSession, buildSiweStatement, buttonVariants, canUseBrowserStorage, clampLockAmount, clearHostedAuthPendingTransaction, clearPendingLock, cn, createDomain, createHostedAuthPendingStorageKey, createHostedAuthState, createHostedAuthStorageKey, createLockExpiry, createPkceChallenge, createPkceVerifier, createSignedLockRequest, formatCountdown, formatTimeRemaining, formatTokenAmount, getAccountingContract, getApiUrl, getBrowserStorageItem, getChainById, getChainId, getExplorerAddressUrl, getExplorerLabel, getTransactionReceipt, getWalletClient3 as getWalletClient, isHostedAuthRefreshActive, isHostedAuthSessionActive, isSignedLockUsable, loadPendingLock, normalizeAddress, normalizeHex, parseHostedAuthCallback, parseTokenAmount, persistHostedAuthPendingTransaction, readHostedAuthPendingTransaction, readStoredHostedAuthSession, removeBrowserStorageItem, savePendingLock, setBrowserStorageItem, shortenAddress, signLockMessage, signModifyLockMessage, signTransferLockedMessage, signTransferMessage, signWithdrawFromLockMessage, signWithdrawMessage, stripHostedAuthCallbackParams, submitPendingLock, syncHostedAuthSessionToClient, useDepositVerification, useEnsureCorrectChain, useFiatOnRamp, usePrivanaContext, usePrivateReadRequest, useSafeAccount, useSafePrivanaContext, useSiweAuth, waitForTransactionReceipt };
+//# sourceMappingURL=chunk-SAJ7K5WT.js.map
+//# sourceMappingURL=chunk-SAJ7K5WT.js.map