@openfort/react 0.3.1 → 1.0.0

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

@@ -0,0 +1,331 @@
+import { jsxs, jsx } from 'react/jsx-runtime';
+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 { useEthereumEmbeddedWallet } from '../../../ethereum/hooks/useEthereumEmbeddedWallet.js';
+import { useEthereumWalletAssets } from '../../../ethereum/hooks/useEthereumWalletAssets.js';
+import { useBalance } from '../../../hooks/useBalance.js';
+import { useOpenfortCore } from '../../../openfort/useOpenfort.js';
+import { useAsyncData } from '../../../shared/hooks/useAsyncData.js';
+import { getExplorerUrl } from '../../../shared/utils/explorer.js';
+import 'detect-browser';
+import { truncateEthAddress } from '../../../utils/format.js';
+import { parseTransactionError } from '../../../utils/errorHandling.js';
+import { logger } from '../../../utils/logger.js';
+import { getChainName, getDefaultEthereumRpcUrl } from '../../../utils/rpc.js';
+import Button from '../../Common/Button/index.js';
+import { CopyText } from '../../Common/CopyToClipboard/CopyText.js';
+import Loader from '../../Common/Loading/index.js';
+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, getAssetSymbol, getAssetDecimals } from '../Send/utils.js';
+import { EstimatedFees } from './EstimatedFees.js';
+import { ButtonRow, SummaryList, SummaryItem, SummaryLabel, AmountValue, AddressValue, FeesValue, CheckIconWrapper, StatusMessage, ErrorContainer, ErrorTitle, ErrorMessage, ErrorAction } from './styles.js';
+
+/** Check if chain is a testnet */
+function isTestnetChain(chainId) {
+    const testnets = new Set([5, 11155111, 80001, 84532, 421614, 97, 4002]);
+    return testnets.has(chainId);
+}
+const SendConfirmation = () => {
+    var _a, _b, _c, _d, _e, _f;
+    const wallet = useEthereumEmbeddedWallet();
+    const { chainType } = useOpenfortCore();
+    const { sendForm, setRoute, triggerResize, walletConfig } = useOpenfort();
+    const address = wallet.status === 'connected' ? wallet.address : undefined;
+    const chainId = wallet.status === 'connected' ? wallet.chainId : undefined;
+    // Build chain info for block explorer
+    const chain = chainId
+        ? {
+            id: chainId,
+            name: getChainName(chainId),
+            blockExplorers: {
+                default: {
+                    url: getExplorerUrl(ChainTypeEnum.EVM, { chainId }),
+                },
+            },
+            testnet: isTestnetChain(chainId),
+        }
+        : undefined;
+    const recipientAddress = isAddress(sendForm.recipient) ? sendForm.recipient : undefined;
+    const normalisedAmount = sanitizeForParsing(sendForm.amount);
+    const { data: assets } = useEthereumWalletAssets();
+    const matchedToken = useMemo(() => assets === null || assets === void 0 ? void 0 : assets.find((asset) => isSameToken(asset, sendForm.asset)), [assets, sendForm.asset]);
+    const selectedTokenOption = matchedToken !== null && matchedToken !== void 0 ? matchedToken : assets === null || assets === void 0 ? void 0 : assets[0];
+    const token = selectedTokenOption !== null && selectedTokenOption !== void 0 ? selectedTokenOption : sendForm.asset;
+    const isErc20 = token.type === 'erc20';
+    const nativeBalance = useBalance({
+        address: address !== null && address !== void 0 ? address : '',
+        chainType: chainType,
+        chainId: chainId !== null && chainId !== void 0 ? chainId : 84532,
+        cluster: chainType === ChainTypeEnum.SVM ? 'devnet' : undefined,
+        enabled: !!address && !isErc20,
+    });
+    const refetchNativeBalance = nativeBalance.refetch;
+    // ERC20 balance using viem publicClient directly (skipped when native send; no placeholder address)
+    const erc20Balance = useAsyncData({
+        queryKey: ['erc20-balance', address, token.type === 'erc20' ? token.address : null, chainId],
+        queryFn: async () => {
+            if (!isErc20 || !address || !chainId)
+                return { value: BigInt(0), decimals: 18, symbol: 'ERC20' };
+            try {
+                const rpcUrl = getDefaultEthereumRpcUrl(chainId);
+                const publicClient = createPublicClient({ transport: http(rpcUrl) });
+                const balance = await publicClient.readContract({
+                    address: token.address,
+                    abi: erc20Abi,
+                    functionName: 'balanceOf',
+                    args: [address],
+                });
+                return { value: balance, decimals: 18, symbol: getAssetSymbol(token) };
+            }
+            catch (error) {
+                logger.error('Failed to fetch ERC20 balance:', error);
+                return { value: BigInt(0), decimals: 18, symbol: getAssetSymbol(token) };
+            }
+        },
+        enabled: Boolean(isErc20 && address && chainId),
+    });
+    const refetchErc20Balance = erc20Balance.refetch;
+    const parsedAmount = normalisedAmount && token && getAssetDecimals(token) !== undefined
+        ? (() => {
+            try {
+                return parseUnits(normalisedAmount, getAssetDecimals(token));
+            }
+            catch (_error) {
+                return null;
+            }
+        })()
+        : null;
+    useEffect(() => {
+        if (!recipientAddress || parsedAmount === null || parsedAmount <= BigInt(0)) {
+            logger.log('INVALID - recipientAddress:', recipientAddress, 'parsedAmount:', parsedAmount);
+            // setRoute(routes.SEND)
+        }
+    }, [recipientAddress, parsedAmount, setRoute]);
+    // Get current balance value from discriminated unions
+    const nativeBalanceValue = nativeBalance.status === 'success' ? nativeBalance.value : undefined;
+    const erc20BalanceValue = erc20Balance.data && !erc20Balance.error ? (_a = erc20Balance.data) === null || _a === void 0 ? void 0 : _a.value : undefined;
+    const currentBalance = isErc20 ? erc20BalanceValue : nativeBalanceValue;
+    const nativeSymbol = nativeBalance.status === 'success' ? nativeBalance.symbol : 'ETH';
+    const insufficientBalance = parsedAmount !== null && currentBalance !== undefined ? parsedAmount > currentBalance : false;
+    // Track original balance and polling state
+    const [isPollingBalance, setIsPollingBalance] = useState(false);
+    const originalBalanceRef = useRef(undefined);
+    const pollingIntervalRef = useRef(null);
+    // Inline transaction state management (replaces useEthereumSendTransaction + useEthereumWriteContract)
+    const [nativeTxHash, setNativeTxHash] = useState(undefined);
+    const [isNativePending, setIsNativePending] = useState(false);
+    const [nativeError, setNativeError] = useState(null);
+    const [erc20TxHash, setErc20TxHash] = useState(undefined);
+    const [isTokenPending, setIsTokenPending] = useState(false);
+    const [erc20Error, setErc20Error] = useState(null);
+    const transactionHash = nativeTxHash !== null && nativeTxHash !== void 0 ? nativeTxHash : erc20TxHash;
+    const sendTransactionAsync = async (params) => {
+        setIsNativePending(true);
+        setNativeError(null);
+        try {
+            if (!wallet.activeWallet)
+                throw new Error('Wallet not available');
+            const provider = await wallet.activeWallet.getProvider();
+            const hash = (await provider.request({
+                method: 'eth_sendTransaction',
+                params: [
+                    {
+                        from: address,
+                        to: params.to,
+                        value: `0x${params.value.toString(16)}`,
+                    },
+                ],
+            }));
+            setNativeTxHash(hash);
+            return hash;
+        }
+        catch (error) {
+            const err = error instanceof Error ? error : new Error(String(error));
+            setNativeError(err);
+            throw err;
+        }
+        finally {
+            setIsNativePending(false);
+        }
+    };
+    const writeContractAsync = async (params) => {
+        setIsTokenPending(true);
+        setErc20Error(null);
+        try {
+            if (!wallet.activeWallet)
+                throw new Error('Wallet not available');
+            const provider = await wallet.activeWallet.getProvider();
+            const data = encodeFunctionData({
+                abi: params.abi,
+                functionName: params.functionName,
+                args: params.args,
+            });
+            const hash = (await provider.request({
+                method: 'eth_sendTransaction',
+                params: [{ from: address, to: params.address, data }],
+            }));
+            setErc20TxHash(hash);
+            return hash;
+        }
+        catch (error) {
+            const err = error instanceof Error ? error : new Error(String(error));
+            setErc20Error(err);
+            throw err;
+        }
+        finally {
+            setIsTokenPending(false);
+        }
+    };
+    const transferData = recipientAddress && parsedAmount !== null && parsedAmount > BigInt(0)
+        ? token.type === 'erc20'
+            ? encodeFunctionData({
+                abi: erc20Abi,
+                functionName: 'transfer',
+                args: [recipientAddress, parsedAmount],
+            })
+            : undefined
+        : undefined;
+    // Wait for transaction receipt using viem publicClient directly
+    const receiptState = useAsyncData({
+        queryKey: ['tx-receipt', transactionHash, chainId],
+        queryFn: async () => {
+            if (!transactionHash || !chainId)
+                return null;
+            try {
+                const rpcUrl = getDefaultEthereumRpcUrl(chainId);
+                const publicClient = createPublicClient({ transport: http(rpcUrl) });
+                const receipt = await publicClient.waitForTransactionReceipt({ hash: transactionHash });
+                return receipt;
+            }
+            catch (error) {
+                logger.error('Failed to get transaction receipt:', error);
+                throw error;
+            }
+        },
+        enabled: Boolean(transactionHash && chainId),
+    });
+    const receipt = receiptState.data;
+    const isWaitingForReceipt = receiptState.isLoading;
+    const isSuccess = receiptState.data && !receiptState.error && ((_b = receiptState.data) === null || _b === void 0 ? void 0 : _b.status) === 'success';
+    const waitError = (_c = receiptState.error) !== null && _c !== void 0 ? _c : null;
+    const isSubmitting = isNativePending || isTokenPending;
+    const isLoading = isSubmitting || isWaitingForReceipt;
+    const firstError = nativeError || erc20Error || waitError;
+    // Store original balance when transaction starts
+    useEffect(() => {
+        if (isSubmitting && originalBalanceRef.current === undefined) {
+            originalBalanceRef.current = currentBalance;
+        }
+    }, [isSubmitting, currentBalance]);
+    // Poll balance when transaction is successful until it changes
+    useEffect(() => {
+        if (isSuccess && originalBalanceRef.current !== undefined) {
+            // Start polling
+            setIsPollingBalance(true);
+            const refetchBalance = isErc20 ? refetchErc20Balance : refetchNativeBalance;
+            // Immediate first refetch
+            refetchBalance();
+            // Set up interval for polling every 3 seconds
+            pollingIntervalRef.current = setInterval(() => {
+                refetchBalance();
+            }, 3000);
+        }
+        return () => {
+            if (pollingIntervalRef.current) {
+                clearInterval(pollingIntervalRef.current);
+                pollingIntervalRef.current = null;
+            }
+        };
+    }, [isSuccess, isErc20, refetchErc20Balance, refetchNativeBalance]);
+    // Stop polling when balance changes
+    useEffect(() => {
+        if (isPollingBalance && currentBalance !== undefined && originalBalanceRef.current !== undefined) {
+            if (currentBalance !== originalBalanceRef.current) {
+                setIsPollingBalance(false);
+                if (pollingIntervalRef.current) {
+                    clearInterval(pollingIntervalRef.current);
+                    pollingIntervalRef.current = null;
+                }
+            }
+        }
+    }, [isPollingBalance, currentBalance]);
+    const handleConfirm = async () => {
+        if (!recipientAddress || !parsedAmount || parsedAmount <= BigInt(0) || insufficientBalance)
+            return;
+        try {
+            if (token.type === 'native') {
+                await sendTransactionAsync({
+                    to: recipientAddress,
+                    value: parsedAmount,
+                    chainId,
+                });
+            }
+            else {
+                await writeContractAsync({
+                    abi: erc20Abi,
+                    address: token.address,
+                    functionName: 'transfer',
+                    args: [recipientAddress, parsedAmount],
+                    chainId,
+                });
+            }
+        }
+        catch (_error) {
+            // Errors are surfaced through mutation hooks
+        }
+    };
+    const handleCancel = () => {
+        // Keep the current token, amount, and recipient when going back - don't reset
+        setRoute(routes.SEND);
+    };
+    const handleFinish = () => {
+        // Clear polling interval if still running
+        if (pollingIntervalRef.current) {
+            clearInterval(pollingIntervalRef.current);
+            pollingIntervalRef.current = null;
+        }
+        setIsPollingBalance(false);
+        // Don't reset the form - keep amount, token, and recipient for easier repeat transactions
+        setRoute(routes.CONNECTED);
+    };
+    const status = isSuccess ? 'success' : firstError ? 'error' : 'idle';
+    const errorDetails = status === 'error' ? parseTransactionError(firstError) : null;
+    const blockExplorerUrl = (_e = (_d = chain === null || chain === void 0 ? void 0 : chain.blockExplorers) === null || _d === void 0 ? void 0 : _d.default) === null || _e === void 0 ? void 0 : _e.url;
+    const handleOpenBlockExplorer = () => {
+        if ((receipt === null || receipt === void 0 ? void 0 : receipt.transactionHash) && blockExplorerUrl) {
+            window.open(`${blockExplorerUrl}/tx/${receipt.transactionHash}`, '_blank', 'noopener,noreferrer');
+        }
+    };
+    useEffect(() => {
+        setTimeout(triggerResize, 10); // delay required here for modal to resize
+    }, [errorDetails, insufficientBalance, receipt === null || receipt === void 0 ? void 0 : receipt.transactionHash, isLoading, triggerResize]);
+    const isSponsored = useMemo(() => {
+        var _a;
+        const feeSponsorship = (_a = walletConfig === null || walletConfig === void 0 ? void 0 : walletConfig.ethereum) === null || _a === void 0 ? void 0 : _a.ethereumFeeSponsorshipId;
+        if (!feeSponsorship)
+            return false;
+        if (typeof feeSponsorship === 'string')
+            return true;
+        return feeSponsorship[chainId !== null && chainId !== void 0 ? chainId : 0] !== undefined;
+    }, [(_f = walletConfig === null || walletConfig === void 0 ? void 0 : walletConfig.ethereum) === null || _f === void 0 ? void 0 : _f.ethereumFeeSponsorshipId, chainId]);
+    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(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',
+                                    marginTop: '4px',
+                                    width: '100%',
+                                    color: 'var(--ck-body-color-valid)',
+                                    fontSize: '12px',
+                                }, children: "Sponsored transaction" }))] })] }), 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 : !recipientAddress || !parsedAmount || parsedAmount <= BigInt(0) || insufficientBalance, waiting: isLoading, icon: isSuccess ? jsx(TickIcon, { style: { width: 18, height: 18 } }) : undefined, children: isSuccess ? 'Confirmed' : isLoading ? 'Confirming...' : 'Confirm' }), isSuccess ? (jsx(Button, { variant: "secondary", onClick: handleFinish, children: "Back to profile" })) : (jsx(Button, { variant: "secondary", onClick: handleCancel, disabled: isLoading, children: "Cancel" }))] })] }));
+};
+
+export { SendConfirmation as default };
+//# sourceMappingURL=index.js.map

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

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

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

