@openfort/react 1.0.0 → 1.0.1

package/build/assets/icons.js

@@ -1,4 +1,4 @@
-import { jsx, jsxs } from 'react/jsx-runtime';
+import { jsxs, jsx } from 'react/jsx-runtime';
 
 const SendIcon = ({ ...props }) => (jsxs("svg", { "aria-hidden": "true", width: "20", height: "20", viewBox: "0 0 24 24", fill: "none", xmlns: "http://www.w3.org/2000/svg", ...props, children: [jsx("path", { d: "M5 19L19 5", stroke: "currentColor", strokeWidth: "1.75", strokeLinecap: "round", strokeLinejoin: "round" }), jsx("path", { d: "M9 5H19V15", stroke: "currentColor", strokeWidth: "1.75", strokeLinecap: "round", strokeLinejoin: "round" })] }));
 const ReceiveIcon = ({ ...props }) => (jsxs("svg", { "aria-hidden": "true", width: "20", height: "20", viewBox: "0 0 24 24", fill: "none", xmlns: "http://www.w3.org/2000/svg", ...props, children: [jsx("path", { d: "M19 5L5 19", stroke: "currentColor", strokeWidth: "1.75", strokeLinecap: "round", strokeLinejoin: "round" }), jsx("path", { d: "M15 19H5V9", stroke: "currentColor", strokeWidth: "1.75", strokeLinecap: "round", strokeLinejoin: "round" })] }));

package/build/components/ConnectModal/index.js

@@ -44,11 +44,8 @@ import RemoveLinkedProvider from '../Pages/RemoveLinkedProvider/index.js';
 import SelectToken from '../Pages/SelectToken/index.js';
 import SelectWalletToRecover from '../Pages/SelectWalletToRecover/index.js';
 import Send from '../Pages/Send/index.js';
-import { SolanaSend } from '../Pages/Send/SolanaSend.js';
 import SendConfirmation from '../Pages/SendConfirmation/index.js';
 import SocialProviders from '../Pages/SocialProviders/index.js';
-import SolanaSendConfirmation from '../Pages/SolanaSendConfirmation/index.js';
-import SolanaWallets from '../Pages/SolanaWallets/index.js';
 import ConnectUsing from './ConnectUsing.js';
 import ConnectWithMobile from './ConnectWithMobile.js';
 
