solariskit 1.4.0 → 1.6.0

package/dist/ChainSelectButton-BcLkwhod.d.ts

@@ -0,0 +1,187 @@
+
+import React, { ReactNode } from "react";
+import { Chain } from "wagmi/chains";
+import { RequiredConditionalValue } from "@vanilla-extract/sprinkles";
+//#region src/css/sprinkles.css.d.ts
+declare const themeContractValues: {
+  colors: {
+    accentColor: string;
+    accentColorForeground: string;
+    actionButtonBorder: string;
+    actionButtonBorderMobile: string;
+    actionButtonSecondaryBackground: string;
+    closeButton: string;
+    closeButtonBackground: string;
+    connectButtonBackground: string;
+    connectButtonBackgroundError: string;
+    connectButtonInnerBackground: string;
+    connectButtonText: string;
+    connectButtonTextError: string;
+    connectionIndicator: string;
+    downloadBottomCardBackground: string;
+    downloadTopCardBackground: string;
+    error: string;
+    generalBorder: string;
+    generalBorderDim: string;
+    menuItemBackground: string;
+    modalBackdrop: string;
+    modalBackground: string;
+    modalBorder: string;
+    modalText: string;
+    modalTextDim: string;
+    modalTextSecondary: string;
+    profileAction: string;
+    profileActionHover: string;
+    profileForeground: string;
+    selectedOptionBorder: string;
+    standby: string;
+  };
+  fonts: {
+    body: string;
+  };
+  radii: {
+    actionButton: string;
+    connectButton: string;
+    menuButton: string;
+    modal: string;
+    modalMobile: string;
+  };
+  shadows: {
+    connectButton: string;
+    dialog: string;
+    profileDetailsAction: string;
+    selectedOption: string;
+    selectedWallet: string;
+    walletLogo: string;
+  };
+  blurs: {
+    modalOverlay: string;
+  };
+};
+type ThemeVars = typeof themeContractValues;
+declare const responsiveProperties: {
+  conditions: {
+    defaultCondition: "smallScreen";
+    conditionNames: ("smallScreen" | "largeScreen")[];
+  };
+  styles: {
+    alignItems: {
+      values: {
+        center: {
+          defaultClass: string;
+          conditions: {
+            smallScreen: string;
+            largeScreen: string;
+          };
+        };
+        "flex-end": {
+          defaultClass: string;
+          conditions: {
+            smallScreen: string;
+            largeScreen: string;
+          };
+        };
+        "flex-start": {
+          defaultClass: string;
+          conditions: {
+            smallScreen: string;
+            largeScreen: string;
+          };
+        };
+      };
+    };
+    display: {
+      values: {
+        flex: {
+          defaultClass: string;
+          conditions: {
+            smallScreen: string;
+            largeScreen: string;
+          };
+        };
+        none: {
+          defaultClass: string;
+          conditions: {
+            smallScreen: string;
+            largeScreen: string;
+          };
+        };
+        block: {
+          defaultClass: string;
+          conditions: {
+            smallScreen: string;
+            largeScreen: string;
+          };
+        };
+        inline: {
+          defaultClass: string;
+          conditions: {
+            smallScreen: string;
+            largeScreen: string;
+          };
+        };
+      };
+    };
+  };
+};
+type ResponsiveValue<Value extends string | number | boolean> = RequiredConditionalValue<typeof responsiveProperties, Value>;
+//#endregion
+//#region src/components/RainbowKitProvider/AppContext.d.ts
+type DisclaimerComponent = React.FunctionComponent<{
+  Text: React.FunctionComponent<{
+    children: ReactNode;
+  }>;
+  Link: React.FunctionComponent<{
+    children: ReactNode;
+    href: string;
+  }>;
+}>;
+//#endregion
+//#region src/components/RainbowKitProvider/AvatarContext.d.ts
+type AvatarComponentProps = {
+  address: string;
+  ensImage?: string | null;
+  size: number;
+};
+type AvatarComponent = React.FunctionComponent<AvatarComponentProps>;
+//#endregion
+//#region src/components/RainbowKitProvider/ModalSizeContext.d.ts
+declare const ModalSizeOptions: {
+  readonly COMPACT: "compact";
+  readonly WIDE: "wide";
+};
+type ModalSizes = (typeof ModalSizeOptions)[keyof typeof ModalSizeOptions];
+//#endregion
+//#region src/components/RainbowKitProvider/RainbowKitProvider.d.ts
+type Theme = ThemeVars | {
+  lightMode: ThemeVars;
+  darkMode: ThemeVars;
+};
+interface RainbowKitProviderProps {
+  initialChain?: Chain | number;
+  chainSearchThreshold?: number;
+  id?: string;
+  children: ReactNode;
+  theme?: Theme | null;
+  showRecentTransactions?: boolean;
+  appInfo?: {
+    appName?: string;
+    learnMoreUrl?: string;
+    disclaimer?: DisclaimerComponent;
+  };
+  avatar?: AvatarComponent;
+  modalSize?: ModalSizes;
+}
+declare function RainbowKitProvider({ appInfo, avatar, chainSearchThreshold, children, id, initialChain, modalSize, showRecentTransactions, theme }: RainbowKitProviderProps): React.JSX.Element;
+//#endregion
+//#region src/components/ConnectButton/ConnectButtonView.d.ts
+type AccountStatus = "full" | "avatar" | "address";
+//#endregion
+//#region src/components/ChainSelectButton/ChainSelectButton.d.ts
+type ChainStatus = "full" | "icon" | "name" | "none";
+interface ChainSelectButtonProps {
+  chainStatus?: ResponsiveValue<ChainStatus>;
+}
+declare function ChainSelectButton({ chainStatus }: ChainSelectButtonProps): React.JSX.Element | null;
+//#endregion
+export { RainbowKitProvider as a, ModalSizes as c, DisclaimerComponent as d, ResponsiveValue as f, AccountStatus as i, AvatarComponent as l, ChainSelectButtonProps as n, RainbowKitProviderProps as o, ThemeVars as p, ChainStatus as r, Theme as s, ChainSelectButton as t, AvatarComponentProps as u };

