@openfort/react 1.6.0 → 1.6.2

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

@@ -3,6 +3,7 @@ import { ChainTypeEnum } from '@openfort/openfort-js';
 import { useMemo, useEffect, useState, useRef } from 'react';
 import { isAddress, createPublicClient, http, erc20Abi, parseUnits, encodeFunctionData } from 'viem';
 import { TickIcon } from '../../../assets/icons.js';
+import { chainLogoUrl } from '../../../constants/logos.js';
 import { useEthereumEmbeddedWallet } from '../../../ethereum/hooks/useEthereumEmbeddedWallet.js';
 import { useEthereumWalletAssets } from '../../../ethereum/hooks/useEthereumWalletAssets.js';
 import { useBalance } from '../../../hooks/useBalance.js';
@@ -20,16 +21,16 @@ import { ModalHeading, ModalBody } from '../../Common/Modal/styles.js';
 import { routes } from '../../Openfort/types.js';
 import { useOpenfort } from '../../Openfort/useOpenfort.js';
 import { PageContent } from '../../PageContent/index.js';
-import { sanitizeForParsing, isSameToken, getAssetDecimals, getAssetSymbol } from '../Send/utils.js';
+import { sanitizeForParsing, isSameToken, getAssetDecimals, getAssetSymbol, formatBalanceWithSymbol } from '../Send/utils.js';
 import { ConfirmationSummary } from './ConfirmationSummary.js';
 import { EstimatedFees } from './EstimatedFees.js';
-import { ButtonRow, SponsoredFee, FeesValue, StatusMessage, ErrorContainer, ErrorTitle, ErrorMessage, ErrorAction } from './styles.js';
+import { ButtonRow, FeesValue, StatusMessage, ErrorContainer, ErrorTitle, ErrorMessage, ErrorAction } from './styles.js';
 
 const SendConfirmation = () => {
-    var _a, _b, _c, _d, _e, _f;
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k;
     const wallet = useEthereumEmbeddedWallet();
     const { chainType } = useOpenfortCore();
-    const { sendForm, setRoute, triggerResize, walletConfig } = useOpenfort();
+    const { sendForm, setRoute, triggerResize, walletConfig, chains } = useOpenfort();
     const address = wallet.status === 'connected' ? wallet.address : undefined;
     const chainId = wallet.status === 'connected' ? wallet.chainId : undefined;
     const blockExplorerUrl = chainId ? getExplorerUrl(ChainTypeEnum.EVM, { chainId }) : undefined;
@@ -316,12 +317,17 @@ const SendConfirmation = () => {
             return null;
         return `$${(n * perToken).toFixed(2)}`;
     }, [(_f = (_e = token.metadata) === null || _e === void 0 ? void 0 : _e.fiat) === null || _f === void 0 ? void 0 : _f.value, normalisedAmount]);
+    // Prefer the configured chain's display name over the numeric id fallback.
+    const networkName = (_h = (_g = chains === null || chains === void 0 ? void 0 : chains.find((c) => c.id === chainId)) === null || _g === void 0 ? void 0 : _g.name) !== null && _h !== void 0 ? _h : getChainName(chainId !== null && chainId !== void 0 ? chainId : 0);
+    const balanceLabel = currentBalance !== undefined
+        ? formatBalanceWithSymbol(currentBalance, (_j = getAssetDecimals(token)) !== null && _j !== void 0 ? _j : 18, getAssetSymbol(token))
+        : undefined;
     if (isSuccess) {
         const successAmount = normalisedAmount || '0';
         const successSymbol = getAssetSymbol(token);
         return (jsxs(PageContent, { children: [jsx(Loader, { isSuccess: true, header: "Transfer Sent", description: `${successAmount} ${successSymbol} sent successfully` }), jsxs(ButtonRow, { children: [blockExplorerUrl && (jsx(Button, { variant: "primary", onClick: handleOpenBlockExplorer, children: "View on Explorer" })), jsx(Button, { variant: "secondary", onClick: handleFinish, children: "Back to profile" })] })] }));
     }