@@ -112,10 +109,10 @@ const CHAIN_PREFIXED_PAGES = {
         'sol:connected': jsx(Connected, {}),
         'sol:createWallet': jsx(CreateWallet, {}),
         'sol:recoverWallet': jsx(RecoverPage, {}),
-        'sol:send': jsx(SolanaSend, {}),
-        'sol:sendConfirmation': jsx(SolanaSendConfirmation, {}),
+        // 'sol:send': <SolanaSend />,
+        // 'sol:sendConfirmation': <SolanaSendConfirmation />,
         'sol:receive': jsx(Receive, {}),
-        'sol:wallets': jsx(SolanaWallets, {}),
+        // 'sol:wallets': <SolanaWallets />,
     },
 };
 const DEFAULT_CONNECTED_ROUTE = {

package/build/components/ConnectModal/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/Send/index.js

@@ -2,11 +2,10 @@ import { jsx } from 'react/jsx-runtime';
 import { ChainTypeEnum } from '@openfort/openfort-js';
 import { useOpenfortCore } from '../../../openfort/useOpenfort.js';
 import { EthereumSend } from './EthereumSend.js';
-import { SolanaSend } from './SolanaSend.js';
 
 const SEND_REGISTRY = {
     [ChainTypeEnum.EVM]: EthereumSend,
-    [ChainTypeEnum.SVM]: SolanaSend,
+    // [ChainTypeEnum.SVM]: SolanaSend,
 };
 const Send = () => {
     const { chainType } = useOpenfortCore();

package/build/components/Pages/Send/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/solana/hooks/utils.d.ts

@@ -1,2 +1 @@
-export declare function solToLamports(sol: number): bigint;
 export declare function formatSol(lamports: bigint, decimals?: number): string;

package/build/solana/hooks/utils.js

@@ -1,12 +1,4 @@
-import { LAMPORTS_PER_SOL } from '../constants.js';
-
-function solToLamports(sol) {
-    // Use toFixed(9) to avoid scientific notation (e.g. 1e-9) for small values
-    const str = sol.toFixed(9);
-    const [whole = '0', frac = ''] = str.split('.');
-    const padded = frac.slice(0, 9);
-    return BigInt(whole) * LAMPORTS_PER_SOL + BigInt(padded);
-}
+const LAMPORTS_PER_SOL = BigInt(1000000000);
 function formatSol(lamports, decimals = 4) {
     const whole = lamports / LAMPORTS_PER_SOL;
     const remainder = lamports % LAMPORTS_PER_SOL;
@@ -14,5 +6,5 @@ function formatSol(lamports, decimals = 4) {
     return `${whole}.${fracStr}`.replace(new RegExp(`(\\d*\\.\\d{${decimals}})\\d*`), '$1');
 }
 
-export { formatSol, solToLamports };
+export { formatSol };
 //# sourceMappingURL=utils.js.map

package/build/solana/hooks/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/version.d.ts

@@ -1 +1 @@
-export declare const OPENFORT_VERSION = "1.0.0";
+export declare const OPENFORT_VERSION = "1.0.1";

package/build/version.js

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

package/package.json

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

package/build/components/Pages/Send/SolanaSend.d.ts

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

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

@@ -1,93 +0,0 @@
-import { jsxs, jsx } from 'react/jsx-runtime';
-import { useCallback } from 'react';
-import { fetchSolanaBalance } from '../../../hooks/useBalance.js';
-import { useAsyncData } from '../../../shared/hooks/useAsyncData.js';
-import { isValidSolanaAddress } from '../../../shared/utils/validation.js';
-import { BASE_FEE_LAMPORTS, RENT_EXEMPT_MINIMUM_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 { logger } from '../../../utils/logger.js';
-import Button from '../../Common/Button/index.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 { sanitizeForParsing, sanitizeAmountInput } from './utils.js';
-
-const RENT_EXEMPT_LAMPORTS = RENT_EXEMPT_MINIMUM_LAMPORTS;
-function SolanaSend() {
-    var _a, _b, _c;
-    const { rpcUrl } = useSolanaContext();
-    const { sendForm, setSendForm, setRoute } = useOpenfort();
-    const wallet = useSolanaEmbeddedWallet();
-    const recipient = sendForm.recipient;
-    const amount = sendForm.amount;
-    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 balanceResult = useAsyncData({
-        queryKey: ['solana-balance', walletAddress, rpcUrl],
-        queryFn: async () => {
-            if (!walletAddress || !rpcUrl)
-                return null;
-            try {
-                const result = await fetchSolanaBalance(walletAddress, rpcUrl, 'confirmed');
-                return { value: result.value };
-            }
-            catch (error) {
-                logger.error('Failed to fetch Solana balance:', error);
-                return null;
-            }
-        },
-        enabled: Boolean(walletAddress && rpcUrl),
-    });
-    const balanceLamports = (_c = (_b = balanceResult.data) === null || _b === void 0 ? void 0 : _b.value) !== null && _c !== void 0 ? _c : BigInt(0);
-    const recipientValid = recipient.length > 0 && isValidSolanaAddress(recipient);
-    const amountNum = amount === '' || amount === '.' ? null : parseFloat(amount);
-    const amountLamports = amountNum !== null && !Number.isNaN(amountNum) && amountNum > 0 ? solToLamports(amountNum) : null;
-    const insufficientBalance = amountLamports !== null && balanceLamports !== undefined ? amountLamports > balanceLamports : false;
-    const belowRentExempt = amountLamports !== null && balanceLamports !== undefined
-        ? balanceLamports - amountLamports < RENT_EXEMPT_LAMPORTS
-        : false;
-    const hasAmount = amountLamports !== null && amountLamports > BigInt(0);
-    const amountValid = hasAmount && !insufficientBalance && !belowRentExempt;
-    const maxLamports = balanceLamports > BASE_FEE_LAMPORTS ? balanceLamports - BASE_FEE_LAMPORTS - RENT_EXEMPT_LAMPORTS : BigInt(0);
-    const maxLamportsSafe = maxLamports > BigInt(0) ? maxLamports : BigInt(0);
-    const canProceed = recipientValid && amountValid && !!provider;
-    const handleMax = useCallback(() => {
-        if (maxLamportsSafe <= BigInt(0))
-            return;
-        setSendForm((prev) => ({ ...prev, amount: formatSol(maxLamportsSafe, 9) }));
-    }, [maxLamportsSafe, setSendForm]);
-    const handleSubmit = (event) => {
-        event.preventDefault();
-        if (!canProceed || !amountLamports || amountLamports <= BigInt(0))
-            return;
-        const normalized = sanitizeForParsing(amount);
-        if (!normalized)
-            return;
-        setSendForm((prev) => ({
-            ...prev,
-            amount: normalized,
-            recipient,
-            asset: prev.asset,
-        }));
-        setRoute(routes.SOL_SEND_CONFIRMATION);
-    };
-    const handleRecipientChange = (e) => {
-        setSendForm((prev) => ({ ...prev, recipient: e.target.value }));
-    };
-    const handleAmountChange = (e) => {
-        const raw = sanitizeAmountInput(e.target.value);
-        if (raw === '' || /^[0-9]*\.?[0-9]*$/.test(raw)) {
-            setSendForm((prev) => ({ ...prev, amount: raw }));
-        }
-    };
-    const availableLabel = balanceResult.data != null ? formatSol(balanceLamports) : '--';
-    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: amount, onChange: handleAmountChange, inputMode: "decimal", autoComplete: "off", style: { paddingRight: '86px' } }), jsx(MaxButton, { type: "button", onClick: handleMax, disabled: maxLamportsSafe <= BigInt(0), children: "Max" })] }), jsxs(HelperText, { children: ["Available: ", availableLabel, " SOL"] }), amount && amountNum !== null && Number.isNaN(amountNum) && jsx(ErrorText, { children: "Enter a valid amount." }), insufficientBalance && jsx(ErrorText, { children: "Insufficient balance for this transfer." }), belowRentExempt && jsx(ErrorText, { children: "Leave enough for rent-exempt minimum (~0.00089 SOL)." })] }), jsxs(Field, { children: [jsx(FieldLabel, { children: "Recipient address" }), jsx(Input, { placeholder: "Base58 address...", value: recipient, onChange: handleRecipientChange, autoComplete: "off" }), recipient && !recipientValid && jsx(ErrorText, { children: "Enter a valid Solana address." })] }), jsx(Button, { variant: "primary", disabled: !canProceed, type: "submit", children: "Review transfer" })] })] }));
-}
-
-export { SolanaSend };
-//# sourceMappingURL=SolanaSend.js.map

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

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

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

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

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

