@openfort/react 1.2.0 → 1.4.0

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

@@ -1,11 +1,15 @@
 import { jsxs, jsx } from 'react/jsx-runtime';
+import { ChainTypeEnum } from '@openfort/openfort-js';
 import { useState, useEffect } from 'react';
 import { formatUnits } from 'viem';
 import { useEthereumWalletAssets } from '../../../ethereum/hooks/useEthereumWalletAssets.js';
+import { useOpenfortCore } from '../../../openfort/useOpenfort.js';
 import { Arrow, ArrowChevron, TextLinkButton } from '../../Common/Button/styles.js';
 import { ModalHeading } from '../../Common/Modal/styles.js';
 import { routes } from '../../Openfort/types.js';
 import { useOpenfort } from '../../Openfort/useOpenfort.js';
+import { EVM_BUY_CURRENCIES } from '../Buy/evmCurrencies.js';
+import { SOLANA_BUY_CURRENCIES } from '../Buy/solanaCurrencies.js';
 import { getAssetSymbol, getAssetDecimals, formatBalanceWithSymbol } from '../Send/utils.js';
 import { SelectTokenContent, EmptyState, TokenList, TokenButton, TokenInfo, TokenSymbol, TokenName, TokenBalance } from './styles.js';
 
@@ -22,9 +26,16 @@ const SelectToken = ({ isBuyFlow }) => {
     useEffect(() => {
         triggerResize();
     }, [viewAllAssets]);
+    const { chainType } = useOpenfortCore();
     const { data: walletAssets, isLoading: isBalancesLoading } = useEthereumWalletAssets();
-    // Show all tokens for both buy and send flows
-    const selectableTokens = walletAssets || [];
+    // Buys pick from a fixed buyable-currency list (USDC first, then native) per
+    // chain family, so the picker always has options even for a fresh wallet with no
+    // indexed balances. The send flow reads the EVM wallet's actual assets.
+    const selectableTokens = isBuyFlow
+        ? chainType === ChainTypeEnum.SVM
+            ? SOLANA_BUY_CURRENCIES
+            : EVM_BUY_CURRENCIES
+        : walletAssets || [];
     const handleSelect = (asset) => {
         var _a;
         // In send flow, don't allow selecting tokens with 0 balance

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

@@ -1,9 +1,10 @@
-export declare const SelectTokenContent: import("styled-components").StyledComponent<({ children, width, onBack, logoutOnBack, header }: {
+export declare const SelectTokenContent: import("styled-components").StyledComponent<({ children, width, onBack, logoutOnBack, header, className, }: {
     children?: React.ReactNode;
     width?: number | string;
     onBack?: import("../../PageContent").SetOnBackFunction;
     logoutOnBack?: boolean;
     header?: string;
+    className?: string;
 }) => import("react/jsx-runtime").JSX.Element, any, {}, never>;
 export declare const TokenList: import("styled-components").StyledComponent<"div", any, {}, never>;
 export declare const TokenButton: import("styled-components").StyledComponent<"button", any, {}, never>;

package/build/components/Pages/Send/SolanaSend.js

@@ -1,16 +1,15 @@
 import { jsxs, jsx } from 'react/jsx-runtime';
 import { useMemo } from 'react';
 import { parseUnits, formatUnits } from 'viem';
-import { fetchSolanaBalance } from '../../../hooks/useBalance.js';
-import { useAsyncData } from '../../../shared/hooks/useAsyncData.js';
-import { useSolanaEmbeddedWallet } from '../../../solana/hooks/useSolanaEmbeddedWallet.js';
+import { useSolanaWalletAssets } from '../../../solana/hooks/useSolanaWalletAssets.js';
 import Button from '../../Common/Button/index.js';
+import { Arrow, ArrowChevron } from '../../Common/Button/styles.js';
 import Input from '../../Common/Input/index.js';
 import { ModalHeading } from '../../Common/Modal/styles.js';
 import { routes } from '../../Openfort/types.js';
 import { useOpenfort } from '../../Openfort/useOpenfort.js';
 import { PageContent } from '../../PageContent/index.js';
-import { Form, Field, FieldLabel, AmountInputWrapper, MaxButton, HelperText, ErrorText } from './styles.js';
+import { Form, Field, FieldLabel, TokenSelectorButton, TokenSelectorContent, TokenSelectorValue, TokenSelectorRight, AmountInputWrapper, MaxButton, HelperText, ErrorText } from './styles.js';
 import { sanitizeForParsing, formatBalance, sanitizeAmountInput } from './utils.js';
 
 const SOL_DECIMALS = 9;
@@ -18,39 +17,40 @@ const SOL_DECIMALS = 9;
 function isLikelySolanaAddress(value) {
     return /^[1-9A-HJ-NP-Za-km-z]{32,44}$/.test(value);
 }
+/** A native SOL asset with the canonical metadata (the default form asset has none). */
+function solAsset(balance) {
+    return {
+        type: 'native',
+        balance,
+        metadata: { symbol: 'SOL', decimals: SOL_DECIMALS, fiat: { value: 0, currency: 'USD' } },
+    };
+}
 const SolanaSend = () => {
-    var _a;
     const { sendForm, setSendForm, setRoute } = useOpenfort();
-    const wallet = useSolanaEmbeddedWallet();
-    const address = wallet.status === 'connected' ? wallet.address : undefined;
-    const rpcUrl = wallet.rpcUrl;
-    const balanceResult = useAsyncData({
-        queryKey: ['solana-balance', address, rpcUrl],
-        queryFn: async () => {
-            if (!address || !rpcUrl)
-                return null;
-            const { value } = await fetchSolanaBalance(address, rpcUrl, 'confirmed');
-            return value;
-        },
-        enabled: Boolean(address && rpcUrl),
-    });
-    const balanceLamports = (_a = balanceResult.data) !== null && _a !== void 0 ? _a : undefined;
+    const { data: assets } = useSolanaWalletAssets();
+    const asset = sendForm.asset;
+    const selected = asset.type === 'spl'
+        ? { isSpl: true, mint: asset.address, decimals: asset.metadata.decimals, symbol: asset.metadata.symbol }
+        : { isSpl: false, mint: 'native', decimals: SOL_DECIMALS, symbol: 'SOL' };
+    // Live balance (base units) for the selected token, matched by mint.
+    const liveToken = assets === null || assets === void 0 ? void 0 : assets.find((t) => (selected.isSpl ? t.mint === selected.mint : t.isNative));
+    const balanceBase = liveToken === null || liveToken === void 0 ? void 0 : liveToken.amount;
     const parsedAmount = useMemo(() => {
         const raw = sanitizeForParsing(sendForm.amount);
         if (!raw)
             return null;
         try {
-            return parseUnits(raw, SOL_DECIMALS);
+            return parseUnits(raw, selected.decimals);
         }
         catch {
             return null;
         }
-    }, [sendForm.amount]);
+    }, [sendForm.amount, selected.decimals]);
     const recipientValid = isLikelySolanaAddress(sendForm.recipient.trim());
-    const insufficientBalance = parsedAmount !== null && balanceLamports !== undefined ? parsedAmount > balanceLamports : false;
+    const insufficientBalance = parsedAmount !== null && balanceBase !== undefined ? parsedAmount > balanceBase : false;
     const amountValid = parsedAmount !== null && parsedAmount > BigInt(0) && !insufficientBalance;
     const canProceed = recipientValid && amountValid;
-    const availableLabel = formatBalance(balanceLamports, SOL_DECIMALS);
+    const availableLabel = formatBalance(balanceBase, selected.decimals);
     const handleSubmit = (event) => {
         event.preventDefault();
         if (!canProceed)
@@ -58,15 +58,15 @@ const SolanaSend = () => {
         const normalized = sanitizeForParsing(sendForm.amount);
         if (!normalized)
             return;
+        // Persist the selected token with its live balance so the confirmation reads it.
+        const nextAsset = asset.type === 'spl'
+            ? { type: 'spl', address: asset.address, balance: balanceBase !== null && balanceBase !== void 0 ? balanceBase : asset.balance, metadata: asset.metadata }
+            : solAsset(balanceBase !== null && balanceBase !== void 0 ? balanceBase : BigInt(0));
         setSendForm((prev) => ({
             ...prev,
             recipient: prev.recipient.trim(),
             amount: normalized,
-            asset: {
-                type: 'native',
-                balance: balanceLamports !== null && balanceLamports !== void 0 ? balanceLamports : BigInt(0),
-                metadata: { symbol: 'SOL', decimals: SOL_DECIMALS, fiat: { value: 0, currency: 'USD' } },
-            },
+            asset: nextAsset,
         }));
         setRoute(routes.SOL_SEND_CONFIRMATION);
     };
@@ -77,11 +77,12 @@ const SolanaSend = () => {
         }
     };
     const handleMax = () => {
-        if (balanceLamports === undefined)
+        if (balanceBase === undefined)
             return;
-        setSendForm((prev) => ({ ...prev, amount: formatUnits(balanceLamports, SOL_DECIMALS) }));
+        setSendForm((prev) => ({ ...prev, amount: formatUnits(balanceBase, selected.decimals) }));
     };
-    return (jsxs(PageContent, { onBack: routes.SOL_CONNECTED, children: [jsx(ModalHeading, { children: "Send SOL" }), jsxs(Form, { onSubmit: handleSubmit, children: [jsxs(Field, { children: [jsx(FieldLabel, { children: "Amount" }), jsxs(AmountInputWrapper, { children: [jsx(Input, { placeholder: "0.00", value: sendForm.amount, onChange: handleAmountChange, inputMode: "decimal", autoComplete: "off", style: { paddingRight: '86px' } }), jsx(MaxButton, { type: "button", onClick: handleMax, disabled: balanceLamports === undefined, children: "Max" })] }), jsxs(HelperText, { children: ["Available: ", availableLabel, " SOL"] }), sendForm.amount && parsedAmount === null && jsx(ErrorText, { children: "Enter a valid amount." }), insufficientBalance && jsx(ErrorText, { children: "Insufficient SOL balance for this transfer." })] }), jsxs(Field, { children: [jsx(FieldLabel, { children: "Recipient address" }), jsx(Input, { placeholder: "Solana address", value: sendForm.recipient, onChange: (e) => setSendForm((prev) => ({ ...prev, recipient: e.target.value })), autoComplete: "off" }), sendForm.recipient && !recipientValid && jsx(ErrorText, { children: "Enter a valid Solana address." })] }), jsx(Button, { variant: "primary", disabled: !canProceed, children: "Review transfer" })] })] }));
+    const handleOpenTokenSelector = () => setRoute(routes.SOL_SEND_TOKEN_SELECT);
+    return (jsxs(PageContent, { onBack: routes.SOL_CONNECTED, children: [jsx(ModalHeading, { children: "Send assets" }), jsxs(Form, { onSubmit: handleSubmit, children: [jsxs(Field, { children: [jsx(FieldLabel, { children: "Asset" }), jsxs(TokenSelectorButton, { type: "button", onClick: handleOpenTokenSelector, children: [jsx(TokenSelectorContent, { children: jsx(TokenSelectorValue, { "$primary": true, children: selected.symbol }) }), jsxs(TokenSelectorRight, { children: [jsx(TokenSelectorValue, { children: availableLabel === '--' ? '--' : `${availableLabel} ${selected.symbol}` }), jsx(Arrow, { width: "13", height: "12", viewBox: "0 0 13 12", fill: "none", xmlns: "http://www.w3.org/2000/svg", children: jsx(ArrowChevron, { stroke: "currentColor", d: "M7.51431 1.5L11.757 5.74264M7.5 10.4858L11.7426 6.24314", strokeWidth: "2", strokeLinecap: "round" }) })] })] })] }), jsxs(Field, { children: [jsx(FieldLabel, { children: "Amount" }), jsxs(AmountInputWrapper, { children: [jsx(Input, { placeholder: "0.00", value: sendForm.amount, onChange: handleAmountChange, inputMode: "decimal", autoComplete: "off", style: { paddingRight: '86px' } }), jsx(MaxButton, { type: "button", onClick: handleMax, disabled: balanceBase === undefined, children: "Max" })] }), jsxs(HelperText, { children: ["Available: ", availableLabel, " ", selected.symbol] }), sendForm.amount && parsedAmount === null && jsx(ErrorText, { children: "Enter a valid amount." }), insufficientBalance && jsxs(ErrorText, { children: ["Insufficient ", selected.symbol, " balance for this transfer."] })] }), jsxs(Field, { children: [jsx(FieldLabel, { children: "Recipient address" }), jsx(Input, { placeholder: "Solana address", value: sendForm.recipient, onChange: (e) => setSendForm((prev) => ({ ...prev, recipient: e.target.value })), autoComplete: "off" }), sendForm.recipient && !recipientValid && jsx(ErrorText, { children: "Enter a valid Solana address." })] }), jsx(Button, { variant: "primary", disabled: !canProceed, children: "Review transfer" })] })] }));
 };
 
 export { SolanaSend };

package/build/components/Pages/Send/SolanaSend.js.map

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

package/build/components/Pages/Send/utils.js

@@ -44,10 +44,13 @@ const isSameToken = (a, b) => {
         return false;
     if (a.type === 'native')
         return true;
-    // At this point, a.type === 'erc20' and b.type === 'erc20'
     if (a.type === 'erc20' && b.type === 'erc20') {
         return a.address.toLowerCase() === b.address.toLowerCase();
     }
+    // SPL mints are base58 and case-sensitive — compare verbatim.
+    if (a.type === 'spl' && b.type === 'spl') {
+        return a.address === b.address;
+    }
     return false;
 };
 const getAssetSymbol = (asset) => {

package/build/components/Pages/Send/utils.js.map

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

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

@@ -1,9 +1,10 @@
 import { jsxs, jsx } from 'react/jsx-runtime';
 import { ChainTypeEnum } from '@openfort/openfort-js';
 import { useState, useEffect } from 'react';
+import { parseUnits } from 'viem';
 import { getExplorerUrl } from '../../../shared/utils/explorer.js';
 import { useSolanaEmbeddedWallet } from '../../../solana/hooks/useSolanaEmbeddedWallet.js';
-import { sendSolGasless, sendSol } from '../../../solana/transfer.js';
+import { sendSplTokenGasless, sendSplToken, sendSolGasless, sendSol } from '../../../solana/transfer.js';
 import 'detect-browser';
 import { truncateSolanaAddress } from '../../../utils/format.js';
 import Button from '../../Common/Button/index.js';
@@ -13,11 +14,12 @@ 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 { ButtonRow, SummaryList, SummaryItem, SummaryLabel, AmountValue, AddressValue, GaslessRow, GaslessToggle, ErrorContainer, ErrorTitle, ErrorMessage } from './styles.js';
+import { ButtonRow, SummaryList, SummaryItem, SummaryLabel, AmountValue, AddressValue, FeesValue, ErrorContainer, ErrorTitle, ErrorMessage } from './styles.js';
 
+const SOL_DECIMALS = 9;
 const SolanaSendConfirmation = () => {
-    var _a;
-    const { sendForm, setRoute, publishableKey, triggerResize } = useOpenfort();
+    var _a, _b;
+    const { sendForm, setRoute, publishableKey, triggerResize, walletConfig } = useOpenfort();
     const wallet = useSolanaEmbeddedWallet();
     const address = wallet.status === 'connected' ? wallet.address : undefined;
     const provider = wallet.status === 'connected' ? wallet.provider : undefined;
@@ -25,7 +27,11 @@ const SolanaSendConfirmation = () => {
     const rpcUrl = wallet.rpcUrl;
     const recipient = sendForm.recipient;
     const amount = sendForm.amount;
-    const [gasless, setGasless] = useState(false);
+    const asset = sendForm.asset;
+    const symbol = asset.type === 'spl' ? asset.metadata.symbol : 'SOL';
+    const decimals = asset.type === 'spl' ? asset.metadata.decimals : SOL_DECIMALS;
+    // Fees are sponsored from config (the SVM counterpart of ethereumFeeSponsorshipId).
+    const isSponsored = Boolean((_b = walletConfig === null || walletConfig === void 0 ? void 0 : walletConfig.solana) === null || _b === void 0 ? void 0 : _b.sponsorFees);
     const [isLoading, setIsLoading] = useState(false);
     const [signature, setSignature] = useState(null);
     const [error, setError] = useState(null);
@@ -37,21 +43,59 @@ const SolanaSendConfirmation = () => {
     const handleConfirm = async () => {
         if (!address || !provider || isLoading)
             return;
-        const amountSol = Number(amount);
-        if (!Number.isFinite(amountSol) || amountSol <= 0) {
+        // The Send screen validates these before navigating here; re-guard in case
+        // this page is reached directly with an unvalidated form.
+        if (!recipient.trim()) {
+            setError('Enter a recipient address.');
+            return;
+        }
+        const amountNum = Number(amount);
+        if (!Number.isFinite(amountNum) || amountNum <= 0) {
             setError('Enter a valid amount.');
             return;
         }
-        if (!gasless && !rpcUrl) {
+        if (!isSponsored && !rpcUrl) {
             setError('No Solana RPC is configured for this network.');
             return;
         }
         setIsLoading(true);
         setError(null);
         try {
-            const sig = gasless
-                ? await sendSolGasless({ from: address, to: recipient, amountSol, provider, cluster, publishableKey })
-                : await sendSol({ from: address, to: recipient, amountSol, provider, rpcUrl: rpcUrl !== null && rpcUrl !== void 0 ? rpcUrl : '' });
+            let sig;
+            if (asset.type === 'spl') {
+                const baseUnits = parseUnits(amount, decimals);
+                sig = isSponsored
+                    ? await sendSplTokenGasless({
+                        from: address,
+                        to: recipient,
+                        mint: asset.address,
+                        amount: baseUnits,
+                        provider,
+                        cluster,
+                        publishableKey,
+                    })
+                    : await sendSplToken({
+                        from: address,
+                        to: recipient,
+                        mint: asset.address,
+                        amount: baseUnits,
+                        decimals,
+                        provider,
+                        rpcUrl: rpcUrl !== null && rpcUrl !== void 0 ? rpcUrl : '',
+                    });
+            }
+            else {
+                sig = isSponsored
+                    ? await sendSolGasless({
+                        from: address,
+                        to: recipient,
+                        amountSol: amountNum,
+                        provider,
+                        cluster,
+                        publishableKey,
+                    })
+                    : await sendSol({ from: address, to: recipient, amountSol: amountNum, provider, rpcUrl: rpcUrl !== null && rpcUrl !== void 0 ? rpcUrl : '' });
+            }
             setSignature(sig);
         }
         catch (err) {
@@ -68,9 +112,9 @@ const SolanaSendConfirmation = () => {
         window.open(getExplorerUrl(ChainTypeEnum.SVM, { txHash: signature, cluster }), '_blank', 'noopener,noreferrer');
     };
     if (signature) {
-        return (jsxs(PageContent, { children: [jsx(Loader, { isSuccess: true, header: "Transfer sent", description: `${amount} SOL sent successfully` }), jsxs(ButtonRow, { children: [jsx(Button, { variant: "primary", onClick: handleViewExplorer, children: "View on Explorer" }), jsx(Button, { variant: "secondary", onClick: handleFinish, children: "Back to profile" })] })] }));
+        return (jsxs(PageContent, { children: [jsx(Loader, { isSuccess: true, header: "Transfer sent", description: `${amount} ${symbol} sent successfully` }), jsxs(ButtonRow, { children: [jsx(Button, { variant: "primary", onClick: handleViewExplorer, children: "View on Explorer" }), jsx(Button, { variant: "secondary", onClick: handleFinish, children: "Back to profile" })] })] }));
     }
-    return (jsxs(PageContent, { onBack: routes.SOL_SEND, children: [jsx(ModalHeading, { children: "Confirm transfer" }), jsx(ModalBody, { children: "Review the transaction details before sending." }), jsxs(SummaryList, { children: [jsxs(SummaryItem, { children: [jsx(SummaryLabel, { children: "Sending" }), jsxs(AmountValue, { children: [amount || '0', " SOL"] })] }), jsxs(SummaryItem, { children: [jsx(SummaryLabel, { children: "From" }), jsx(AddressValue, { children: address ? (jsx(CopyText, { size: "1rem", value: address, children: truncateSolanaAddress(address) })) : ('--') })] }), jsxs(SummaryItem, { children: [jsx(SummaryLabel, { children: "To" }), jsx(AddressValue, { children: recipient ? (jsx(CopyText, { size: "1rem", value: recipient, children: truncateSolanaAddress(recipient) })) : ('--') })] })] }), jsxs(GaslessRow, { children: [jsxs("div", { children: [jsx(SummaryLabel, { children: "Sponsor network fee" }), jsx("div", { style: { fontSize: 12, color: 'var(--ck-body-color-muted)', marginTop: 2 }, children: "Pay no SOL fee (requires a sponsorship policy)" })] }), jsx(GaslessToggle, { type: "button", role: "switch", "aria-checked": gasless, "aria-label": "Sponsor network fee", "$on": gasless, onClick: () => setGasless((v) => !v), disabled: isLoading, children: jsx("span", {}) })] }), error && (jsxs(ErrorContainer, { children: [jsx(ErrorTitle, { children: "Transaction failed" }), jsx(ErrorMessage, { children: error })] })), jsxs(ButtonRow, { children: [jsx(Button, { variant: "primary", onClick: handleConfirm, disabled: !address || isLoading, waiting: isLoading, children: isLoading ? 'Confirming...' : 'Confirm' }), jsx(Button, { variant: "secondary", onClick: () => setRoute(routes.SOL_SEND), disabled: isLoading, children: "Cancel" })] })] }));
+    return (jsxs(PageContent, { onBack: routes.SOL_SEND, children: [jsx(ModalHeading, { children: "Confirm transfer" }), jsx(ModalBody, { children: "Review the transaction details before sending." }), jsxs(SummaryList, { children: [jsxs(SummaryItem, { children: [jsx(SummaryLabel, { children: "Sending" }), jsxs(AmountValue, { children: [amount || '0', " ", symbol] })] }), jsxs(SummaryItem, { children: [jsx(SummaryLabel, { children: "From" }), jsx(AddressValue, { children: address ? (jsx(CopyText, { size: "1rem", value: address, children: truncateSolanaAddress(address) })) : ('--') })] }), jsxs(SummaryItem, { children: [jsx(SummaryLabel, { children: "To" }), jsx(AddressValue, { children: recipient ? (jsx(CopyText, { size: "1rem", value: recipient, children: truncateSolanaAddress(recipient) })) : ('--') })] }), isSponsored && (jsxs(SummaryItem, { children: [jsx(SummaryLabel, { children: "Network fee" }), jsx(FeesValue, { "$completed": true, children: "Sponsored" })] }))] }), error && (jsxs(ErrorContainer, { children: [jsx(ErrorTitle, { children: "Transaction failed" }), jsx(ErrorMessage, { children: error })] })), jsxs(ButtonRow, { children: [jsx(Button, { variant: "primary", onClick: handleConfirm, disabled: !address || isLoading, waiting: isLoading, children: isLoading ? 'Confirming...' : 'Confirm' }), jsx(Button, { variant: "secondary", onClick: () => setRoute(routes.SOL_SEND), disabled: isLoading, children: "Cancel" })] })] }));
 };
 
 export { SolanaSendConfirmation };

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

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

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

@@ -329,7 +329,7 @@ const SendConfirmation = () => {
     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: [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(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 details before sending." }), jsxs(SummaryList, { children: [jsxs(SummaryItem, { children: [jsx(SummaryLabel, { children: "Sending" }), jsxs(AmountValue, { children: [normalisedAmount || '0', " ", getAssetSymbol(token)] })] }), jsxs(SummaryItem, { children: [jsx(SummaryLabel, { children: "From" }), jsx(AddressValue, { children: address ? (jsx(CopyText, { size: "1rem", value: address, children: truncateEthAddress(address) })) : ('--') })] }), jsxs(SummaryItem, { children: [jsx(SummaryLabel, { children: "To" }), jsx(AddressValue, { children: recipientAddress ? (jsx(CopyText, { size: "1rem", value: recipientAddress, children: truncateEthAddress(recipientAddress) })) : ('--') })] }), jsxs("div", { children: [jsxs(SummaryItem, { children: [jsx(SummaryLabel, { children: "Estimated fees" }), jsxs(FeesValue, { "$completed": isSponsored, 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: isSponsored }), jsx(CheckIconWrapper, { children: jsx(TickIcon, {}) })] })] }), isSponsored && (jsx("div", { style: {
                                     textAlign: 'end',

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

@@ -16,8 +16,3 @@ export declare const ErrorContainer: import("styled-components").StyledComponent
 export declare const ErrorTitle: import("styled-components").StyledComponent<"div", any, {}, never>;
 export declare const ErrorMessage: import("styled-components").StyledComponent<"div", any, {}, never>;
 export declare const ErrorAction: import("styled-components").StyledComponent<"div", any, {}, never>;
-export declare const GaslessRow: import("styled-components").StyledComponent<"div", any, {}, never>;
-/** A minimal theme-aware switch for the Solana "sponsor fee" toggle. */
-export declare const GaslessToggle: import("styled-components").StyledComponent<"button", any, {
-    $on?: boolean;
-}, never>;

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

@@ -124,44 +124,6 @@ const ErrorAction = styled.div `
   color: var(--ck-body-color-muted);
   line-height: 1.4;
 `;
-const GaslessRow = styled.div `
-  display: flex;
-  align-items: center;
-  justify-content: space-between;
-  gap: 12px;
-  margin: 4px 0 8px;
-  text-align: left;
-`;
-/** A minimal theme-aware switch for the Solana "sponsor fee" toggle. */
-const GaslessToggle = styled.button `
-  position: relative;
-  flex-shrink: 0;
-  width: 40px;
-  height: 24px;
-  border-radius: 999px;
-  border: 1px solid var(--ck-body-divider);
-  background: ${(props) => (props.$on ? 'var(--ck-body-color-valid, #22c55e)' : 'var(--ck-body-background-secondary)')};
-  cursor: pointer;
-  transition: background 150ms ease;
-  padding: 0;
-
-  &:disabled {
-    opacity: 0.5;
-    cursor: not-allowed;
-  }
-
-  > span {
-    position: absolute;
-    top: 50%;
-    left: ${(props) => (props.$on ? '18px' : '2px')};
-    transform: translateY(-50%);
-    width: 18px;
-    height: 18px;
-    border-radius: 50%;
-    background: #fff;
-    transition: left 150ms ease;
-  }
-`;
 
-export { AddressValue, AmountValue, ButtonRow, CheckIconWrapper, ErrorAction, ErrorContainer, ErrorMessage, ErrorTitle, FeesValue, GaslessRow, GaslessToggle, InfoIconWrapper, StatusMessage, SummaryItem, SummaryLabel, SummaryList };
+export { AddressValue, AmountValue, ButtonRow, CheckIconWrapper, ErrorAction, ErrorContainer, ErrorMessage, ErrorTitle, FeesValue, InfoIconWrapper, 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/constants/chainConfigs.js

@@ -27,28 +27,28 @@ const chainConfigs = [
     {
         id: 37111,
         name: 'Lens Chain Testnet',
-        logo: jsx(ChainIcons.LensChain, { testnet: true }),
+        logo: jsx(ChainIcons.LensChain, {}),
     },
     {
         id: 3,
         name: 'Rinkeby',
-        logo: jsx(ChainIcons.Ethereum, { testnet: true }),
+        logo: jsx(ChainIcons.Ethereum, {}),
         rpcUrls: {},
     },
     {
         id: 4,
         name: 'Ropsten',
-        logo: jsx(ChainIcons.Ethereum, { testnet: true }),
+        logo: jsx(ChainIcons.Ethereum, {}),
     },
     {
         id: 5,
         name: 'Görli',
-        logo: jsx(ChainIcons.Ethereum, { testnet: true }),
+        logo: jsx(ChainIcons.Ethereum, {}),
     },
     {
         id: 42,
         name: 'Kovan',
-        logo: jsx(ChainIcons.Ethereum, { testnet: true }),
+        logo: jsx(ChainIcons.Ethereum, {}),
     },
     {
         id: 10,
@@ -58,17 +58,17 @@ const chainConfigs = [
     {
         id: 69, // nice
         name: 'Optimism Kovan',
-        logo: jsx(ChainIcons.Optimism, { testnet: true }),
+        logo: jsx(ChainIcons.Optimism, {}),
     },
     {
         id: 420, // nice
         name: 'Optimism Goerli',
-        logo: jsx(ChainIcons.Optimism, { testnet: true }),
+        logo: jsx(ChainIcons.Optimism, {}),
     },
     {
         id: 11155420,
         name: 'Optimism Sepolia',
-        logo: jsx(ChainIcons.Optimism, { testnet: true }),
+        logo: jsx(ChainIcons.Optimism, {}),
     },
     {
         id: 137,
@@ -78,27 +78,27 @@ const chainConfigs = [
     {
         id: 80001,
         name: 'Polygon Mumbai',
-        logo: jsx(ChainIcons.Polygon, { testnet: true }),
+        logo: jsx(ChainIcons.Polygon, {}),
     },
     {
         id: 80002,
         name: 'Polygon Amoy',
-        logo: jsx(ChainIcons.Polygon, { testnet: true }),
+        logo: jsx(ChainIcons.Polygon, {}),
     },
     {
         id: 13337,
         name: 'Beam Testnet',
-        logo: jsx(ChainIcons.Avalanche, { testnet: true }),
+        logo: jsx(ChainIcons.Avalanche, {}),
     },
     {
         id: 31337,
         name: 'Hardhat',
-        logo: jsx(ChainIcons.Ethereum, { testnet: true }),
+        logo: jsx(ChainIcons.Ethereum, {}),
     },
     {
         id: 1337,
         name: 'Localhost',
-        logo: jsx(ChainIcons.Ethereum, { testnet: true }),
+        logo: jsx(ChainIcons.Ethereum, {}),
     },
     {
         id: 42161,
@@ -118,12 +118,12 @@ const chainConfigs = [
     {
         id: 421611,
         name: 'Arbitrum Rinkeby',
-        logo: jsx(ChainIcons.Arbitrum, { testnet: true }),
+        logo: jsx(ChainIcons.Arbitrum, {}),
     },
     {
         id: 421613,
         name: 'Arbitrum Goerli',
-        logo: jsx(ChainIcons.Arbitrum, { testnet: true }),
+        logo: jsx(ChainIcons.Arbitrum, {}),
         rpcUrls: {
             alchemy: {
                 http: ['https://arb-goerli.g.alchemy.com/v2'],
@@ -143,7 +143,7 @@ const chainConfigs = [
     {
         id: 41,
         name: 'Telos Testnet',
-        logo: jsx(ChainIcons.Telos, { testnet: true }),
+        logo: jsx(ChainIcons.Telos, {}),
     },
     {
         id: 1313161554,
@@ -153,7 +153,7 @@ const chainConfigs = [
     {
         id: 1313161555,
         name: 'Aurora Testnet',
-        logo: jsx(ChainIcons.Aurora, { testnet: true }),
+        logo: jsx(ChainIcons.Aurora, {}),
     },
     {
         id: 43114,
@@ -163,12 +163,12 @@ const chainConfigs = [
     {
         id: 43113,
         name: 'Avalanche Fuji',
-        logo: jsx(ChainIcons.Avalanche, { testnet: true }),
+        logo: jsx(ChainIcons.Avalanche, {}),
     },
     {
         id: 31337,
         name: 'Foundry',
-        logo: jsx(ChainIcons.Foundry, { testnet: true }),
+        logo: jsx(ChainIcons.Foundry, {}),
     },
     {
         id: 100,
@@ -183,7 +183,7 @@ const chainConfigs = [
     {
         id: 9000,
         name: 'Evmos Testnet',
-        logo: jsx(ChainIcons.Evmos, { testnet: true }),
+        logo: jsx(ChainIcons.Evmos, {}),
     },
     {
         id: 56,
@@ -193,7 +193,7 @@ const chainConfigs = [
     {
         id: 97,
         name: 'Binance Smart Chain Testnet',
-        logo: jsx(ChainIcons.BinanceSmartChain, { testnet: true }),
+        logo: jsx(ChainIcons.BinanceSmartChain, {}),
     },
     {
         id: 11155111,
@@ -208,7 +208,7 @@ const chainConfigs = [
     {
         id: 842,
         name: 'Taraxa Testnet',
-        logo: jsx(ChainIcons.Taraxa, { testnet: true }),
+        logo: jsx(ChainIcons.Taraxa, {}),
     },
     {
         id: 324,
@@ -218,7 +218,7 @@ const chainConfigs = [
     {
         id: 280,
         name: 'zkSync Testnet',
-        logo: jsx(ChainIcons.zkSync, { testnet: true }),
+        logo: jsx(ChainIcons.zkSync, {}),
     },
     {
         id: 42220,
@@ -228,7 +228,7 @@ const chainConfigs = [
     {
         id: 44787,
         name: 'Celo Alfajores',
-        logo: jsx(ChainIcons.Celo, { testnet: true }),
+        logo: jsx(ChainIcons.Celo, {}),
     },
     {
         id: 7700,
@@ -253,12 +253,12 @@ const chainConfigs = [
     {
         id: 3141,
         name: 'Filecoin Hyperspace',
-        logo: jsx(ChainIcons.Filecoin, { testnet: true }),
+        logo: jsx(ChainIcons.Filecoin, {}),
     },
     {
         id: 314159,
         name: 'Filecoin Calibration',
-        logo: jsx(ChainIcons.Filecoin, { testnet: true }),
+        logo: jsx(ChainIcons.Filecoin, {}),
     },
     {
         id: 1088,
@@ -268,7 +268,7 @@ const chainConfigs = [
     {
         id: 599,
         name: 'Metis Goerli',
-        logo: jsx(ChainIcons.Metis, { testnet: true }),
+        logo: jsx(ChainIcons.Metis, {}),
     },
     {
         id: 4689,
@@ -278,7 +278,7 @@ const chainConfigs = [
     {
         id: 4690,
         name: 'IoTeX Testnet',
-        logo: jsx(ChainIcons.IoTeX, { testnet: true }),
+        logo: jsx(ChainIcons.IoTeX, {}),
     },
     {
         id: 8453,
@@ -288,12 +288,12 @@ const chainConfigs = [
     {
         id: 84531,
         name: 'Base Goerli',
-        logo: jsx(ChainIcons.Base, { testnet: true }),
+        logo: jsx(ChainIcons.Base, {}),
     },
     {
         id: 84532,
         name: 'Base Sepolia',
-        logo: jsx(ChainIcons.Base, { testnet: true }),
+        logo: jsx(ChainIcons.Base, {}),
     },
     {
         id: 7777777,
@@ -303,12 +303,12 @@ const chainConfigs = [
     {
         id: 999999999,
         name: 'Zora Sepolia',
-        logo: jsx(ChainIcons.Zora, { testnet: true }),
+        logo: jsx(ChainIcons.Zora, {}),
     },
     {
         id: 999,
         name: 'Zora Goerli Testnet',
-        logo: jsx(ChainIcons.Zora, { testnet: true }),
+        logo: jsx(ChainIcons.Zora, {}),
     },
 ];