package/dist/RainbowKitProvider-D6tnZRYJ.js

@@ -0,0 +1,271 @@
+"use client";
+import { A as clearLatestWalletId, At as useHydrated, Ct as useRainbowKitChains, D as useWalletConnectors, Dt as useIsMounted, E as preloadAssetsIcon, Et as isChainIdSupported, G as AppContext, H as defaultAvatar, J as ShowRecentTransactionsContext, K as defaultAppInfo, O as isNotNullish, Ot as ShowBalanceProvider, Pt as useAuthenticationStatus, St as RainbowKitChainProvider, T as preloadLoginIcon, V as AvatarContext, X as formatAddress, Y as formatENS, Z as abbreviateETHBalance, _t as TransactionStoreProvider, a as NetworkSelectButtonView, at as WalletButtonProvider, b as clearWalletConnectDeepLink, bt as useSelectedChainId, c as defaultConnectButtonProps, ct as ThemeRootStyle, d as useAccountModal, f as useChainModal, g as signInIcon, gt as useRecentTransactions, ht as useAsyncImage, i as WalletButtonView, it as WalletButtonContext, j as getLatestWalletId, jt as useConnectionStatus, k as addLatestWalletId, kt as useShowBalance, l as resolveShowBalance, lt as useThemeRoot, m as useModalState, mt as loadImages, n as lightTheme, nt as ModalSizeOptions, o as defaultNetworkSelectChainStatus, p as useConnectModal, pt as isMobile, rt as ModalSizeProvider, s as ConnectButtonView, st as ThemeIdProvider, t as useFingerprint, u as ModalProvider, wt as useRainbowKitChainsById, xt as useProfile } from "./useFingerprint-DGiyXD_j.js";
+import React, { useCallback, useContext, useEffect, useMemo, useState } from "react";
+import { useConfig, useConnection, useConnectionEffect } from "wagmi";
+import { Fragment as Fragment$1, jsx } from "react/jsx-runtime";
+
+//#region src/components/ConnectButton/ConnectButtonRenderer.tsx
+const noop = () => {};
+function ConnectButtonRenderer({ children }) {
+	const isMounted = useIsMounted();
+	const { address, chainId: connectedChainId } = useConnection();
+	const chainId = useSelectedChainId(connectedChainId);
+	const { chains: wagmiChains } = useConfig();
+	const isConnectedChainSupported = connectedChainId ? isChainIdSupported(wagmiChains, connectedChainId) : true;
+	const rainbowkitChainsById = useRainbowKitChainsById();
+	const authenticationStatus = useAuthenticationStatus() ?? void 0;
+	const rainbowKitChain = chainId ? rainbowkitChainsById[chainId] : void 0;
+	const chainName = rainbowKitChain?.name ?? void 0;
+	const chainIconUrl = rainbowKitChain?.iconUrl ?? void 0;
+	const chainIconBackground = rainbowKitChain?.iconBackground ?? void 0;
+	const resolvedChainIconUrl = useAsyncImage(chainIconUrl);
+	const showRecentTransactions = useContext(ShowRecentTransactionsContext);
+	const hasPendingTransactions = useRecentTransactions().some(({ status }) => status === "pending") && showRecentTransactions;
+	const { showBalance } = useShowBalance();
+	const { balance, ensAvatar, ensName } = useProfile({
+		address,
+		includeBalance: resolveShowBalance(showBalance)
+	});
+	const displayBalance = balance ? `${abbreviateETHBalance(Number.parseFloat(balance.formatted))} ${balance.symbol}` : void 0;
+	const { openConnectModal } = useConnectModal();
+	const { openChainModal } = useChainModal();
+	const { openAccountModal } = useAccountModal();
+	const { accountModalOpen, chainModalOpen, connectModalOpen } = useModalState();
+	return /* @__PURE__ */ jsx(Fragment$1, { children: children({
+		account: address ? {
+			address,
+			balanceDecimals: balance?.decimals,
+			balanceFormatted: balance?.formatted,
+			balanceSymbol: balance?.symbol,
+			displayBalance,
+			displayName: ensName ? formatENS(ensName) : formatAddress(address),
+			ensAvatar: ensAvatar ?? void 0,
+			ensName: ensName ?? void 0,
+			hasPendingTransactions
+		} : void 0,
+		accountModalOpen,
+		authenticationStatus,
+		chain: chainId ? {
+			hasIcon: Boolean(chainIconUrl),
+			iconBackground: chainIconBackground,
+			iconUrl: resolvedChainIconUrl,
+			id: chainId,
+			name: chainName,
+			unsupported: !isConnectedChainSupported
+		} : void 0,
+		chainModalOpen,
+		connectModalOpen,
+		mounted: isMounted(),
+		openAccountModal: openAccountModal ?? noop,
+		openChainModal: openChainModal ?? noop,
+		openConnectModal: openConnectModal ?? noop
+	}) });
+}
+ConnectButtonRenderer.displayName = "ConnectButton.Custom";
+
+//#endregion
+//#region src/components/ConnectButton/ConnectButton.tsx
+const defaultProps = defaultConnectButtonProps;
+function ConnectButton({ accountStatus = defaultProps.accountStatus, label = defaultProps.label, showBalance = defaultProps.showBalance }) {
+	const connectionStatus = useConnectionStatus();
+	const { setShowBalance } = useShowBalance();
+	const hydrated = useHydrated();
+	useEffect(() => {
+		setShowBalance(showBalance);
+	}, [setShowBalance, showBalance]);
+	return hydrated ? /* @__PURE__ */ jsx(ConnectButtonRenderer, { children: ({ account, mounted, openAccountModal, openConnectModal }) => {
+		return /* @__PURE__ */ jsx(ConnectButtonView, {
+			account,
+			accountStatus,
+			buttonReady: mounted && connectionStatus !== "loading",
+			isConnected: connectionStatus === "connected",
+			label,
+			mounted,
+			onOpenAccountModal: openAccountModal,
+			onOpenConnectModal: openConnectModal,
+			showBalance
+		});
+	} }) : null;
+}
+ConnectButton.Custom = ConnectButtonRenderer;
+
+//#endregion
+//#region src/components/ChainSelectButton/ChainSelectButton.tsx
+function ChainSelectButton({ chainStatus = defaultNetworkSelectChainStatus }) {
+	const chains = useRainbowKitChains();
+	const chainsById = useRainbowKitChainsById();
+	const connectionStatus = useConnectionStatus();
+	const { openChainModal } = useChainModal();
+	const { chainId: connectedChainId } = useConnection();
+	const chainId = useSelectedChainId(connectedChainId);
+	const { chains: wagmiChains } = useConfig();
+	const isConnectedChainSupported = connectedChainId ? isChainIdSupported(wagmiChains, connectedChainId) : true;
+	const hydrated = useHydrated();
+	const chainMetadata = chainId ? chainsById[chainId] : void 0;
+	const resolvedChainIconUrl = useAsyncImage(chainMetadata?.iconUrl ?? void 0);
+	const chain = chainId ? {
+		hasIcon: Boolean(chainMetadata?.iconUrl),
+		iconBackground: chainMetadata?.iconBackground,
+		iconUrl: resolvedChainIconUrl,
+		id: chainId,
+		name: chainMetadata?.name ?? void 0,
+		unsupported: !isConnectedChainSupported
+	} : void 0;
+	if (!hydrated) return null;
+	return /* @__PURE__ */ jsx(NetworkSelectButtonView, {
+		buttonReady: connectionStatus !== "loading",
+		chainStatus,
+		network: chain,
+		networkCount: chains.length,
+		onOpenNetworkModal: openChainModal
+	});
+}
+
+//#endregion
+//#region src/components/WalletButton/WalletButtonRenderer.tsx
+function WalletButtonRenderer({ wallet = "rainbow", children }) {
+	const isMounted = useIsMounted();
+	const { openConnectModal } = useConnectModal();
+	const { connectModalOpen } = useModalState();
+	const { connector, setConnector } = useContext(WalletButtonContext);
+	const [firstConnector] = useWalletConnectors().filter((wallet) => wallet.isRainbowKitConnector).filter((_wallet) => _wallet.id.toLowerCase() === wallet.toLowerCase() || _wallet.aliases?.some((alias) => alias.toLowerCase() === wallet.toLowerCase())).sort((a, b) => a.groupIndex - b.groupIndex);
+	if (!firstConnector) throw new Error("Connector not found");
+	const connectionStatus = useConnectionStatus();
+	const [loading, setLoading] = useState(false);
+	const [isError, setIsError] = useState(false);
+	const mobile = isMobile();
+	useEffect(() => {
+		if (!connectModalOpen && connector) setConnector(null);
+	}, [
+		connectModalOpen,
+		connector,
+		setConnector
+	]);
+	const { isConnected, isConnecting } = useConnection();
+	useConnectionEffect({
+		onConnect: () => {
+			if (isError) setIsError(false);
+		},
+		onDisconnect: clearLatestWalletId
+	});
+	const isLastWalletIdConnected = useMemo(() => {
+		const lastWalletId = getLatestWalletId();
+		if (!lastWalletId || !firstConnector?.id) return false;
+		if (!isConnected) return false;
+		return lastWalletId === firstConnector?.id;
+	}, [isConnected, firstConnector]);
+	const connectWallet = async () => {
+		try {
+			setLoading(true);
+			if (isError) setIsError(false);
+			await firstConnector?.connect?.();
+		} catch {
+			setIsError(true);
+		} finally {
+			setLoading(false);
+		}
+	};
+	const ready = !isConnecting && !!openConnectModal && firstConnector && !(connectionStatus === "loading");
+	const isNotSupported = !firstConnector?.installed || !firstConnector?.ready;
+	return /* @__PURE__ */ jsx(Fragment$1, { children: children({
+		error: isError,
+		loading,
+		connected: isLastWalletIdConnected,
+		ready,
+		mounted: isMounted(),
+		connector: firstConnector,
+		connect: async () => {
+			addLatestWalletId(firstConnector?.id || "");
+			if (mobile || isNotSupported) {
+				openConnectModal?.();
+				setConnector(firstConnector);
+				return;
+			}
+			await connectWallet();
+		}
+	}) });
+}
+
+//#endregion
+//#region src/components/WalletButton/WalletButton.tsx
+const WalletButton = ({ wallet }) => {
+	return /* @__PURE__ */ jsx(WalletButtonRenderer, {
+		wallet,
+		children: ({ ready, connect, connected, mounted, connector, loading }) => {
+			return /* @__PURE__ */ jsx(WalletButtonView, {
+				connected,
+				connector,
+				loading,
+				mounted,
+				onConnect: connect,
+				ready
+			});
+		}
+	});
+};
+WalletButton.Custom = WalletButtonRenderer;
+
+//#endregion
+//#region src/components/RainbowKitProvider/usePreloadImages.ts
+function usePreloadImages() {
+	const rainbowKitChains = useRainbowKitChains();
+	const walletConnectors = useWalletConnectors();
+	const isUnauthenticated = useAuthenticationStatus() === "unauthenticated";
+	const preloadImages = useCallback(() => {
+		loadImages(...walletConnectors.map((wallet) => wallet.iconUrl), ...rainbowKitChains.map((chain) => chain.iconUrl).filter(isNotNullish));
+		if (!isMobile()) {
+			preloadAssetsIcon();
+			preloadLoginIcon();
+		}
+		if (isUnauthenticated) loadImages(signInIcon);
+	}, [
+		walletConnectors,
+		rainbowKitChains,
+		isUnauthenticated
+	]);
+	useEffect(() => {
+		preloadImages();
+	}, [preloadImages]);
+}
+
+//#endregion
+//#region src/components/RainbowKitProvider/RainbowKitProvider.tsx
+const defaultTheme = lightTheme();
+function RainbowKitProvider({ appInfo, avatar, chainSearchThreshold, children, id, initialChain, modalSize = ModalSizeOptions.WIDE, showRecentTransactions = false, theme = defaultTheme }) {
+	usePreloadImages();
+	useFingerprint();
+	useConnectionEffect({ onDisconnect: clearWalletConnectDeepLink });
+	const { themeCss, themeId } = useThemeRoot(id, theme);
+	const appContext = useMemo(() => ({
+		...defaultAppInfo,
+		...appInfo
+	}), [appInfo]);
+	const avatarContext = avatar ?? defaultAvatar;
+	return /* @__PURE__ */ jsx(RainbowKitChainProvider, {
+		chainSearchThreshold,
+		initialChain,
+		children: /* @__PURE__ */ jsx(WalletButtonProvider, { children: /* @__PURE__ */ jsx(ModalSizeProvider, {
+			modalSize,
+			children: /* @__PURE__ */ jsx(ShowRecentTransactionsContext.Provider, {
+				value: showRecentTransactions,
+				children: /* @__PURE__ */ jsx(TransactionStoreProvider, { children: /* @__PURE__ */ jsx(AvatarContext.Provider, {
+					value: avatarContext,
+					children: /* @__PURE__ */ jsx(AppContext.Provider, {
+						value: appContext,
+						children: /* @__PURE__ */ jsx(ThemeIdProvider, {
+							id: themeId,
+							children: /* @__PURE__ */ jsx(ShowBalanceProvider, { children: /* @__PURE__ */ jsx(ModalProvider, { children: /* @__PURE__ */ jsx(ThemeRootStyle, {
+								themeCss,
+								themeId,
+								children
+							}) }) })
+						})
+					})
+				}) })
+			})
+		}) })
+	});
+}
+
+//#endregion
+export { ConnectButton as i, WalletButton as n, ChainSelectButton as r, RainbowKitProvider as t };