@@ -1,152 +0,0 @@
-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

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

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

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

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

@@ -1,36 +0,0 @@
-import { jsxs, jsx } from 'react/jsx-runtime';
-import { ChainTypeEnum } from '@openfort/openfort-js';
-import { PlusIcon } from '../../../assets/icons.js';
-import { toSolanaUserWallet } from '../../../hooks/openfort/walletTypes.js';
-import { useOpenfortCore } from '../../../openfort/useOpenfort.js';
-import { useSolanaEmbeddedWallet } from '../../../solana/hooks/useSolanaEmbeddedWallet.js';
-import Button from '../../Common/Button/index.js';
-import { ModalHeading, ModalBody } from '../../Common/Modal/styles.js';
-import { WalletRecoveryIcon } from '../../Common/WalletRecoveryIcon/index.js';
-import { recoverRoute } from '../../Openfort/routeHelpers.js';
-import { routes } from '../../Openfort/types.js';
-import { useOpenfort } from '../../Openfort/useOpenfort.js';
-import { PageContent } from '../../PageContent/index.js';
-import { ProvidersButton, ProviderIcon, ProviderLabel } from '../Providers/styles.js';
-
-function WalletRow({ wallet }) {
-    const { setRoute } = useOpenfort();
-    const { chainType } = useOpenfortCore();
-    const display = wallet.address.length > 12 ? `${wallet.address.slice(0, 4)}...${wallet.address.slice(-4)}` : wallet.address;
-    const handleClick = () => {
-        const walletForRoute = toSolanaUserWallet(wallet);
-        setRoute(recoverRoute(chainType, walletForRoute));
-    };
-    return (jsx(ProvidersButton, { children: jsxs(Button, { onClick: handleClick, children: [jsx(ProviderLabel, { children: display }), jsx(ProviderIcon, { children: jsx(WalletRecoveryIcon, { recovery: wallet.recoveryMethod }) })] }) }));
-}
-function SolanaWallets() {
-    var _a;
-    const { setRoute } = useOpenfort();
-    const embeddedWallet = useSolanaEmbeddedWallet();
-    const wallets = (_a = embeddedWallet.wallets) !== null && _a !== void 0 ? _a : [];
-    const solanaWallets = wallets.filter((w) => w.chainType === ChainTypeEnum.SVM);
-    return (jsxs(PageContent, { onBack: routes.SOL_CONNECTED, children: [jsx(ModalHeading, { children: "Solana Wallets" }), jsxs(ModalBody, { children: [solanaWallets.map((wallet) => (jsx(WalletRow, { wallet: wallet }, wallet.id))), jsx(ProvidersButton, { children: jsx(Button, { onClick: () => setRoute(routes.SOL_CREATE_WALLET), icon: jsx(ProviderIcon, { children: jsx(PlusIcon, {}) }), children: jsx(ProviderLabel, { children: "Create new wallet" }) }) })] })] }));
-}
-
-export { SolanaWallets as default };
-//# sourceMappingURL=index.js.map

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

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