@@ -0,0 +1,129 @@
+import styled from '../../../styles/styled/index.js';
+
+const SummaryList = styled.div `
+  display: flex;
+  flex-direction: column;
+  gap: 12px;
+  margin: 20px 0;
+`;
+const SummaryItem = styled.div `
+  display: flex;
+  justify-content: space-between;
+  align-items: center;
+  gap: 12px;
+  text-align: left;
+`;
+const SummaryLabel = styled.span `
+  font-size: 14px;
+  color: var(--ck-body-color-muted);
+`;
+const SummaryValue = styled.span `
+  font-size: 15px;
+  font-weight: 600;
+  color: var(--ck-body-color);
+  text-align: right;
+  word-break: break-all;
+`;
+const AmountValue = styled(SummaryValue) `
+  color: var(--ck-body-color);
+  display: inline-flex;
+  align-items: center;
+  justify-content: flex-end;
+  gap: 8px;
+`;
+const AddressValue = styled(SummaryValue) `
+  display: inline-flex;
+  align-items: center;
+  justify-content: flex-end;
+  gap: 8px;
+`;
+const FeesValue = styled(SummaryValue) `
+  display: inline-flex;
+  align-items: center;
+  justify-content: flex-end;
+  gap: 4px;
+  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;
+  display: inline-flex;
+  align-items: center;
+  
+  svg {
+    width: 16px;
+    height: 16px;
+  }
+`;
+// export const BalanceSpinnerWrapper = styled.span`
+//   display: inline-flex;
+//   align-items: center;
+//   margin-left: 8px;
+//   svg {
+//     width: 14px;
+//     height: 14px;
+//   }
+// `
+const InfoIconWrapper = styled.span `
+  color: var(--ck-body-color-muted);
+  opacity: 0.6;
+  line-height: 0;
+  
+  &:hover {
+    opacity: 1;
+  }
+  
+  svg {
+    display: block;
+    width: 14px;
+    height: 14px;
+    vertical-align: middle;
+  }
+`;
+const ButtonRow = styled.div `
+  display: flex;
+  flex-direction: column;
+  gap: 4px;
+  margin-top: 24px;
+`;
+const StatusMessage = styled.div `
+  margin-top: 16px;
+  font-size: 14px;
+  font-weight: ${(props) => (props.$status === 'idle' ? '600' : '500')};
+  color: ${(props) => {
+    if (props.$status === 'success')
+        return 'var(--ck-body-color-valid)';
+    if (props.$status === 'error')
+        return 'var(--ck-body-color-danger)';
+    return 'var(--ck-body-color)';
+}};
+  text-align: center;
+`;
+const ErrorContainer = styled.div `
+  margin-top: 16px;
+  padding: 16px;
+  background: var(--ck-body-background-secondary);
+  border-radius: 12px;
+  border: 1px solid var(--ck-body-color-danger, rgba(255, 71, 71, 0.2));
+`;
+const ErrorTitle = styled.div `
+  font-size: 15px;
+  font-weight: 600;
+  color: var(--ck-body-color-danger);
+  margin-bottom: 8px;
+`;
+const ErrorMessage = styled.div `
+  font-size: 14px;
+  color: var(--ck-body-color);
+  margin-bottom: 8px;
+  line-height: 1.4;
+`;
+const ErrorAction = styled.div `
+  font-size: 13px;
+  color: var(--ck-body-color-muted);
+  line-height: 1.4;
+`;
+
+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

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

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