package/dist/{Wallet-epUweMuA.d.ts → Wallet-BhiBD1Pn.d.ts}

@@ -1,16 +1,12 @@
 
 import { Connector, CreateConnectorFn } from "wagmi";
 import { WalletConnectParameters } from "wagmi/connectors";
-
 //#region src/wallets/walletConnectors/walletConnectWallet/walletConnectWallet.d.ts
 interface WalletConnectWalletOptions {
   projectId: string;
   options?: RainbowKitWalletConnectParameters;
 }
-declare const walletConnectWallet: ({
-  projectId,
-  options
-}: WalletConnectWalletOptions) => Wallet;
+declare const walletConnectWallet: ({ projectId, options }: WalletConnectWalletOptions) => Wallet;
 //#endregion
 //#region src/wallets/Wallet.d.ts
 type RainbowKitConnector = {

package/dist/WalletButton-Dc_yPK_E.d.ts

@@ -0,0 +1,114 @@
+
+import { f as ResponsiveValue, i as AccountStatus } from "./ChainSelectButton-BcLkwhod.js";
+import { o as WalletInstance } from "./Wallet-BhiBD1Pn.js";
+import React, { JSX, ReactNode } from "react";
+import { Address, SignableMessage } from "viem";
+//#region src/components/RainbowKitProvider/AuthenticationContext.d.ts
+type AuthenticationStatus = "loading" | "unauthenticated" | "authenticated";
+interface AuthenticationAdapter<Message extends SignableMessage> {
+  getNonce: () => Promise<string>;
+  createMessage: (args: {
+    nonce: string;
+    address: Address;
+    chainId: number;
+  }) => Promise<Message> | Message;
+  verify: (args: {
+    message: Message;
+    signature: string;
+  }) => Promise<boolean>;
+  signOut: () => Promise<void>;
+}
+interface AuthenticationConfig<Message extends SignableMessage> {
+  adapter: AuthenticationAdapter<Message>;
+  status: AuthenticationStatus;
+}
+declare function createAuthenticationAdapter<Message extends SignableMessage>(adapter: AuthenticationAdapter<Message>): AuthenticationAdapter<Message>;
+interface RainbowKitAuthenticationProviderProps<Message extends SignableMessage> extends AuthenticationConfig<Message> {
+  enabled?: boolean;
+  children: ReactNode;
+}
+declare function RainbowKitAuthenticationProvider<Message extends SignableMessage = SignableMessage>({ adapter, children, enabled, status }: RainbowKitAuthenticationProviderProps<Message>): React.JSX.Element;
+//#endregion
+//#region src/components/ConnectButton/ConnectButtonRenderer.d.ts
+interface ConnectButtonRendererProps {
+  children: (renderProps: {
+    account?: {
+      address: string;
+      balanceDecimals?: number;
+      balanceFormatted?: string;
+      balanceSymbol?: string;
+      displayBalance?: string;
+      displayName: string;
+      ensAvatar?: string;
+      ensName?: string;
+      hasPendingTransactions: boolean;
+    };
+    chain?: {
+      hasIcon: boolean;
+      iconUrl?: string;
+      iconBackground?: string;
+      id: number;
+      name?: string;
+      unsupported?: boolean;
+    };
+    mounted: boolean;
+    authenticationStatus?: AuthenticationStatus;
+    openAccountModal: () => void;
+    openChainModal: () => void;
+    openConnectModal: () => void;
+    accountModalOpen: boolean;
+    chainModalOpen: boolean;
+    connectModalOpen: boolean;
+  }) => ReactNode;
+}
+declare function ConnectButtonRenderer({ children }: ConnectButtonRendererProps): React.JSX.Element;
+declare namespace ConnectButtonRenderer {
+  var displayName: string;
+}
+//#endregion
+//#region src/components/ConnectButton/ConnectButton.d.ts
+interface ConnectButtonProps {
+  accountStatus?: ResponsiveValue<AccountStatus>;
+  showBalance?: ResponsiveValue<boolean>;
+  label?: string;
+}
+declare function ConnectButton({ accountStatus, label, showBalance }: ConnectButtonProps): React.JSX.Element | null;
+declare namespace ConnectButton {
+  var Custom: typeof ConnectButtonRenderer;
+}
+//#endregion
+//#region src/wallets/useWalletConnectors.d.ts
+interface WalletConnector extends WalletInstance {
+  ready?: boolean;
+  connect: WalletInstance["connect"];
+  showWalletConnectModal?: () => void;
+  recent: boolean;
+  getDesktopUri?: () => Promise<string>;
+  getQrCodeUri?: () => Promise<string>;
+  getMobileUri?: () => Promise<string>;
+}
+//#endregion
+//#region src/components/WalletButton/WalletButtonRenderer.d.ts
+interface WalletButtonRendererProps {
+  wallet?: string;
+  children: (renderProps: {
+    error: boolean;
+    loading: boolean;
+    connected: boolean;
+    ready: boolean;
+    mounted: boolean;
+    connector: WalletConnector;
+    connect: () => Promise<void>;
+  }) => ReactNode;
+}
+//#endregion
+//#region src/components/WalletButton/WalletButton.d.ts
+interface WalletButtonProps {
+  wallet?: string;
+}
+declare const WalletButton: {
+  (props: WalletButtonProps): JSX.Element | undefined;
+  Custom: (props: WalletButtonRendererProps) => ReactNode;
+};
+//#endregion
+export { ConnectButtonProps as a, RainbowKitAuthenticationProvider as c, ConnectButton as i, createAuthenticationAdapter as l, WalletButtonProps as n, AuthenticationConfig as o, WalletButtonRendererProps as r, AuthenticationStatus as s, WalletButton as t };