package/build/shared/utils/validation.d.ts

@@ -1,15 +0,0 @@
-/**
- * Address validation utilities (dependency-free).
- *
- * openfort-js does not export address validation. The solana-sample example
- * (openfort-js/examples/apps/solana-sample) uses @solana/kit's address() in a
- * try/catch for Solana. We keep this shared util dependency-free so that
- * consumers that don't use @solana/kit (e.g. EVM-only apps) don't pull it in.
- * For stricter Solana validation when @solana/kit is available, use
- * address(addr) from '@solana/kit' in a try/catch. React-native package has no
- * shared address validation (no Send UI with recipient field in the repo).
- */
-/**
- * Validates a Solana address (Base58, 32–44 characters).
- */
-export declare function isValidSolanaAddress(address: string): boolean;

package/build/shared/utils/validation.js

@@ -1,27 +0,0 @@
-/**
- * Address validation utilities (dependency-free).
- *
- * openfort-js does not export address validation. The solana-sample example
- * (openfort-js/examples/apps/solana-sample) uses @solana/kit's address() in a
- * try/catch for Solana. We keep this shared util dependency-free so that
- * consumers that don't use @solana/kit (e.g. EVM-only apps) don't pull it in.
- * For stricter Solana validation when @solana/kit is available, use
- * address(addr) from '@solana/kit' in a try/catch. React-native package has no
- * shared address validation (no Send UI with recipient field in the repo).
- */
-const BASE58_ALPHABET = '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz';
-function isValidBase58Character(c) {
-    return BASE58_ALPHABET.includes(c);
-}
-/**
- * Validates a Solana address (Base58, 32–44 characters).
- */
-function isValidSolanaAddress(address) {
-    if (typeof address !== 'string' || address.length < 32 || address.length > 44) {
-        return false;
-    }
-    return address.split('').every(isValidBase58Character);
-}
-
-export { isValidSolanaAddress };
-//# sourceMappingURL=validation.js.map

package/build/shared/utils/validation.js.map

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

package/build/solana/constants.d.ts

