@openfort/react 1.5.1 → 1.6.1

package/build/components/Pages/SendConfirmation/styles.js

@@ -1,4 +1,5 @@
 import styled from '../../../styles/styled/index.js';
+import { ButtonContainer } from '../../Common/Button/styles.js';
 
 const SummaryList = styled.div `
   display: flex;
@@ -45,26 +46,64 @@ const FeesValue = styled(SummaryValue) `
   text-decoration: ${(props) => (props.$completed ? 'line-through' : 'none')};
   opacity: ${(props) => (props.$completed ? 0.6 : 1)};
 `;
-const CheckIconWrapper = styled.span `
-  color: var(--ck-body-color);
-  line-height: 0;
+const FiatValue = styled.span `
+  margin-left: 6px;
+  font-size: 13px;
+  font-weight: 400;
+  color: var(--ck-body-color-muted);
+`;
+const NetworkValue = styled(SummaryValue) `
   display: inline-flex;
   align-items: center;
-  
-  svg {
-    width: 16px;
-    height: 16px;
+  justify-content: flex-end;
+  gap: 6px;
+
+  svg,
+  img {
+    width: 18px;
+    height: 18px;
+    border-radius: 50%;
   }
 `;
-// export const BalanceSpinnerWrapper = styled.span`
-//   display: inline-flex;
-//   align-items: center;
-//   margin-left: 8px;
-//   svg {
-//     width: 14px;
-//     height: 14px;
-//   }
-// `
+/** The would-be fee, struck through, shown next to "Sponsored". */
+const FeeStrike = styled.span `
+  text-decoration: line-through;
+  opacity: 0.55;
+`;
+const SponsoredText = styled.span `
+  color: var(--ck-body-color-valid, #16a34a);
+  font-weight: 600;
+`;
+const PayWithCard = styled.div `
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  gap: 12px;
+  margin-top: 4px;
+  padding: 12px 14px;
+  border-radius: 14px;
+  background: var(--ck-body-background-secondary, rgba(0, 0, 0, 0.04));
+`;
+const PayWithMeta = styled.div `
+  display: flex;
+  flex-direction: column;
+  gap: 2px;
+  text-align: left;
+`;
+const PayWithAddress = styled.span `
+  font-size: 14px;
+  font-weight: 600;
+  color: var(--ck-body-color);
+`;
+const PayWithBadge = styled.span `
+  flex-shrink: 0;
+  padding: 4px 10px;
+  border-radius: 999px;
+  font-size: 13px;
+  font-weight: 600;
+  color: var(--ck-body-color);
+  background: var(--ck-body-background);
+`;
 const InfoIconWrapper = styled.span `
   color: var(--ck-body-color-muted);
   opacity: 0.6;
@@ -83,9 +122,16 @@ const InfoIconWrapper = styled.span `
 `;
 const ButtonRow = styled.div `
   display: flex;
-  flex-direction: column;
-  gap: 4px;
+  gap: 12px;
   margin-top: 24px;
+
+  > button {
+    flex: 1;
+  }
+
+  ${ButtonContainer} {
+    margin: 0;
+  }
 `;
 const StatusMessage = styled.div `
   margin-top: 16px;
@@ -125,5 +171,5 @@ const ErrorAction = styled.div `
   line-height: 1.4;
 `;
 
-export { AddressValue, AmountValue, ButtonRow, CheckIconWrapper, ErrorAction, ErrorContainer, ErrorMessage, ErrorTitle, FeesValue, InfoIconWrapper, StatusMessage, SummaryItem, SummaryLabel, SummaryList };
+export { AddressValue, AmountValue, ButtonRow, ErrorAction, ErrorContainer, ErrorMessage, ErrorTitle, FeeStrike, FeesValue, FiatValue, InfoIconWrapper, NetworkValue, PayWithAddress, PayWithBadge, PayWithCard, PayWithMeta, SponsoredText, StatusMessage, SummaryItem, SummaryLabel, SummaryList };
 //# sourceMappingURL=styles.js.map