-    return (jsxs(PageContent, { children: [jsx(ModalHeading, { children: "Confirm transfer" }), jsx(ModalBody, { children: "Review the transaction before sending." }), jsx(ConfirmationSummary, { amount: normalisedAmount || '0', symbol: getAssetSymbol(token), fiat: fiatTotal, to: recipientAddress ? { display: truncateEthAddress(recipientAddress), value: recipientAddress } : undefined, networkName: getChainName(chainId !== null && chainId !== void 0 ? chainId : 0), payWith: address ? { display: truncateEthAddress(address), value: address } : undefined, fee: isSponsored ? (jsx(SponsoredFee, { children: "Sponsored \u00B7 gasless" })) : (jsx(FeesValue, { children: jsx(EstimatedFees, { account: address, to: token.type === 'erc20' ? token.address : recipientAddress, value: token.type === 'native' && parsedAmount ? parsedAmount : undefined, data: transferData, chainId: chainId, nativeSymbol: nativeSymbol, enabled: Boolean(address && recipientAddress && parsedAmount && parsedAmount > BigInt(0)), hideInfoIcon: false }) })) }), insufficientBalance && !isSuccess && (jsx(StatusMessage, { "$status": "error", children: "Insufficient balance for this transfer." })), errorDetails && (jsxs(ErrorContainer, { children: [jsx(ErrorTitle, { children: errorDetails.title }), jsx(ErrorMessage, { children: errorDetails.message }), errorDetails.action && jsx(ErrorAction, { children: errorDetails.action })] })), jsxs(ButtonRow, { children: [jsx(Button, { variant: "primary", onClick: isSuccess ? handleOpenBlockExplorer : handleConfirm, disabled: isSuccess
+    return (jsxs(PageContent, { children: [jsx(ModalHeading, { children: "Confirm transfer" }), jsx(ModalBody, { children: "Review the transaction before sending." }), jsx(ConfirmationSummary, { amount: normalisedAmount || '0', symbol: getAssetSymbol(token), fiat: fiatTotal, to: recipientAddress ? { display: truncateEthAddress(recipientAddress), value: recipientAddress } : undefined, networkName: networkName, networkIcon: chainLogoUrl(chainId) ? jsx("img", { src: (_k = chainLogoUrl(chainId)) !== null && _k !== void 0 ? _k : '', alt: "" }) : undefined, balance: balanceLabel, payWith: address ? { display: truncateEthAddress(address), value: address } : undefined, fee: jsx(FeesValue, { children: jsx(EstimatedFees, { account: address, to: token.type === 'erc20' ? token.address : recipientAddress, value: token.type === 'native' && parsedAmount ? parsedAmount : undefined, data: transferData, chainId: chainId, nativeSymbol: nativeSymbol, enabled: Boolean(address && recipientAddress && parsedAmount && parsedAmount > BigInt(0)), sponsored: isSponsored, hideInfoIcon: false }) }) }), insufficientBalance && !isSuccess && (jsx(StatusMessage, { "$status": "error", children: "Insufficient balance for this transfer." })), errorDetails && (jsxs(ErrorContainer, { children: [jsx(ErrorTitle, { children: errorDetails.title }), jsx(ErrorMessage, { children: errorDetails.message }), errorDetails.action && jsx(ErrorAction, { children: errorDetails.action })] })), jsxs(ButtonRow, { children: [jsx(Button, { variant: "primary", onClick: isSuccess ? handleOpenBlockExplorer : handleConfirm, disabled: isSuccess
                             ? false
                             : isLoading ||
                                 Boolean(transactionHash) ||

package/build/components/Pages/SendConfirmation/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/components/Pages/SendConfirmation/styles.d.ts

@@ -8,7 +8,9 @@ export declare const FeesValue: import("styled-components").StyledComponent<"spa
 }, never>;
 export declare const FiatValue: import("styled-components").StyledComponent<"span", any, {}, never>;
 export declare const NetworkValue: import("styled-components").StyledComponent<"span", any, {}, never>;
-export declare const SponsoredFee: import("styled-components").StyledComponent<"span", any, {}, never>;
+/** The would-be fee, struck through, shown next to "Sponsored". */
+export declare const FeeStrike: import("styled-components").StyledComponent<"span", any, {}, never>;
+export declare const SponsoredText: import("styled-components").StyledComponent<"span", any, {}, never>;
 export declare const PayWithCard: import("styled-components").StyledComponent<"div", any, {}, never>;
 export declare const PayWithMeta: import("styled-components").StyledComponent<"div", any, {}, never>;
 export declare const PayWithAddress: import("styled-components").StyledComponent<"span", any, {}, never>;

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;
@@ -64,8 +65,14 @@ const NetworkValue = styled(SummaryValue) `
     border-radius: 50%;
   }
 `;
-const SponsoredFee = styled(SummaryValue) `
+/** 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;
@@ -94,8 +101,8 @@ const PayWithBadge = styled.span `
   border-radius: 999px;
   font-size: 13px;
   font-weight: 600;
-  color: var(--ck-body-color-valid, #16a34a);
-  background: var(--ck-body-background, rgba(22, 163, 74, 0.12));
+  color: var(--ck-body-color);
+  background: var(--ck-body-background);
 `;
 const InfoIconWrapper = styled.span `
   color: var(--ck-body-color-muted);
@@ -115,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;
@@ -157,5 +171,5 @@ const ErrorAction = styled.div `
   line-height: 1.4;
 `;
 
-export { AddressValue, AmountValue, ButtonRow, ErrorAction, ErrorContainer, ErrorMessage, ErrorTitle, FeesValue, FiatValue, InfoIconWrapper, NetworkValue, PayWithAddress, PayWithBadge, PayWithCard, PayWithMeta, SponsoredFee, 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.js

@@ -1,11 +1,14 @@
 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, CopyRow, ErrorText, DataList, DataItem, DataKey } from './styles.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 }) {
@@ -17,17 +20,29 @@ function DataNode({ 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).
+    // 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 () => {
-            if (!settledRef.current)
-                signRequest === null || signRequest === void 0 ? void 0 : signRequest.reject(new Error('User rejected the signature request'));
+            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.
@@ -46,16 +61,26 @@ const SignMessage = () => {
         setError(null);
         setSigning(true);
         try {
-            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');
-            const 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)],
-                }));
+            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);
@@ -70,11 +95,11 @@ const SignMessage = () => {
     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 })) : (jsxs(Fragment, { children: [jsx(MessageBox, { "$scroll": true, children: jsx(DataNode, { value: {
-                                    domain: signRequest.typedData.domain,
-                                    primaryType: signRequest.typedData.primaryType,
-                                    message: signRequest.typedData.message,
-                                } }) }), 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" })] }) }));
+    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 };

package/build/components/Pages/SignMessage/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/components/Pages/SignMessage/styles.d.ts

@@ -1,8 +1,7 @@
 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, {
-    $scroll?: boolean;
-}, 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>;

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

@@ -4,8 +4,15 @@ 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;
@@ -13,6 +20,11 @@ const Subtitle = styled.p `
   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));
@@ -22,7 +34,12 @@ const MessageBox = styled.div `
   text-align: left;
   word-break: break-word;
   white-space: pre-wrap;
-  ${({ $scroll }) => $scroll && 'max-height: 320px; overflow-y: auto;'}
+`;
+const Footer = styled.div `
+  flex-shrink: 0;
+  display: flex;
+  flex-direction: column;
+  gap: 12px;
 `;
 const DataList = styled.ul `
   margin: 0;
@@ -78,5 +95,5 @@ const SignaturePreview = styled.code `
   text-align: center;
 `;
 
-export { CopyRow, DataItem, DataKey, DataList, ErrorText, MessageBox, SignContent, SignaturePreview, Subtitle, SuccessCircle, SuccessTitle, SuccessWrap };
+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

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

package/build/constants/defaultAssets.d.ts

@@ -0,0 +1,18 @@
+import type { Hex } from 'viem';
+/** A default token surfaced when no custom assets are configured. */
+type DefaultAsset = {
+    symbol: string;
+    name: string;
+    decimals: number;
+    address: Hex;
+};
+/**
+ * Default ERC-20 assets per chain id, mirroring the set returned by
+ * `wallet_getAssets` — see https://www.openfort.io/docs/configuration/default-assets.
+ * Used to surface common tokens (USDC / USDT / DAI / wrapped native) in the asset
+ * inventory even at zero balance. Native tokens come from `getNativeCurrency`.
+ */
+export declare const DEFAULT_ASSETS: Record<number, DefaultAsset[]>;
+/** Whether a symbol is a ~$1 stablecoin (for the inventory's USD estimate). */
+export declare function isStableSymbol(symbol: string): boolean;
+export {};

package/build/constants/defaultAssets.js

@@ -0,0 +1,70 @@
+/**
+ * Default ERC-20 assets per chain id, mirroring the set returned by
+ * `wallet_getAssets` — see https://www.openfort.io/docs/configuration/default-assets.
+ * Used to surface common tokens (USDC / USDT / DAI / wrapped native) in the asset
+ * inventory even at zero balance. Native tokens come from `getNativeCurrency`.
+ */
+const DEFAULT_ASSETS = {
+    // Ethereum Mainnet
+    1: [
+        { symbol: 'USDC', name: 'USD Coin', decimals: 6, address: '0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48' },
+        { symbol: 'USDT', name: 'Tether USD', decimals: 6, address: '0xdAC17F958D2ee523a2206206994597C13D831ec7' },
+        { symbol: 'DAI', name: 'Dai Stablecoin', decimals: 18, address: '0x6B175474E89094C44Da98b954EedeAC495271d0F' },
+        { symbol: 'WETH', name: 'Wrapped Ether', decimals: 18, address: '0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2' },
+    ],
+    // Optimism
+    10: [
+        { symbol: 'USDC', name: 'USD Coin', decimals: 6, address: '0x0b2C639c533813f4Aa9D7837CAf62653d097Ff85' },
+        { symbol: 'USDT', name: 'Tether USD', decimals: 6, address: '0x94b008aA00579c1307B0EF2c499aD98a8ce58e58' },
+        { symbol: 'DAI', name: 'Dai Stablecoin', decimals: 18, address: '0xDA10009cBd5D07dd0CeCc66161FC93D7c9000da1' },
+        { symbol: 'WETH', name: 'Wrapped Ether', decimals: 18, address: '0x4200000000000000000000000000000000000006' },
+    ],
+    // BSC
+    56: [
+        { symbol: 'USDC', name: 'USD Coin', decimals: 18, address: '0x8AC76a51cc950d9822D68b83fE1Ad97B32Cd580d' },
+        { symbol: 'USDT', name: 'Tether USD', decimals: 18, address: '0x55d398326f99059fF775485246999027B3197955' },
+        { symbol: 'DAI', name: 'Dai Stablecoin', decimals: 18, address: '0x1AF3F329e8BE154074D8769D1FFa4eE058B1DBc3' },
+        { symbol: 'WBNB', name: 'Wrapped BNB', decimals: 18, address: '0xbb4CdB9CBd36B01bD1cBaEBF2De08d9173bc095c' },
+    ],
+    // Polygon
+    137: [
+        { symbol: 'USDC', name: 'USD Coin', decimals: 6, address: '0x3c499c542cEF5E3811e1192ce70d8cC03d5c3359' },
+        { symbol: 'USDT', name: 'Tether USD', decimals: 6, address: '0xc2132D05D31c914a87C6611C10748AEb04B58e8F' },
+        { symbol: 'DAI', name: 'Dai Stablecoin', decimals: 18, address: '0x8f3Cf7ad23Cd3CaDbD9735AFf958023239c6A063' },
+        { symbol: 'WMATIC', name: 'Wrapped Matic', decimals: 18, address: '0x0d500B1d8E8eF31E21C99d1Db9A6444d3ADf1270' },
+    ],
+    // Base
+    8453: [
+        { symbol: 'USDC', name: 'USD Coin', decimals: 6, address: '0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913' },
+        { symbol: 'DAI', name: 'Dai Stablecoin', decimals: 18, address: '0x50c5725949A6F0c72E6C4a641F24049A917DB0Cb' },
+        { symbol: 'WETH', name: 'Wrapped Ether', decimals: 18, address: '0x4200000000000000000000000000000000000006' },
+    ],
+    // Arbitrum
+    42161: [
+        { symbol: 'USDC', name: 'USD Coin', decimals: 6, address: '0xaf88d065e77c8cC2239327C5EDb3A432268e5831' },
+        { symbol: 'USDT', name: 'Tether USD', decimals: 6, address: '0xFd086bC7CD5C481DCC9C85ebE478A1C0b69FCbb9' },
+        { symbol: 'DAI', name: 'Dai Stablecoin', decimals: 18, address: '0xDA10009cBd5D07dd0CeCc66161FC93D7c9000da1' },
+        { symbol: 'WETH', name: 'Wrapped Ether', decimals: 18, address: '0x82aF49447D8a07e3bd95BD0d56f35241523fBab1' },
+    ],
+    // Avalanche
+    43114: [
+        { symbol: 'USDC', name: 'USD Coin', decimals: 6, address: '0xB97EF9Ef8734C71904D8002F8b6Bc66Dd9c48a6E' },
+        { symbol: 'USDT', name: 'Tether USD', decimals: 6, address: '0x9702230A8Ea53601f5cD2dc00fDBc13d4dF4A8c7' },
+        { symbol: 'DAI.e', name: 'Dai Stablecoin', decimals: 18, address: '0xd586E7F844cEa2F87f50152665BCbc2C279D8d70' },
+        { symbol: 'WETH.e', name: 'Wrapped Ether', decimals: 18, address: '0x49D5c2BdFfac6CE2BFdB6640F4F80f226bc10bAB' },
+    ],
+    // Sepolia
+    11155111: [{ symbol: 'USDC', name: 'USD Coin', decimals: 6, address: '0x1c7D4B196Cb0C7B01d743Fbc6116a902379C7238' }],
+    // Amoy
+    80002: [{ symbol: 'USDC', name: 'USD Coin', decimals: 6, address: '0x41E94Eb019C0762f9Bfcf9Fb1E58725BfB0e7582' }],
+    // Base Sepolia
+    84532: [{ symbol: 'USDC', name: 'USD Coin', decimals: 6, address: '0x036CbD53842c5426634e7929541eC2318f3dCF7e' }],
+};
+const STABLE_SYMBOLS = new Set(['USDC', 'USDT', 'DAI', 'DAI.E']);
+/** Whether a symbol is a ~$1 stablecoin (for the inventory's USD estimate). */
+function isStableSymbol(symbol) {
+    return STABLE_SYMBOLS.has(symbol.toUpperCase());
+}
+
+export { DEFAULT_ASSETS, isStableSymbol };
+//# sourceMappingURL=defaultAssets.js.map

package/build/constants/defaultAssets.js.map

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

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

@@ -21,7 +21,7 @@ import { type SignTypedDataPayload } from '../../components/Openfort/types';
  * ```
  */
 export declare function useSignMessage(): {
-    signMessage: (message: string) => Promise<`0x${string}`>;
-    signTypedData: (typedData: SignTypedDataPayload) => Promise<`0x${string}`>;
+    signMessage: (message: string) => Promise<string>;
+    signTypedData: (typedData: SignTypedDataPayload) => Promise<string>;
     isPending: boolean;
 };

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,
@@ -133,8 +135,8 @@ function useUI() {
         openSwitchNetworks: () => gotoAndOpen(routes.ETH_SWITCH_NETWORK),
         openProviders: () => gotoAndOpen(routes.PROVIDERS),
         openWallets: () => gotoAndOpen({ route: routes.CONNECTORS, connectType: 'linkIfUserConnectIfNoUser' }),
-        openSend: (tx) => tx ? openSendPreview(tx) : 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/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/version.d.ts

@@ -1 +1 @@
-export declare const OPENFORT_VERSION = "1.6.0";
+export declare const OPENFORT_VERSION = "1.6.2";

package/build/version.js

@@ -1,4 +1,4 @@
-const OPENFORT_VERSION = '1.6.0';
+const OPENFORT_VERSION = '1.6.2';
 
 export { OPENFORT_VERSION };
 //# sourceMappingURL=version.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openfort/react",
-  "version": "1.6.0",
+  "version": "1.6.2",
   "author": "Openfort (https://www.openfort.io)",
   "license": "BSD-2-Clause license",
   "description": "The easiest way to integrate Openfort to your project.",