@coinbase/cdp-core 0.0.123 → 0.0.124

package/dist/web/index.web98.js

@@ -1,108 +1,135 @@
-import { Analytics as u } from "./index.web2.js";
-import "./index.web3.js";
-import { getCurrentUserSync as b } from "./index.web44.js";
+import { hashTypedData as m, serializeErc6492Signature as u, encodeFunctionData as g, pad as d, getTypesForEIP712Domain as p, hashMessage as A } from "viem";
+import { getCurrentUserSync as l } from "./index.web45.js";
 import "@coinbase/cdp-api-client";
+import "./index.web2.js";
+import "./index.web3.js";
 import "jose";
-import "viem";
-import "./index.web103.js";
-import { getConfig as S } from "./index.web74.js";
-import { getAccessToken as A } from "./index.web24.js";
-import { getAccessTokenExpiration as j } from "./index.web25.js";
-import { ensureMfaVerified as y } from "./index.web86.js";
-import { DEFAULT_SECURE_IFRAME_BASE_PATH as w, SECURE_IFRAME_KEY_EXPORT_EVENT_TYPE as n, DEFAULT_SECURE_IFRAME_THEME as k } from "./index.web97.js";
-import { validateSecureIframeEnvironment as g, createIframe as x, calculateSecureIframeHeight as U, buildKeyExportIframeUrl as L, getSecureIframeOrigin as v, isSecureIframeKeyExportMessage as R, sendSecureIframeMessage as l } from "./index.web96.js";
+import "./index.web110.js";
+import { signEvmHash as i } from "./index.web29.js";
+import { signEvmTransaction as h } from "./index.web30.js";
+import { signEvmMessage as f } from "./index.web31.js";
+import { signEvmTypedData as y } from "./index.web32.js";
 import "./index.web104.js";
+import "./index.web111.js";
 import "@solana/web3.js";
 import "bs58";