@@ -1,21 +0,0 @@
-/** System Program's Transfer instruction index (SystemInstruction enum variant 2). */
-export declare const TRANSFER_INSTRUCTION_INDEX = 2;
-export declare const LAMPORTS_PER_SOL: bigint;
-/**
- * Solana System Program address.
- * Not exported by @solana/kit v5 directly — defined here as a typed constant.
- * Source: https://docs.solana.com/developing/runtime-facilities/programs#system-program
- */
-export declare const SYSTEM_PROGRAM_ADDRESS = "11111111111111111111111111111111";
-/**
- * Base fee per signature (5,000 lamports). Does NOT include priority fees,
- * which should be estimated dynamically via getPriorityFeeEstimate.
- * See https://helius.dev/blog/solana-fees-in-theory-and-practice
- */
-export declare const BASE_FEE_LAMPORTS: bigint;
-/**
- * Rent-exempt minimum for a zero-data system account (0 bytes of data).
- * Derived from (128 + 0) bytes * 3,480 lamports/byte-year * 2 years = 890,880 lamports.
- * For accounts with data, use getMinimumBalanceForRentExemption RPC call instead.
- */
-export declare const RENT_EXEMPT_MINIMUM_LAMPORTS: bigint;

package/build/solana/constants.js

@@ -1,24 +0,0 @@
-/** System Program's Transfer instruction index (SystemInstruction enum variant 2). */
-const TRANSFER_INSTRUCTION_INDEX = 2;
-const LAMPORTS_PER_SOL = BigInt(1000000000);
-/**
- * Solana System Program address.
- * Not exported by @solana/kit v5 directly — defined here as a typed constant.
- * Source: https://docs.solana.com/developing/runtime-facilities/programs#system-program
- */
-const SYSTEM_PROGRAM_ADDRESS = '11111111111111111111111111111111';
-/**
- * Base fee per signature (5,000 lamports). Does NOT include priority fees,
- * which should be estimated dynamically via getPriorityFeeEstimate.
- * See https://helius.dev/blog/solana-fees-in-theory-and-practice
- */
-const BASE_FEE_LAMPORTS = BigInt(5000);
-/**
- * Rent-exempt minimum for a zero-data system account (0 bytes of data).
- * Derived from (128 + 0) bytes * 3,480 lamports/byte-year * 2 years = 890,880 lamports.
- * For accounts with data, use getMinimumBalanceForRentExemption RPC call instead.
- */
-const RENT_EXEMPT_MINIMUM_LAMPORTS = BigInt(890880);
-
-export { BASE_FEE_LAMPORTS, LAMPORTS_PER_SOL, RENT_EXEMPT_MINIMUM_LAMPORTS, SYSTEM_PROGRAM_ADDRESS, TRANSFER_INSTRUCTION_INDEX };
-//# sourceMappingURL=constants.js.map

package/build/solana/constants.js.map

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

package/build/solana/utils/transfer.d.ts

@@ -1,9 +0,0 @@
-import { AccountRole, address } from '@solana/kit';
-export declare function createTransferSolInstruction(from: string, to: string, lamports: bigint): {
-    programAddress: ReturnType<typeof address>;
-    data: Uint8Array;
-    accounts: Array<{
-        address: ReturnType<typeof address>;
-        role: AccountRole;
-    }>;
-};

package/build/solana/utils/transfer.js

@@ -1,20 +0,0 @@
-import { address, AccountRole } from '@solana/kit';
-import { TRANSFER_INSTRUCTION_INDEX, SYSTEM_PROGRAM_ADDRESS } from '../constants.js';
-
-function createTransferSolInstruction(from, to, lamports) {
-    const data = new Uint8Array(12);
-    const view = new DataView(data.buffer);
-    view.setUint32(0, TRANSFER_INSTRUCTION_INDEX, true);
-    view.setBigUint64(4, lamports, true);
-    return {
-        programAddress: address(SYSTEM_PROGRAM_ADDRESS),
-        data,
-        accounts: [
-            { address: address(from), role: AccountRole.WRITABLE_SIGNER },
-            { address: address(to), role: AccountRole.WRITABLE },
-        ],
-    };
-}
-
-export { createTransferSolInstruction };
-//# sourceMappingURL=transfer.js.map

package/build/solana/utils/transfer.js.map

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