package/build/components/Pages/SendConfirmation/styles.js.map

@@ -1 +1 @@
-{"version":3,"file":"styles.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"styles.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/build/components/Pages/SignMessage/index.d.ts

@@ -0,0 +1,2 @@
+declare const SignMessage: () => import("react/jsx-runtime").JSX.Element | null;
+export default SignMessage;

package/build/components/Pages/SignMessage/index.js

@@ -0,0 +1,106 @@
+import { jsx, jsxs, Fragment } from 'react/jsx-runtime';
+import { ChainTypeEnum } from '@openfort/openfort-js';
+import { useState, useRef, useEffect } from 'react';
+import { useEthereumEmbeddedWallet } from '../../../ethereum/hooks/useEthereumEmbeddedWallet.js';
+import { useOpenfortCore } from '../../../openfort/useOpenfort.js';
+import { useSolanaEmbeddedWallet } from '../../../solana/hooks/useSolanaEmbeddedWallet.js';
+import Button from '../../Common/Button/index.js';
+import { CopyButton } from '../../Common/CopyToClipboard/CopyButton.js';
+import { useOpenfort } from '../../Openfort/useOpenfort.js';
+import { PageContent } from '../../PageContent/index.js';
+import { SuccessWrap, SuccessCircle, SuccessTitle, SignaturePreview, SignContent, Subtitle, MessageBox, Footer, CopyRow, ErrorText, DataList, DataItem, DataKey } from './styles.js';
+
+/** Renders an EIP-712 value as a readable nested bullet list. */
+function DataNode({ value }) {
+    if (value !== null && typeof value === 'object' && !Array.isArray(value)) {
+        return (jsx(DataList, { children: Object.entries(value).map(([key, child]) => (jsxs(DataItem, { children: [jsxs(DataKey, { children: [key, ":"] }), ' ', child !== null && typeof child === 'object' ? jsx(DataNode, { value: child }) : String(child)] }, key))) }));
+    }
+    return jsx(Fragment, { children: String(value) });
+}
+const SignMessage = () => {
+    var _a;
+    const { signRequest, setSignRequest, setOpen, uiConfig, triggerResize } = useOpenfort();
+    const { chainType } = useOpenfortCore();
+    const wallet = useEthereumEmbeddedWallet();
+    const solana = useSolanaEmbeddedWallet();
+    const [signing, setSigning] = useState(false);
+    const [error, setError] = useState(null);
+    const [signature, setSignature] = useState(null);
+    const settledRef = useRef(false);
+    const mountedRef = useRef(false);
+    // Reject the pending request if the screen unmounts before signing (the user
+    // closed the modal or navigated away). React StrictMode invokes effect cleanup
+    // on a dev-only synchronous remount, so defer the reject to a microtask: the
+    // immediate remount flips mountedRef back to true and cancels the spurious
+    // "User rejected" that would otherwise fire while the wallet UI is still open.
+    useEffect(() => {
+        mountedRef.current = true;
+        const request = signRequest;
+        return () => {
+            mountedRef.current = false;
+            queueMicrotask(() => {
+                if (!mountedRef.current && !settledRef.current) {
+                    request === null || request === void 0 ? void 0 : request.reject(new Error('User rejected the signature request'));
+                }
+            });
+        };
+    }, [signRequest]);
+    // Content height changes between the views; re-measure.
+    useEffect(() => {
+        triggerResize();
+    }, [triggerResize]);
+    if (!signRequest)
+        return null;
+    const appName = (_a = uiConfig.appName) !== null && _a !== void 0 ? _a : 'This app';
+    const close = () => {
+        setSignRequest(null);
+        setOpen(false);
+    };
+    const handleSign = async () => {
+        var _a;
+        setError(null);
+        setSigning(true);
+        try {
+            let signed;
+            if (chainType === ChainTypeEnum.SVM) {
+                if (signRequest.kind !== 'message')
+                    throw new Error('Typed data signing is not supported on Solana.');
+                if (solana.status !== 'connected')
+                    throw new Error('No connected wallet to sign with');
+                signed = await solana.provider.signMessage(signRequest.message);
+            }
+            else {
+                const provider = await ((_a = wallet.activeWallet) === null || _a === void 0 ? void 0 : _a.getProvider());
+                const address = wallet.address;
+                if (!provider || !address)
+                    throw new Error('No connected wallet to sign with');
+                signed = (signRequest.kind === 'message'
+                    ? await provider.request({ method: 'personal_sign', params: [signRequest.message, address] })
+                    : await provider.request({
+                        method: 'eth_signTypedData_v4',
+                        params: [address, JSON.stringify(signRequest.typedData)],
+                    }));
+            }
+            settledRef.current = true;
+            signRequest.resolve(signed);
+            setSignature(signed);
+            setSigning(false);
+            triggerResize();
+        }
+        catch (e) {
+            setError(e instanceof Error ? e.message : 'Failed to sign the message');
+            setSigning(false);
+        }
+    };
+    if (signature) {
+        return (jsx(PageContent, { onBack: null, children: jsxs(SuccessWrap, { children: [jsx(SuccessCircle, { children: jsx("svg", { width: "28", height: "28", viewBox: "0 0 24 24", fill: "none", "aria-hidden": "true", children: jsx("path", { d: "M20 6 9 17l-5-5", stroke: "currentColor", strokeWidth: "2.5", strokeLinecap: "round", strokeLinejoin: "round" }) }) }), jsx(SuccessTitle, { children: "Message signed" }), jsx(SignaturePreview, { children: `${signature.slice(0, 14)}…${signature.slice(-12)}` }), jsx(Button, { variant: "primary", onClick: close, children: "Done" })] }) }));
+    }
+    return (jsx(PageContent, { onBack: null, children: jsxs(SignContent, { children: [jsxs(Subtitle, { children: [appName, " wants you to sign a message. It will not cost you any fees."] }), signRequest.kind === 'message' ? (jsx(MessageBox, { children: signRequest.message })) : (jsx(MessageBox, { children: jsx(DataNode, { value: {
+                            domain: signRequest.typedData.domain,
+                            primaryType: signRequest.typedData.primaryType,
+                            message: signRequest.typedData.message,
+                        } }) })), jsxs(Footer, { children: [signRequest.kind === 'typedData' && (jsx(CopyRow, { children: jsx(CopyButton, { value: JSON.stringify(signRequest.typedData, null, 2), children: "Copy to clipboard" }) })), error && jsx(ErrorText, { children: error }), jsx(Button, { variant: "primary", onClick: handleSign, waiting: signing, disabled: signing, arrow: true, children: "Sign and continue" })] })] }) }));
+};
+
+export { SignMessage as default };
+//# sourceMappingURL=index.js.map

package/build/components/Pages/SignMessage/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/build/components/Pages/SignMessage/styles.d.ts

@@ -0,0 +1,13 @@
+export declare const SignContent: import("styled-components").StyledComponent<"div", any, {}, never>;
+export declare const Subtitle: import("styled-components").StyledComponent<"p", any, {}, never>;
+export declare const MessageBox: import("styled-components").StyledComponent<"div", any, {}, never>;
+export declare const Footer: import("styled-components").StyledComponent<"div", any, {}, never>;
+export declare const DataList: import("styled-components").StyledComponent<"ul", any, {}, never>;
+export declare const DataItem: import("styled-components").StyledComponent<"li", any, {}, never>;
+export declare const DataKey: import("styled-components").StyledComponent<"span", any, {}, never>;
+export declare const ErrorText: import("styled-components").StyledComponent<"div", any, {}, never>;
+export declare const CopyRow: import("styled-components").StyledComponent<"div", any, {}, never>;
+export declare const SuccessWrap: import("styled-components").StyledComponent<"div", any, {}, never>;
+export declare const SuccessCircle: import("styled-components").StyledComponent<"div", any, {}, never>;
+export declare const SuccessTitle: import("styled-components").StyledComponent<"div", any, {}, never>;
+export declare const SignaturePreview: import("styled-components").StyledComponent<"code", any, {}, never>;

package/build/components/Pages/SignMessage/styles.js

@@ -0,0 +1,99 @@
+import styled from '../../../styles/styled/index.js';
+
+const SignContent = styled.div `
+  display: flex;
+  flex-direction: column;
+  gap: 16px;
+  min-height: 0;
+  /* Cap to the modal viewport (InnerContainer caps at 88vh) so the message body
+     is the only part that scrolls and the Sign button stays pinned and reachable
+     on small screens. 112px ≈ PageContent top padding + PageContents padding,
+     mirroring DepositWallet's Layout. */
+  max-height: calc(88vh - 112px);
+`;
+const Subtitle = styled.p `
+  flex-shrink: 0;
+  margin: 0;
+  text-align: center;
+  font-size: 15px;
+  line-height: 1.4;
+  color: var(--ck-body-color-muted, #999);
+`;
+const MessageBox = styled.div `
+  flex: 1 1 auto;
+  min-height: 0;
+  overflow-y: auto;
+  -webkit-overflow-scrolling: touch;
+  overscroll-behavior: contain;
+  padding: 16px;
+  border-radius: 12px;
+  background: var(--ck-body-background-secondary, rgba(0, 0, 0, 0.04));
+  color: var(--ck-body-color, #111);
+  font-size: 14px;
+  line-height: 1.45;
+  text-align: left;
+  word-break: break-word;
+  white-space: pre-wrap;
+`;
+const Footer = styled.div `
+  flex-shrink: 0;
+  display: flex;
+  flex-direction: column;
+  gap: 12px;
+`;
+const DataList = styled.ul `
+  margin: 0;
+  padding-left: 18px;
+  list-style: disc;
+`;
+const DataItem = styled.li `
+  margin: 2px 0;
+`;
+const DataKey = styled.span `
+  color: var(--ck-body-color-muted, #777);
+`;
+const ErrorText = styled.div `
+  text-align: center;
+  font-size: 13px;
+  color: var(--ck-body-color-danger, #e7000b);
+`;
+const CopyRow = styled.div `
+  display: flex;
+  justify-content: center;
+`;
+const SuccessWrap = styled.div `
+  display: flex;
+  flex-direction: column;
+  align-items: center;
+  gap: 12px;
+  padding: 12px 0 4px;
+`;
+const SuccessCircle = styled.div `
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  width: 56px;
+  height: 56px;
+  border-radius: 50%;
+  color: #fff;
+  background: var(--ck-body-color-valid, #16a34a);
+`;
+const SuccessTitle = styled.div `
+  font-size: 17px;
+  font-weight: 600;
+  color: var(--ck-body-color, #111);
+`;
+const SignaturePreview = styled.code `
+  display: block;
+  max-width: 100%;
+  padding: 10px 12px;
+  border-radius: 10px;
+  background: var(--ck-body-background-secondary, rgba(0, 0, 0, 0.04));
+  color: var(--ck-body-color-muted, #777);
+  font-size: 12px;
+  word-break: break-all;
+  text-align: center;
+`;
+
+export { CopyRow, DataItem, DataKey, DataList, ErrorText, Footer, MessageBox, SignContent, SignaturePreview, Subtitle, SuccessCircle, SuccessTitle, SuccessWrap };
+//# sourceMappingURL=styles.js.map

package/build/components/Pages/SignMessage/styles.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"styles.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/build/hooks/openfort/useSignMessage.d.ts

@@ -0,0 +1,27 @@
+import { type SignTypedDataPayload } from '../../components/Openfort/types';
+/**
+ * Hook for signing messages with a confirmation modal (EVM only).
+ *
+ * Opens the Openfort "Sign message" screen, shows the message (or EIP-712 typed
+ * data) to the user, and resolves with the signature once they confirm. Rejects
+ * if the user dismisses the modal.
+ *
+ * @example
+ * ```tsx
+ * const { signMessage, signTypedData, isPending } = useSignMessage()
+ *
+ * const signature = await signMessage('I hereby vote for foobar')
+ *
+ * const typedSignature = await signTypedData({
+ *   domain: { name: 'Ether Mail', version: '1', chainId: 1, verifyingContract: '0x…' },
+ *   types: { Person: [{ name: 'name', type: 'string' }] },
+ *   primaryType: 'Person',
+ *   message: { name: 'Cow' },
+ * })
+ * ```
+ */
+export declare function useSignMessage(): {
+    signMessage: (message: string) => Promise<string>;
+    signTypedData: (typedData: SignTypedDataPayload) => Promise<string>;
+    isPending: boolean;
+};

package/build/hooks/openfort/useSignMessage.js

@@ -0,0 +1,52 @@
+import { useState, useCallback } from 'react';
+import { routes } from '../../components/Openfort/types.js';
+import { useOpenfort } from '../../components/Openfort/useOpenfort.js';
+
+/**
+ * Hook for signing messages with a confirmation modal (EVM only).
+ *
+ * Opens the Openfort "Sign message" screen, shows the message (or EIP-712 typed
+ * data) to the user, and resolves with the signature once they confirm. Rejects
+ * if the user dismisses the modal.
+ *
+ * @example
+ * ```tsx
+ * const { signMessage, signTypedData, isPending } = useSignMessage()
+ *
+ * const signature = await signMessage('I hereby vote for foobar')
+ *
+ * const typedSignature = await signTypedData({
+ *   domain: { name: 'Ether Mail', version: '1', chainId: 1, verifyingContract: '0x…' },
+ *   types: { Person: [{ name: 'name', type: 'string' }] },
+ *   primaryType: 'Person',
+ *   message: { name: 'Cow' },
+ * })
+ * ```
+ */
+function useSignMessage() {
+    const { setSignRequest, setRoute, setOpen } = useOpenfort();
+    const [isPending, setIsPending] = useState(false);
+    const request = useCallback((args) => new Promise((resolve, reject) => {
+        setIsPending(true);
+        // setOpen(true) resets route/history, so it MUST run before setRoute.
+        setOpen(true);
+        setSignRequest({
+            ...args,
+            resolve: (signature) => {
+                setIsPending(false);
+                resolve(signature);
+            },
+            reject: (reason) => {
+                setIsPending(false);
+                reject(reason);
+            },
+        });
+        setRoute(routes.SIGN_MESSAGE);
+    }), [setSignRequest, setRoute, setOpen]);
+    const signMessage = useCallback((message) => request({ kind: 'message', message }), [request]);
+    const signTypedData = useCallback((typedData) => request({ kind: 'typedData', typedData }), [request]);
+    return { signMessage, signTypedData, isPending };
+}
+
+export { useSignMessage };
+//# sourceMappingURL=useSignMessage.js.map

package/build/hooks/openfort/useSignMessage.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useSignMessage.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/build/hooks/openfort/useUI.d.ts

@@ -1,3 +1,4 @@
+import { type Asset } from '../../components/Openfort/types';
 /**
  * Hook for controlling Openfort UI modal and navigation
  *
@@ -35,7 +36,11 @@ export declare function useUI(): {
     openSwitchNetworks: () => void;
     openProviders: () => void;
     openWallets: () => void;
-    openSend: () => void;
+    openSend: (tx?: {
+        to: string;
+        amount: string;
+        asset?: Asset;
+    }) => void;
     openReceive: () => void;
     openFunding: () => void;
     openBuy: () => void;

package/build/hooks/openfort/useUI.js

@@ -22,7 +22,9 @@ const safeRoutes = {
         routes.PROVIDERS,
         routes.PROFILE,
         routes.SEND,
+        routes.SOL_SEND,
         routes.RECEIVE,
+        routes.SOL_RECEIVE,
         routes.DEPOSIT,
         routes.BUY,
         routes.EXPORT_KEY,
@@ -68,7 +70,7 @@ function isAccountId(id) {
  */
 function useUI() {
     var _a;
-    const { open, setOpen, setRoute, setConnector, connector, chainType } = useOpenfort();
+    const { open, setOpen, setRoute, setConnector, setSendForm, connector, chainType } = useOpenfort();
     const { isLoading, user, needsRecovery, embeddedAccounts, activeEmbeddedAddress, embeddedState } = useOpenfortCore();
     const bridge = useEthereumBridge();
     const strategy = useConnectionStrategy();
@@ -100,6 +102,16 @@ function useUI() {
         else
             setRoute(routes.CONNECTED);
     }
+    /**
+     * Prefill the send form and jump straight to the confirmation (preview) screen
+     * for the active chain, skipping asset/amount/recipient entry.
+     */
+    const openSendPreview = (tx) => {
+        var _a;
+        setSendForm({ recipient: tx.to, amount: tx.amount, asset: (_a = tx.asset) !== null && _a !== void 0 ? _a : { type: 'native', balance: BigInt(0) } });
+        setOpen(true);
+        setRoute(chainType === ChainTypeEnum.SVM ? routes.SOL_SEND_CONFIRMATION : routes.SEND_CONFIRMATION);
+    };
     const gotoAndOpen = (route) => {
         const safeList = isConnected ? safeRoutes.connected : safeRoutes.disconnected;
         const fallback = isConnected ? routes.CONNECTED : routes.PROVIDERS;
@@ -123,8 +135,8 @@ function useUI() {
         openSwitchNetworks: () => gotoAndOpen(routes.ETH_SWITCH_NETWORK),
         openProviders: () => gotoAndOpen(routes.PROVIDERS),
         openWallets: () => gotoAndOpen({ route: routes.CONNECTORS, connectType: 'linkIfUserConnectIfNoUser' }),
-        openSend: () => gotoAndOpen(routes.SEND),
-        openReceive: () => gotoAndOpen(routes.RECEIVE),
+        openSend: (tx) => tx ? openSendPreview(tx) : gotoAndOpen(chainType === ChainTypeEnum.SVM ? routes.SOL_SEND : routes.SEND),
+        openReceive: () => gotoAndOpen(chainType === ChainTypeEnum.SVM ? routes.SOL_RECEIVE : routes.RECEIVE),
         openFunding: () => gotoAndOpen(routes.DEPOSIT),
         openBuy: () => gotoAndOpen(routes.BUY),
         openExportKey: () => gotoAndOpen(routes.EXPORT_KEY),

package/build/hooks/openfort/useUI.js.map

@@ -1 +1 @@
-{"version":3,"file":"useUI.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"useUI.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/build/index.d.ts

@@ -44,7 +44,7 @@ export { default as Avatar } from './components/Common/Avatar';
 export { default as ChainIcon } from './components/Common/Chain';
 export { OpenfortButton } from './components/ConnectButton';
 export { OpenfortProvider } from './components/Openfort/OpenfortProvider';
-export type { CustomizableRoutes, MultiChainAsset } from './components/Openfort/types';
+export type { CustomizableRoutes, MultiChainAsset, SignTypedDataPayload } from './components/Openfort/types';
 export { FundingMethod, LinkWalletOnSignUpOption, UIAuthProvider as AuthProvider } from './components/Openfort/types';
 export { embeddedWalletId } from './constants/openfort';
 export { OpenfortError, OpenfortReactErrorType, OpenfortReactErrorType as OpenfortErrorType, } from './core/errors';
@@ -64,6 +64,7 @@ export type { FundingSession, FundingTarget, PaymentMethod, PaymentMethodInput,
 export { useFunding } from './hooks/openfort/useFunding';
 export { useGrantPermissions } from './hooks/openfort/useGrantPermissions';
 export { useRevokePermissions } from './hooks/openfort/useRevokePermissions';
+export { useSignMessage } from './hooks/openfort/useSignMessage';
 export { useUI } from './hooks/openfort/useUI';
 export { useUser } from './hooks/openfort/useUser';
 export type { UserWallet } from './hooks/openfort/walletTypes';

package/build/index.js

@@ -17,6 +17,7 @@ export { use7702Authorization } from './hooks/openfort/use7702Authorization.js';
 export { useFunding } from './hooks/openfort/useFunding.js';
 export { useGrantPermissions } from './hooks/openfort/useGrantPermissions.js';
 export { useRevokePermissions } from './hooks/openfort/useRevokePermissions.js';
+export { useSignMessage } from './hooks/openfort/useSignMessage.js';
 export { useUI } from './hooks/openfort/useUI.js';
 export { useUser } from './hooks/openfort/useUser.js';
 export { invalidateBalance } from './hooks/useBalance.js';

package/build/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/build/localizations/locales/en-US.js

@@ -86,7 +86,7 @@ const enUS = {
     injectionScreen_notconnected_h1: `Login to {{ CONNECTORNAME }}`,
     injectionScreen_notconnected_p: `To continue, please login to your {{ CONNECTORNAME }} extension.`,
     profileScreen_heading: 'Connected',
-    buyScreen_heading: 'Add funds',
+    buyScreen_heading: 'Add funds from card',
     buyScreen_subheading: 'Select an amount and token to top up.',
     buyScreen_payWithCard_title: 'Pay with card',
     buyScreen_payWithCard_description: 'Use Stripe or Google Pay for a quick card purchase.',

package/build/solana/transfer.d.ts

@@ -58,4 +58,16 @@ type SendSplTokenGaslessParams = {
 };
 /** Send an SPL token transfer with fees sponsored by the Openfort paymaster (Kora). */
 export declare function sendSplTokenGasless({ from, to, mint, amount, provider, cluster, publishableKey, }: SendSplTokenGaslessParams): Promise<string>;
+/**
+ * Read the network fee (in lamports) for a single-signer transfer from the RPC
+ * via `getFeeForMessage`. Returns null on any failure so callers can fall back to
+ * a neutral "--" rather than a fabricated number. The base fee is per-signature
+ * and identical for native and SPL transfers (a single fee-payer signature), so a
+ * representative SOL transfer message is enough to price it.
+ */
+export declare function estimateSolanaTransferFeeLamports({ from, to, rpcUrl, }: {
+    from: string;
+    to: string;
+    rpcUrl: string;
+}): Promise<bigint | null>;
 export {};

package/build/solana/transfer.js

@@ -214,6 +214,34 @@ async function sendSplTokenGasless({ from, to, mint, amount, provider, cluster,
         publishableKey,
     });
 }
+/**
+ * Read the network fee (in lamports) for a single-signer transfer from the RPC
+ * via `getFeeForMessage`. Returns null on any failure so callers can fall back to
+ * a neutral "--" rather than a fabricated number. The base fee is per-signature
+ * and identical for native and SPL transfers (a single fee-payer signature), so a
+ * representative SOL transfer message is enough to price it.
+ */
+async function estimateSolanaTransferFeeLamports({ from, to, rpcUrl, }) {
+    try {
+        const kit = await import('@solana/kit');
+        const { getTransferSolInstruction } = await import('@solana-program/system');
+        const fromAddress = kit.address(from);
+        const rpc = kit.createSolanaRpc(rpcUrl);
+        const { value: latestBlockhash } = await rpc.getLatestBlockhash().send();
+        const message = kit.pipe(kit.createTransactionMessage({ version: 0 }), (tx) => kit.setTransactionMessageFeePayer(fromAddress, tx), (tx) => kit.setTransactionMessageLifetimeUsingBlockhash(latestBlockhash, tx), (tx) => kit.appendTransactionMessageInstruction(getTransferSolInstruction({
+            source: kit.createNoopSigner(fromAddress),
+            destination: kit.address(to),
+            amount: kit.lamports(BigInt(1)),
+        }), tx));
+        const compiled = kit.compileTransactionMessage(message);
+        const base64Message = kit.getBase64Decoder().decode(kit.getCompiledTransactionMessageEncoder().encode(compiled));
+        const { value } = await rpc.getFeeForMessage(base64Message).send();
+        return value == null ? null : BigInt(value);
+    }
+    catch {
+        return null;
+    }
+}
 
-export { sendSol, sendSolGasless, sendSplToken, sendSplTokenGasless };
+export { estimateSolanaTransferFeeLamports, sendSol, sendSolGasless, sendSplToken, sendSplTokenGasless };
 //# sourceMappingURL=transfer.js.map

package/build/solana/transfer.js.map

@@ -1 +1 @@
-{"version":3,"file":"transfer.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"transfer.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/build/utils/rpc.d.ts

@@ -6,6 +6,12 @@
  */
 import type { Chain } from 'viem';
 import type { SolanaCluster } from '../solana/types';
+/**
+ * Whether an EVM chain id is a testnet. Reads viem's chain metadata (`testnet`)
+ * for the chains the SDK bundles, falling back to a small extra set. Use this to
+ * key behaviour off the wallet's active chain rather than the publishable key.
+ */
+export declare function isTestnetChainId(chainId: number): boolean;
 export declare function getDefaultEthereumRpcUrl(chainId: number): string;
 /**
  * Get default Solana RPC URL for a cluster.

package/build/utils/rpc.js

@@ -17,6 +17,17 @@ const KNOWN_CHAINS = {
     [optimismSepolia.id]: optimismSepolia,
     [arbitrumSepolia.id]: arbitrumSepolia,
 };
+/** Testnets not in {@link KNOWN_CHAINS} but still worth recognizing (deprecated/uncommon). */
+const EXTRA_TESTNET_CHAIN_IDS = new Set([5, 80001, 97, 4002]);
+/**
+ * Whether an EVM chain id is a testnet. Reads viem's chain metadata (`testnet`)
+ * for the chains the SDK bundles, falling back to a small extra set. Use this to
+ * key behaviour off the wallet's active chain rather than the publishable key.
+ */
+function isTestnetChainId(chainId) {
+    var _a;
+    return ((_a = KNOWN_CHAINS[chainId]) === null || _a === void 0 ? void 0 : _a.testnet) === true || EXTRA_TESTNET_CHAIN_IDS.has(chainId);
+}
 /**
  * Default Solana RPC URLs by cluster.
  * Production apps should provide their own RPCs via walletConfig.solana.rpcUrls.
@@ -93,5 +104,5 @@ function buildChainFromConfig(chainId, rpcUrls) {
     });
 }
 
-export { buildChainFromConfig, getChainName, getDefaultEthereumRpcUrl, getDefaultSolanaRpcUrl, getNativeCurrency };
+export { buildChainFromConfig, getChainName, getDefaultEthereumRpcUrl, getDefaultSolanaRpcUrl, getNativeCurrency, isTestnetChainId };
 //# sourceMappingURL=rpc.js.map

package/build/utils/rpc.js.map

@@ -1 +1 @@
-{"version":3,"file":"rpc.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"rpc.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/build/version.d.ts

@@ -1 +1 @@
-export declare const OPENFORT_VERSION = "1.5.1";
+export declare const OPENFORT_VERSION = "1.6.1";