@@ -0,0 +1,15 @@
+import { jsxs, jsx } from 'react/jsx-runtime';
+import { useProviders } from '../../../hooks/openfort/useProviders.js';
+import { ModalHeading } from '../../Common/Modal/styles.js';
+import PoweredByFooter from '../../Common/PoweredByFooter/index.js';
+import { ScrollArea } from '../../Common/ScrollArea/index.js';
+import { PageContent } from '../../PageContent/index.js';
+import { ProviderButton } from '../Providers/index.js';
+
+const SocialProviders = () => {
+    const { remainingSocialProviders } = useProviders();
+    return (jsxs(PageContent, { children: [jsx(ModalHeading, { children: "Other socials" }), jsx(ScrollArea, { mobileDirection: 'horizontal', children: remainingSocialProviders.map((auth) => (jsx(ProviderButton, { provider: auth }, auth))) }), jsx(PoweredByFooter, { showDisclaimer: true })] }));
+};
+
+export { SocialProviders as default };
+//# sourceMappingURL=index.js.map

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

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

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

@@ -0,0 +1 @@
+export default function SolanaSendConfirmation(): import("react/jsx-runtime").JSX.Element;

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

@@ -0,0 +1,152 @@
+import { jsxs, jsx } from 'react/jsx-runtime';
+import { ChainTypeEnum } from '@openfort/openfort-js';
+import { createSolanaRpc, address, pipe, createTransactionMessage, setTransactionMessageFeePayer, setTransactionMessageLifetimeUsingBlockhash, appendTransactionMessageInstruction, compileTransaction, getBase64EncodedWireTransaction, getBase58Encoder } from '@solana/kit';
+import { useState, useRef, useCallback, useEffect } from 'react';
+import { TickIcon } from '../../../assets/icons.js';
+import { OpenfortError, OpenfortReactErrorType } from '../../../types.js';
+import { invalidateBalance } from '../../../hooks/useBalance.js';
+import { getExplorerUrl } from '../../../shared/utils/explorer.js';
+import { BASE_FEE_LAMPORTS } from '../../../solana/constants.js';
+import { useSolanaEmbeddedWallet } from '../../../solana/hooks/useSolanaEmbeddedWallet.js';
+import { solToLamports, formatSol } from '../../../solana/hooks/utils.js';
+import { useSolanaContext } from '../../../solana/SolanaContext.js';
+import { createTransferSolInstruction } from '../../../solana/utils/transfer.js';
+import 'detect-browser';
+import { truncateSolanaAddress } from '../../../utils/format.js';
+import Button from '../../Common/Button/index.js';
+import { CopyText } from '../../Common/CopyToClipboard/CopyText.js';
+import Loader from '../../Common/Loading/index.js';
+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 } from '../Send/utils.js';
+import { ButtonRow, SummaryList, SummaryItem, SummaryLabel, AmountValue, AddressValue, FeesValue, CheckIconWrapper, ErrorContainer, ErrorTitle, ErrorMessage } from '../SendConfirmation/styles.js';
+
+const CONFIRM_POLL_MS = 500;
+const CONFIRM_TIMEOUT_MS = 60000;
+async function waitForConfirmation(rpcUrl, signature) {
+    var _a, _b;
+    const deadline = Date.now() + CONFIRM_TIMEOUT_MS;
+    while (Date.now() < deadline) {
+        const res = await fetch(rpcUrl, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({
+                jsonrpc: '2.0',
+                id: 1,
+                method: 'getSignatureStatuses',
+                params: [[signature], { searchTransactionHistory: true }],
+            }),
+        });
+        const data = await res.json();
+        const status = (_b = (_a = data.result) === null || _a === void 0 ? void 0 : _a.value) === null || _b === void 0 ? void 0 : _b[0];
+        if (status === null || status === void 0 ? void 0 : status.err)
+            throw new Error(typeof status.err === 'object' ? JSON.stringify(status.err) : String(status.err));
+        if ((status === null || status === void 0 ? void 0 : status.confirmationStatus) === 'confirmed' || (status === null || status === void 0 ? void 0 : status.confirmationStatus) === 'finalized')
+            return;
+        await new Promise((r) => setTimeout(r, CONFIRM_POLL_MS));
+    }
+    throw new OpenfortError('Transaction confirmation timed out', OpenfortReactErrorType.UNEXPECTED_ERROR);
+}
+const ED25519_SIGNATURE_LENGTH = 64;
+function decodeSignatureToBytes(signature) {
+    const encoded = getBase58Encoder().encode(signature);
+    let bytes = new Uint8Array(encoded);
+    if (bytes.length === ED25519_SIGNATURE_LENGTH + 1) {
+        bytes = bytes.slice(0, ED25519_SIGNATURE_LENGTH);
+    }
+    if (bytes.length === ED25519_SIGNATURE_LENGTH)
+        return bytes;
+    throw new OpenfortError(`Invalid signature: expected ${ED25519_SIGNATURE_LENGTH} bytes, got ${bytes.length}.`, OpenfortReactErrorType.CONFIGURATION_ERROR);
+}
+function SolanaSendConfirmation() {
+    var _a;
+    const { rpcUrl, cluster } = useSolanaContext();
+    const { sendForm, setRoute, triggerResize } = useOpenfort();
+    const wallet = useSolanaEmbeddedWallet();
+    const walletAddress = wallet.status === 'connected' ? (_a = wallet.activeWallet) === null || _a === void 0 ? void 0 : _a.address : undefined;
+    const provider = wallet.status === 'connected' ? wallet.provider : null;
+    const [txStatus, setTxStatus] = useState('idle');
+    const [txSignature, setTxSignature] = useState(null);
+    const [errorMessage, setErrorMessage] = useState(null);
+    const confirmAbortRef = useRef(null);
+    const normalisedAmount = sanitizeForParsing(sendForm.amount);
+    const parsedAmount = normalisedAmount && !Number.isNaN(parseFloat(normalisedAmount)) && parseFloat(normalisedAmount) > 0
+        ? solToLamports(parseFloat(normalisedAmount))
+        : null;
+    const recipient = sendForm.recipient.trim();
+    const isSponsored = false;
+    const canProceed = !!provider &&
+        !!walletAddress &&
+        !!recipient &&
+        parsedAmount !== null &&
+        parsedAmount > BigInt(0) &&
+        txStatus === 'idle';
+    const handleConfirm = useCallback(async () => {
+        var _a;
+        if (!canProceed || !provider || !walletAddress || !parsedAmount || parsedAmount <= BigInt(0))
+            return;
+        setErrorMessage(null);
+        setTxStatus('signing');
+        try {
+            const rpc = createSolanaRpc(rpcUrl);
+            const { value: blockhash } = await rpc.getLatestBlockhash().send();
+            const fromAddress = address(walletAddress);
+            const transferInstruction = createTransferSolInstruction(walletAddress, recipient, parsedAmount);
+            const message = pipe(createTransactionMessage({ version: 0 }), (msg) => setTransactionMessageFeePayer(fromAddress, msg), (msg) => setTransactionMessageLifetimeUsingBlockhash(blockhash, msg), (msg) => appendTransactionMessageInstruction(transferInstruction, msg));
+            const compiled = compileTransaction(message);
+            const signed = await provider.signTransaction({ messageBytes: compiled.messageBytes });
+            const signatureBytes = decodeSignatureToBytes(signed.signature);
+            const signedTransaction = {
+                messageBytes: compiled.messageBytes,
+                signatures: { ...compiled.signatures, [fromAddress]: signatureBytes },
+            };
+            const encodedWire = getBase64EncodedWireTransaction(signedTransaction);
+            setTxStatus('sending');
+            await rpc
+                .sendTransaction(encodedWire, {
+                encoding: 'base64',
+                preflightCommitment: 'confirmed',
+                skipPreflight: false,
+            })
+                .send();
+            (_a = confirmAbortRef.current) === null || _a === void 0 ? void 0 : _a.abort();
+            const confirmController = new AbortController();
+            confirmAbortRef.current = confirmController;
+            await waitForConfirmation(rpcUrl, signed.signature);
+            setTxSignature(signed.signature);
+            setTxStatus('confirmed');
+            invalidateBalance();
+        }
+        catch (err) {
+            if (err instanceof DOMException && err.name === 'AbortError')
+                return;
+            setTxStatus('error');
+            const msg = err instanceof OpenfortError ? err.message : err instanceof Error ? err.message : String(err);
+            setErrorMessage(msg || 'Transaction failed');
+        }
+    }, [canProceed, provider, walletAddress, parsedAmount, recipient, rpcUrl]);
+    useEffect(() => {
+        return () => {
+            var _a;
+            (_a = confirmAbortRef.current) === null || _a === void 0 ? void 0 : _a.abort();
+        };
+    }, []);
+    useEffect(() => {
+        setTimeout(triggerResize, 10);
+    }, [txStatus, errorMessage, triggerResize]);
+    const feeDisplay = `~${formatSol(BASE_FEE_LAMPORTS, 6)} SOL`;
+    const explorerUrl = txSignature && cluster ? getExplorerUrl(ChainTypeEnum.SVM, { txHash: txSignature, cluster }) : undefined;
+    const handleOpenBlockExplorer = () => {
+        if (explorerUrl)
+            window.open(explorerUrl, '_blank', 'noopener,noreferrer');
+    };
+    if (txStatus === 'confirmed') {
+        return (jsxs(PageContent, { onBack: routes.SOL_CONNECTED, children: [jsx(Loader, { isSuccess: true, header: "Transfer Sent", description: `${normalisedAmount || '0'} SOL sent successfully` }), jsxs(ButtonRow, { children: [jsx(Button, { variant: "primary", onClick: handleOpenBlockExplorer, children: "View on Explorer" }), jsx(Button, { variant: "secondary", onClick: () => setRoute(routes.SOL_CONNECTED), 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: [normalisedAmount || '0', " SOL"] })] }), jsxs(SummaryItem, { children: [jsx(SummaryLabel, { children: "From" }), jsx(AddressValue, { children: walletAddress ? (jsx(CopyText, { size: "1rem", value: walletAddress, children: truncateSolanaAddress(walletAddress) })) : ('--') })] }), jsxs(SummaryItem, { children: [jsx(SummaryLabel, { children: "To" }), jsx(AddressValue, { children: recipient ? (jsx(CopyText, { size: "1rem", value: recipient, children: truncateSolanaAddress(recipient) })) : ('--') })] }), jsxs(SummaryItem, { children: [jsx(SummaryLabel, { children: "Network fee" }), jsxs(FeesValue, { "$completed": isSponsored, children: [feeDisplay, jsx(CheckIconWrapper, { children: jsx(TickIcon, {}) })] })] }), isSponsored ] }), errorMessage && (jsxs(ErrorContainer, { children: [jsx(ErrorTitle, { children: "Transaction failed" }), jsx(ErrorMessage, { children: errorMessage })] })), jsxs(ButtonRow, { children: [jsxs(Button, { variant: "primary", onClick: handleConfirm, disabled: !canProceed, waiting: txStatus === 'signing' || txStatus === 'sending', children: [txStatus === 'idle' && 'Confirm', txStatus === 'signing' && 'Signing...', txStatus === 'sending' && 'Sending...', txStatus === 'error' && 'Try again'] }), jsx(Button, { variant: "secondary", onClick: () => setRoute(routes.SOL_SEND), disabled: txStatus !== 'idle', children: "Cancel" })] })] }));
+}
+
+export { SolanaSendConfirmation as default };
+//# sourceMappingURL=index.js.map

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

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

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

@@ -0,0 +1 @@
+export default function SolanaWallets(): import("react/jsx-runtime").JSX.Element;