-let c = null;
-const C = async () => (c || (c = A({ forceRefresh: !0 }).finally(() => {
-  c = null;
-})), c);
-async function h(e) {
-  const r = x(e.target), I = U(e.theme), m = S().secureIframeBasePath || w;
-  r.setAttribute("allow", "clipboard-read; clipboard-write"), r.style.border = "none", r.style.display = "none", r.style.height = `${I}px`, r.src = L({ projectId: e.projectId, basePath: m });
-  const d = v(m);
-  let f = !1;
-  const E = () => {
-    f || (f = !0, window.removeEventListener("message", p), r.parentNode && r.parentNode.removeChild(r));
-  }, p = async (a) => {
-    if (a.source !== r.contentWindow || !d || a.origin !== d) return;
-    const i = a.data;
-    if (R(i))
-      switch (i.type) {
-        case n.LISTENING: {
-          try {
-            const t = b();
-            if (!t) {
-              e.onStatusUpdate?.("error", "User not authenticated");
-              return;
-            }
-            const o = await C(), s = await j();
-            l(r, {
-              type: n.GET_PRIVATE_KEY,
-              payload: {
-                address: e.address,
-                type: e.type,
-                authState: {
-                  accessToken: o || "",
-                  expiresAt: s || 0,
-                  user: t
-                },
-                theme: {
-                  ...k,
-                  ...e.theme || {}
-                },
-                config: {
-                  action: e.action,
-                  label: e.label,
-                  copiedLabel: e.copiedLabel,
-                  ejectLabel: e.ejectLabel ?? "Eject wallet",
-                  ejectingLabel: e.ejectingLabel ?? "Ejecting…",
-                  ejectedLabel: e.ejectedLabel ?? "Ejected",
-                  icon: e.icon,
-                  ejectIcon: e.ejectIcon,
-                  fullWidth: e.fullWidth
-                }
-              }
-            });
-          } catch (t) {
-            e.onStatusUpdate?.(
-              "error",
-              t instanceof Error ? "Error requesting private key: " + t.message : "Error requesting private key"
-            );
-          }
-          break;
-        }
-        case n.STATUS: {
-          const { status: t, message: o, operation: s, errorType: T, correlationId: _ } = i.payload;
-          t === "ready" && (r.style.display = "block"), t === "expired" && (r.style.display = "none", E()), e.onStatusUpdate?.(t, o, { operation: s, errorType: T, correlationId: _ });
-          break;
-        }
+import { COINBASE_SMART_WALLET_FACTORY_ADDRESS as v, COINBASE_SMART_WALLET_FACTORY_ABI as w } from "./index.web121.js";
+import { signAndWrapTypedDataForSmartAccount as E } from "./index.web122.js";
+import { toAccount as T } from "./index.web123.js";
+function U(r) {
+  const o = l();
+  if (!o || !o.evmAccountObjects?.length && !o.evmSmartAccountObjects?.length)
+    throw new Error(
+      "No accounts found - user must be authenticated and have at least one EVM account or smart account"
+    );
+  const s = r.toLowerCase(), c = o.evmAccountObjects?.some((e) => e.address.toLowerCase() === s) ?? !1, a = o.evmSmartAccountObjects?.some((e) => e.address.toLowerCase() === s) ?? !1;
+  if (!c && !a)
+    throw new Error(`Cannot sign for address ${r} - not authorized for this account`);
+  return T({
+    address: r,
+    /**
+     * Signs a message using CDP's message signing functionality.
+     * Supports string messages, hex strings, and byte arrays.
+     *
+     * @param root0 - The parameters object
+     * @param root0.message - The message to sign, can be a string, hex string, or byte array
+     * @returns The signature as a hex string
+     */
+    async signMessage({ message: e }) {
+      let t;
+      if (typeof e == "string")
+        t = (await f({
+          evmAccount: r,
+          message: e
+        })).signature;
+      else if ("raw" in e) {
+        const n = A(e);
+        t = (await i({
+          evmAccount: r,
+          hash: n
+        })).signature;
+      } else
+        throw new Error("Unsupported message format");
+      return t;
+    },
+    /**
+     * Signs a transaction using CDP's transaction signing functionality.
+     * Converts Viem's transaction format to CDP's AllowedEvmTransactionType.
+     *
+     * @param transaction - The transaction to sign in Viem's format
+     * @returns The signature as a hex string
+     */
+    async signTransaction(e) {
+      const t = {
+        to: e.to,
+        value: e.value,
+        data: e.data,
+        nonce: e.nonce,
+        gas: e.gas,
+        chainId: e.chainId ?? 1
+      };
+      return e.gasPrice !== void 0 ? (t.maxFeePerGas = e.gasPrice, t.maxPriorityFeePerGas = e.gasPrice) : (t.maxFeePerGas = e.maxFeePerGas, t.maxPriorityFeePerGas = e.maxPriorityFeePerGas), (await h({
+        evmAccount: r,
+        transaction: t
+      })).signedTransaction;
+    },
+    /**
+     * Signs EIP-712 typed data using CDP's typed data signing functionality.
+     * Handles domain separation and type encoding according to the EIP-712 specification.
+     * For smart accounts, implements replay-safe hash and signature wrapping.
+     *
+     * @param params - The typed data parameters following the EIP-712 specification
+     * @returns The signature as a hex string
+     */
+    async signTypedData(e) {
+      if (a) {
+        const t = await E({
+          smartAccount: r,
+          ownerAddress: o.evmAccountObjects?.[0]?.address,
+          hash: m(e),
+          chainId: Number(e.domain.chainId)
+        });
+        return u({
+          address: v,
+          data: g({
+            abi: w,
+            functionName: "createAccount",
+            args: [[d(o.evmAccountObjects?.[0]?.address)], 0n]
+          }),
+          signature: t.signature
+        });
+      } else {
+        const t = {
+          domain: e.domain,
+          types: {
+            EIP712Domain: p({
+              domain: e.domain
+            }),
+            ...e.types
+          },
+          primaryType: e.primaryType,
+          message: e.message
+        };
+        return (await y({
+          evmAccount: r,
+          typedData: t
+        })).signature;
       }
-  };
-  return window.addEventListener("message", p), {
-    iframe: r,
-    cleanup: E,
-    updateTheme: (a) => {
-      l(r, {
-        type: n.THEME,
-        payload: { theme: a }
-      });
     },
-    showEject: () => {
-      l(r, {
-        type: n.SHOW_EJECT
-      });
+    /**
+     * Signs a raw message hash using CDP's message signing functionality.
+     *
+     * @param message - The message hash to sign
+     * @returns The signature as a hex string
+     */
+    async sign(e) {
+      return (await i({
+        evmAccount: r,
+        hash: e.hash
+      })).signature;
     }
-  };
-}
-async function Q(e) {
-  return u.sendActionCallEvent({ name: "create_evm_key_export_iframe" }), g(), await y(), h({ ...e, type: "evm" });
-}
-async function Z(e) {
-  return u.sendActionCallEvent({ name: "create_solana_key_export_iframe" }), g(), await y(), h({ ...e, type: "solana" });
+  });
 }
 export {
-  Q as createEvmKeyExportIframe,
-  Z as createSolanaKeyExportIframe
+  U as toViemAccount
 };

package/dist/web/index.web99.js

@@ -1,45 +1,91 @@
-import { getTransactionEncoder as m, getTransactionDecoder as u, address as p } from "@solana/kit";
-import { getCurrentUserSync as f } from "./index.web44.js";
-import "@coinbase/cdp-api-client";
-import "./index.web2.js";
-import "./index.web3.js";
-import "jose";
-import "viem";
-import "./index.web103.js";
-import "./index.web97.js";
-import { signSolanaTransaction as g } from "./index.web32.js";
-import "./index.web104.js";
-import "@solana/web3.js";
-import "bs58";
-import { encodeBase64 as l, decodeBase64 as T } from "./index.web101.js";
-function N(o) {
-  const t = f();
-  if (!t || !t.solanaAccountObjects?.length)
-    throw new Error(
-      "No accounts found. User must be authenticated and have at least one Solana account"
-    );
-  const e = m(), a = u();
-  return {
-    address: p(o),
-    signTransactions: async (c, h) => {
-      const n = [];
-      for (const i of c) {
-        const s = new Uint8Array(e.encode(i)), { signedTransaction: d } = await g({
-          solanaAccount: o,
-          transaction: l(s)
-        }), r = a.decode(T(d)).signatures[o];
-        if (!r)
-          throw new Error("Wallet did not return a signature for the selected account.");
-        n.push(
-          Object.freeze({
-            [o]: r
-          })
-        );
-      }
-      return n;
-    }
-  };
+class n extends Error {
+  /**
+   * The name of the missing module.
+   */
+  moduleName;
+  /**
+   * The API or feature that requires the missing module.
+   */
+  requiredFor;
+  /**
+   * Creates a new ModuleResolutionError.
+   *
+   * @param moduleName - The name of the missing module.
+   * @param requiredFor - The API or feature that requires the module.
+   * @param message - Optional custom error message.
+   */
+  constructor(r, e, o) {
+    const t = `${e} is not available in this React Native environment. Please ensure ${r} is installed.`;
+    super(o || t), this.name = "ModuleResolutionError", this.moduleName = r, this.requiredFor = e;
+  }
+}
+class a extends Error {
+  /**
+   * Creates a new InputValidationError.
+   *
+   * @param message - The validation error message.
+   */
+  constructor(r) {
+    super(r), this.name = "InputValidationError";
+  }
+}
+class i extends Error {
+  /**
+   * Creates a new ValidationError.
+   *
+   * @param message - The validation error message.
+   */
+  constructor(r) {
+    super(r), this.name = "ValidationError";
+  }
+}
+class c extends Error {
+  /**
+   * Creates a new InternalError.
+   *
+   * @param message - The internal error message.
+   */
+  constructor(r) {
+    super(r), this.name = "InternalError";
+  }
+}
+class l extends Error {
+  /**
+   * The error code identifying the type of MFA error.
+   */
+  code;
+  /**
+   * Creates a new MfaError.
+   *
+   * @param code - The error code identifying the type of MFA error.
+   * @param message - The error message.
+   * @param options - Additional error options.
+   * @param options.cause - The underlying error this one was mapped from, when there is one.
+   */
+  constructor(r, e, o) {
+    super(e, o), this.name = "MfaError", this.code = r;
+  }
+}
+class u extends Error {
+  /**
+   * The error code identifying the type of swap failure.
+   */
+  code;
+  /**
+   * Creates a new SwapError.
+   *
+   * @param code - The error code identifying the type of swap failure.
+   * @param message - The error message.
+   */
+  constructor(r, e) {
+    super(e), this.name = "SwapError", this.code = r;
+  }
 }
 export {
-  N as toTransactionSigner
+  a as InputValidationError,
+  c as InternalError,
+  l as MfaError,
+  n as ModuleResolutionError,
+  u as SwapError,
+  i as ValidationError
 };

package/dist/web-types/actions/adjustBorrowPosition.d.ts

@@ -0,0 +1,79 @@
+import { PaymasterContext } from '@coinbase/cdp-api-client';
+import { EvmAddress, Hex } from '../types.js';
+/**
+ * Input for adjusting a borrow position.
+ * The borrow position owner is automatically detected from the current user.
+ */
+export type AdjustBorrowPositionOptions = {
+    /** The globally unique ID of the borrow product whose position to adjust. */
+    borrowProductId: string;
+    /**
+     * The amount of collateral to add to the position, as a decimal string in
+     * standard unit denomination of the collateral token (e.g., "1" for 1 cbBTC).
+     * Can be combined with `borrowLoanAmount`. Must not be combined with
+     * `removeCollateralAmount`.
+     */
+    addCollateralAmount?: string;
+    /**
+     * The amount of collateral to withdraw from the position, as a decimal string
+     * in standard unit denomination of the collateral token (e.g., "1" for
+     * 1 cbBTC). Can be combined with `repayLoanAmount`. Must not be combined with
+     * `addCollateralAmount`.
+     */
+    removeCollateralAmount?: string;
+    /**
+     * The amount of the loan token to repay, as a decimal string in standard unit
+     * denomination of the loan token (e.g., "100" for 100 USDC). Can be combined
+     * with `removeCollateralAmount`. Must not be combined with `borrowLoanAmount`.
+     */
+    repayLoanAmount?: string;
+    /**
+     * The amount of the loan token to borrow, as a decimal string in standard
+     * unit denomination of the loan token (e.g., "100" for 100 USDC). Can be
+     * combined with `addCollateralAmount`. Must not be combined with
+     * `repayLoanAmount`.
+     */
+    borrowLoanAmount?: string;
+    /** The EVM Smart Account that owns the borrow position. */
+    evmSmartAccount: EvmAddress;
+    /**
+     * Whether to use the CDP Paymaster for the user operation.
+     *
+     * Only available on Base.
+     */
+    useCdpPaymaster?: boolean;
+    /** The URL of the paymaster to use for the user operation. */
+    paymasterUrl?: string;
+    /** Optional paymaster metadata forwarded to the paymaster service. Valid only when a paymaster is configured. */
+    paymasterContext?: PaymasterContext;
+};
+/**
+ * Result of adjustBorrowPosition.
+ */
+export type AdjustBorrowPositionResult = {
+    /** The user operation hash. */
+    userOperationHash: Hex;
+};
+/**
+ * Adjusts an existing borrow position for the user's EVM Smart Account.
+ *
+ * Supplies collateral, withdraws collateral, repays debt, and/or borrows more
+ * of the loan asset for a specific borrow product. At least one operation
+ * amount must be supplied. Supplying collateral and borrowing more can be
+ * combined, as can withdrawing collateral and repaying debt. A user operation
+ * is broadcast to adjust the position onchain.
+ *
+ * @param options - The options for adjusting the borrow position.
+ * @example
+ * ```typescript lines
+ * const result = await adjustBorrowPosition({
+ *   borrowProductId: "bp_07fb56c0-9afe-5440-8ff2-5b0e115458df",
+ *   addCollateralAmount: "1", // add 1 cbBTC
+ *   borrowLoanAmount: "100", // borrow 100 more USDC
+ *   useCdpPaymaster: true,
+ *   evmSmartAccount: "0x742d35Cc6634C0532925a3b844Bc454e4438f44e",
+ * });
+ * ```
+ * @returns The result of the borrow position adjustment.
+ */
+export declare const adjustBorrowPosition: (options: AdjustBorrowPositionOptions) => Promise<AdjustBorrowPositionResult>;

package/dist/web-types/actions/closeBorrowPosition.d.ts

@@ -0,0 +1,49 @@
+import { PaymasterContext } from '@coinbase/cdp-api-client';
+import { EvmAddress, Hex } from '../types.js';
+/**
+ * Input for closing a borrow position.
+ * The borrow position owner is automatically detected from the current user.
+ */
+export type CloseBorrowPositionOptions = {
+    /** The globally unique ID of the borrow product whose position to close. */
+    borrowProductId: string;
+    /** The EVM Smart Account that owns the borrow position. */
+    evmSmartAccount: EvmAddress;
+    /**
+     * Whether to use the CDP Paymaster for the user operation.
+     *
+     * Only available on Base.
+     */
+    useCdpPaymaster?: boolean;
+    /** The URL of the paymaster to use for the user operation. */
+    paymasterUrl?: string;
+    /** Optional paymaster metadata forwarded to the paymaster service. Valid only when a paymaster is configured. */
+    paymasterContext?: PaymasterContext;
+};
+/**
+ * Result of closeBorrowPosition.
+ */
+export type CloseBorrowPositionResult = {
+    /** The user operation hash. */
+    userOperationHash: Hex;
+};
+/**
+ * Closes an existing borrow position for the user's EVM Smart Account.
+ *
+ * Fully repays the position's outstanding loan and withdraws all remaining
+ * collateral back to the smart account, broadcasting a single user operation
+ * to settle the position onchain. There is no partial close; use
+ * `adjustBorrowPosition` to adjust a position without closing it.
+ *
+ * @param options - The options for closing the borrow position.
+ * @example
+ * ```typescript lines
+ * const result = await closeBorrowPosition({
+ *   borrowProductId: "bp_07fb56c0-9afe-5440-8ff2-5b0e115458df",
+ *   evmSmartAccount: "0x742d35Cc6634C0532925a3b844Bc454e4438f44e",
+ *   useCdpPaymaster: true,
+ * });
+ * ```
+ * @returns The result of the borrow position close, containing the user operation hash.
+ */
+export declare const closeBorrowPosition: (options: CloseBorrowPositionOptions) => Promise<CloseBorrowPositionResult>;

package/dist/web-types/actions/createBorrowPosition.d.ts

@@ -0,0 +1,31 @@
+import { PaymasterContext } from '@coinbase/cdp-api-client';
+import { EvmAddress, Hex } from '../types.js';
+/** Input for creating a borrow position. */
+export type CreateBorrowPositionOptions = {
+    /** The globally unique ID of the borrow product to borrow against. */
+    borrowProductId: string;
+    /** The amount of collateral to post, in standard token units. */
+    collateralAmount: string;
+    /** The amount of the loan token to borrow, in standard token units. */
+    loanAmount: string;
+    /** The EVM Smart Account to open the borrow position from. */
+    evmSmartAccount: EvmAddress;
+    /** Whether to use the CDP Paymaster. */
+    useCdpPaymaster?: boolean;
+    /** The URL of the paymaster to use. */
+    paymasterUrl?: string;
+    /** Optional paymaster metadata forwarded to the paymaster service. Valid only when a paymaster is configured. */
+    paymasterContext?: PaymasterContext;
+};
+/** Result of creating a borrow position. */
+export type CreateBorrowPositionResult = {
+    /** The user operation hash. */
+    userOperationHash: Hex;
+};
+/**
+ * Creates a borrow position for the user's EVM Smart Account.
+ *
+ * @param options - The request parameters for creating a borrow position.
+ * @returns The result containing the user operation hash.
+ */
+export declare const createBorrowPosition: (options: CreateBorrowPositionOptions) => Promise<CreateBorrowPositionResult>;

package/dist/web-types/actions/getEvmBorrowProduct.d.ts

@@ -0,0 +1,22 @@
+import { BorrowProduct } from '@coinbase/cdp-api-client';
+/** Options for fetching a single EVM borrow product by ID. */
+export type GetEvmBorrowProductOptions = {
+    /** The globally unique ID of the borrow product to fetch. */
+    borrowProductId: string;
+};
+/** The result of fetching a single EVM borrow product. */
+export type GetEvmBorrowProductResult = BorrowProduct;
+/**
+ * Gets a single EVM borrow product by its ID.
+ *
+ * @param options - The request parameters including the `borrowProductId`.
+ * @returns The borrow product.
+ *
+ * @example
+ * ```typescript
+ * const borrowProduct = await getEvmBorrowProduct({
+ *   borrowProductId: "bp_07fb56c0-9afe-5440-8ff2-5b0e115458df",
+ * });
+ * ```
+ */
+export declare const getEvmBorrowProduct: (options: GetEvmBorrowProductOptions) => Promise<GetEvmBorrowProductResult>;

package/dist/web-types/actions/listBorrowPositions.d.ts

@@ -0,0 +1,36 @@
+import { BorrowPosition } from '@coinbase/cdp-api-client';
+import { EvmAddress } from '../types.js';
+/** Options for listing borrow positions for an EVM Smart Account. */
+export type ListBorrowPositionsOptions = {
+    /** The EVM Smart Account to list borrow positions for. */
+    evmSmartAccount: EvmAddress;
+    /** The number of resources to return per page. */
+    pageSize?: number;
+    /** The token for the next page of resources, if any. */
+    pageToken?: string;
+};
+/** A page of borrow positions held by a smart account. */
+export type ListBorrowPositionsResult = {
+    /** The borrow positions held by the smart account. */
+    borrowPositions: BorrowPosition[];
+    /** Whether there are more results available. */
+    hasNextPage: boolean;
+    /** The token for the next page of borrow positions, if any. */
+    nextPageToken: string | undefined;
+};
+/**
+ * Lists the borrow positions held by an EVM Smart Account for the signed-in end
+ * user, with the live onchain state of each position read at a point-in-time
+ * snapshot.
+ *
+ * @param options - The request parameters including the smart account address and optional pagination.
+ * @returns A page of borrow positions, a `hasNextPage` flag, and an optional `nextPageToken` for pagination.
+ *
+ * @example
+ * ```typescript
+ * const { borrowPositions, hasNextPage, nextPageToken } = await listBorrowPositions({
+ *   evmSmartAccount: "0x742d35Cc6634C0532925a3b844Bc454e4438f44e",
+ * });
+ * ```
+ */
+export declare const listBorrowPositions: (options: ListBorrowPositionsOptions) => Promise<ListBorrowPositionsResult>;

package/dist/web-types/actions/listEvmBorrowProducts.d.ts

@@ -0,0 +1,36 @@
+import { BorrowProduct, BorrowProductNetwork, BorrowProductProtocol } from '@coinbase/cdp-api-client';
+/** Options for listing EVM borrow products. */
+export type ListEvmBorrowProductsOptions = {
+    /** The EVM network to list borrow products for. Currently only `"base"` is supported. */
+    network?: BorrowProductNetwork;
+    /** The lending protocol whose borrow products to list. Currently only `"morpho_blue"` is supported. */
+    protocol?: BorrowProductProtocol;
+    /** The number of resources to return per page. */
+    pageSize?: number;
+    /** The token for the next page of resources, if any. */
+    pageToken?: string;
+};
+/** A page of EVM borrow products. */
+export type ListEvmBorrowProductsResult = {
+    /** The EVM borrow products on the requested network and protocol. */
+    borrowProducts: BorrowProduct[];
+    /** Whether there are more results available. */
+    hasNextPage: boolean;
+    /** The token for the next page of borrow products, if any. */
+    nextPageToken: string | undefined;
+};
+/**
+ * Lists the EVM borrow products available to the signed-in end user.
+ *
+ * @param options - The request parameters (network, protocol, optional pagination).
+ * @returns A page of borrow products and an optional `nextPageToken` for pagination.
+ *
+ * @example
+ * ```typescript
+ * const { borrowProducts, nextPageToken } = await listEvmBorrowProducts({
+ *   network: "base",
+ *   protocol: "morpho_blue",
+ * });
+ * ```
+ */
+export declare const listEvmBorrowProducts: (options?: ListEvmBorrowProductsOptions) => Promise<ListEvmBorrowProductsResult>;

package/dist/web-types/actions/refreshUser.d.ts

@@ -0,0 +1,22 @@
+import { User } from '../types.js';
+/**
+ * Re-fetches the signed-in user from the API and writes the result back into shared auth state.
+ *
+ * Unlike {@link getCurrentUser}, which returns the locally cached user (and only re-fetches, without
+ * caching, when `includeBtcXpubs` is set), `refreshUser` reconciles the local auth state with the
+ * server. Use it after accounts are provisioned for the current user out-of-band — i.e. created by a
+ * backend service via the End User API rather than by an in-SDK action such as
+ * `createEvmEoaAccount` / `createSolanaAccount`, which already update the cache themselves.
+ *
+ * Because the refreshed user is written via `setAuthState`, every `useCurrentUser` /
+ * `useEvmAccounts` / `useSolanaAccounts` subscriber re-renders, and subsequent signing actions
+ * (e.g. `signEvmHash`) recognize the newly provisioned accounts instead of throwing
+ * "EVM account not found" against a stale cache.
+ *
+ * This does not request Bitcoin xpubs, so the sensitivity concern that keeps `getCurrentUser`'s
+ * xpub re-fetch out of shared state does not apply here.
+ *
+ * @returns The refreshed user, or null if no user is signed in.
+ * @throws When the network request to re-fetch the user fails.
+ */
+export declare const refreshUser: () => Promise<User | null>;