@oasisprotocol/privana-sdk 0.5.0 → 0.5.1

package/dist/{chunk-ACLJPC75.cjs → chunk-4IW4V7YJ.cjs}

@@ -12,6 +12,7 @@ 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');
@@ -36,7 +37,7 @@ var config_default = {
     testnet: {
       chainId: 23295,
       name: "Sapphire Testnet",
-      accountingContract: "0xaF8e5de153A584528B57DD4B9B0195956BBDF571",
+      accountingContract: "0xad3C76e4E621C0cfF7540479Ee9B0A945723A642",
       apiUrl: "https://api.testnet.privana.finance"
     },
     mainnet: {
@@ -374,6 +375,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}`);
@@ -625,6 +639,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,
@@ -1170,6 +1380,205 @@ function usePrivanaContext() {
 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;
@@ -1401,7 +1810,7 @@ function useDepositVerification(options = {}) {
   const runVerification = react.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);
@@ -1429,7 +1838,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)) {
@@ -1634,6 +2044,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 = 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",
   {
@@ -1702,6 +2118,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 = 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;
@@ -1712,6 +2320,10 @@ async function getTransactionReceipt(config, parameters) {
   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 });
@@ -1739,6 +2351,59 @@ async function waitForTransactionReceipt(config, parameters) {
     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;
@@ -1746,14 +2411,26 @@ var ERC20_TRANSFER_EVENT = viem.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 } = 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([]);
@@ -1764,20 +2441,27 @@ function useFiatOnRamp(options) {
   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, onError, onDebugEvent]);
+  }, [onCredited, onLockSubmitted, onLockFailed, onError, onDebugEvent]);
   react.useEffect(() => {
     statusRef.current = status;
   }, [status]);
@@ -1858,13 +2542,64 @@ function useFiatOnRamp(options) {
   react.useEffect(() => {
     refreshPending();
   }, [refreshPending]);
-  const clearActiveVerification = react.useCallback(() => {
+  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,
@@ -1880,6 +2615,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
@@ -1894,6 +2630,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 {
@@ -1916,7 +2664,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);
@@ -1954,7 +2702,8 @@ function useFiatOnRamp(options) {
     async ({
       currencyCode,
       baseCurrencyCode,
-      baseCurrencyAmount
+      baseCurrencyAmount,
+      quoteCurrencyAmount
     }) => {
       try {
         setError(null);
@@ -1962,12 +2711,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(
+            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(
@@ -1980,6 +2751,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", {
@@ -1995,7 +2788,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 = react.useCallback(
     async (moonpayTransactionId) => {
@@ -2117,6 +2924,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;
@@ -2167,6 +2980,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");
         }
@@ -2185,6 +2999,7 @@ function useFiatOnRamp(options) {
         if (activeVerificationKeyRef.current === verificationKey) {
           activeVerificationKeyRef.current = null;
           activeVerificationRecordRef.current = null;
+          activeVerificationAmountRef.current = null;
           setActiveVerificationId(null);
         }
         throw err;
@@ -2243,6 +3058,7 @@ function useFiatOnRamp(options) {
           previousStatus,
           transactionId
         });
+        if (address) clearPendingLock(address, transactionId);
         await refreshPending();
         if (previousStatus === "awaiting-purchase" || previousStatus === "awaiting-delivery") {
           setStatus("idle");
@@ -2273,7 +3089,7 @@ function useFiatOnRamp(options) {
     } finally {
       closeReconcilePromiseRef.current = null;
     }
-  }, [emitDebug, refreshPending, triggerVerification, waitForOnChainHash]);
+  }, [address, emitDebug, refreshPending, triggerVerification, waitForOnChainHash]);
   const finishPendingVerification = react.useCallback(
     async (record) => {
       try {
@@ -2307,6 +3123,12 @@ function useFiatOnRamp(options) {
         try {
           await triggerVerificationRef.current(record);
         } catch {
+          continue;
+        }
+        if (activeVerificationKeyRef.current === key) {
+          await new Promise((resolve) => {
+            activeVerificationDoneRef.current = resolve;
+          });
         }
       }
     })();
@@ -2423,6 +3245,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,
@@ -2480,6 +3308,7 @@ function useMoonPayBuyWidget({
   colorCode,
   baseCurrencyCode,
   baseCurrencyAmount,
+  quoteCurrencyAmount,
   lockAmount,
   paymentMethod,
   currencyCode,
@@ -2539,6 +3368,7 @@ function useMoonPayBuyWidget({
         overlayNode,
         baseCurrencyCode,
         baseCurrencyAmount,
+        quoteCurrencyAmount,
         lockAmount: lockAmount ? "true" : void 0,
         paymentMethod,
         currencyCode,
@@ -2564,6 +3394,7 @@ function useMoonPayBuyWidget({
     overlayNode,
     baseCurrencyCode,
     baseCurrencyAmount,
+    quoteCurrencyAmount,
     lockAmount,
     paymentMethod,
     currencyCode,
@@ -2582,6 +3413,7 @@ function FiatOnRampForm({
   currencyCode,
   baseCurrencyCode = "usd",
   defaultBaseCurrencyAmount = "100",
+  quoteCurrencyAmount,
   tokenSymbol,
   theme,
   themeId,
@@ -2590,7 +3422,10 @@ function FiatOnRampForm({
   autoStart = false,
   lockAmount,
   paymentMethod,
+  postDepositLock,
   onCredited,
+  onLockSubmitted,
+  onLockFailed,
   onError,
   onDebugEvent
 }) {
@@ -2598,6 +3433,8 @@ function FiatOnRampForm({
   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,
@@ -2615,7 +3452,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 = react.useCallback(
@@ -2631,8 +3486,17 @@ function FiatOnRampForm({
     [onDebugEvent, status, tokenId]
   );
   const minFiatGate = minDepositBaseUnits !== void 0 && decimals !== void 0 ? Number(viem.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: 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";
@@ -2642,9 +3506,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 = react.useCallback(async () => {
@@ -2663,6 +3528,8 @@ function FiatOnRampForm({
       return;
     }
     setIsPreparing(true);
+    setLockError(null);
+    setLockSettled(false);
     emitFormDebug("form:open-click", {
       currencyCode,
       tokenSymbol: displaySymbol,
@@ -2676,7 +3543,8 @@ function FiatOnRampForm({
       const intent = await prepareOnRampIntent({
         currencyCode,
         baseCurrencyCode,
-        baseCurrencyAmount: defaultBaseCurrencyAmount
+        baseCurrencyAmount: defaultBaseCurrencyAmount,
+        quoteCurrencyAmount
       });
       emitFormDebug("form:intent-ready", {
         transactionId: intent.transaction_id,
@@ -2701,6 +3569,7 @@ function FiatOnRampForm({
     decimals,
     displaySymbol,
     defaultBaseCurrencyAmount,
+    quoteCurrencyAmount,
     depositAddress,
     emitFormDebug,
     prepareOnRampIntent,
@@ -2731,6 +3600,7 @@ function FiatOnRampForm({
     colorCode,
     baseCurrencyCode,
     baseCurrencyAmount: defaultBaseCurrencyAmount,
+    quoteCurrencyAmount,
     lockAmount,
     paymentMethod,
     currencyCode,
@@ -2803,7 +3673,7 @@ function FiatOnRampForm({
         );
       })
     ] }),
-    status === "credited" && /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex flex-col items-center gap-2 py-8 text-center", children: [
+    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: [
@@ -2812,12 +3682,20 @@ function FiatOnRampForm({
         " 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),
@@ -2837,43 +3715,63 @@ function parseFinalityProgress(message) {
 
 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.getChainId2 = getChainId2;
 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;
@@ -2881,10 +3779,21 @@ 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;
@@ -2892,5 +3801,5 @@ exports.useSafeAccount = useSafeAccount;
 exports.useSafePrivanaContext = useSafePrivanaContext;
 exports.useSiweAuth = useSiweAuth;
 exports.waitForTransactionReceipt = waitForTransactionReceipt;
-//# sourceMappingURL=chunk-ACLJPC75.cjs.map
-//# sourceMappingURL=chunk-ACLJPC75.cjs.map
+//# sourceMappingURL=chunk-4IW4V7YJ.cjs.map
+//# sourceMappingURL=chunk-4IW4V7YJ.cjs.map