@openfort/react 0.3.1 → 1.0.0

package/build/types.d.ts

@@ -11,7 +11,7 @@ export type All = {
     lang?: Languages;
 };
 export type { CustomAvatarProps } from './components/Common/Avatar';
-export type { ConnectUIOptions as OpenfortOptions, CustomizableRoutes, OpenfortWalletConfig, PhoneConfig, } from './components/Openfort/types';
+export type { ConnectUIOptions as OpenfortOptions, OpenfortWalletConfig, PhoneConfig, } from './components/Openfort/types';
 export declare enum OpenfortReactErrorType {
     AUTHENTICATION_ERROR = "AUTHENTICATION_ERROR",
     WALLET_ERROR = "WALLET_ERROR",
@@ -19,20 +19,19 @@ export declare enum OpenfortReactErrorType {
     VALIDATION_ERROR = "VALIDATION_ERROR",
     UNEXPECTED_ERROR = "UNEXPECTED_ERROR"
 }
-interface Data {
-    [key: string]: any;
+interface OpenfortErrorData {
+    [key: string]: unknown;
 }
 export declare class OpenfortError extends Error {
     type: OpenfortReactErrorType;
-    data: Data;
-    constructor(message: string, type: OpenfortReactErrorType, data?: Data);
+    data: OpenfortErrorData;
+    constructor(message: string, type: OpenfortReactErrorType, data?: OpenfortErrorData);
 }
 export type OpenfortHookOptions<T = {
     error?: OpenfortError;
 }> = {
     onSuccess?: (data: T) => void;
     onError?: (error: OpenfortError) => void;
-    onSettled?: (data: T | undefined | null, error: OpenfortError | null) => void;
     throwOnError?: boolean;
 };
 export { OAuthProvider, SDKOverrides, ThirdPartyOAuthProvider, } from '@openfort/openfort-js';

package/build/types.js

@@ -0,0 +1,33 @@
+export { OAuthProvider, ThirdPartyOAuthProvider } from '@openfort/openfort-js';
+
+var OpenfortReactErrorType;
+(function (OpenfortReactErrorType) {
+    OpenfortReactErrorType["AUTHENTICATION_ERROR"] = "AUTHENTICATION_ERROR";
+    OpenfortReactErrorType["WALLET_ERROR"] = "WALLET_ERROR";
+    OpenfortReactErrorType["CONFIGURATION_ERROR"] = "CONFIGURATION_ERROR";
+    OpenfortReactErrorType["VALIDATION_ERROR"] = "VALIDATION_ERROR";
+    OpenfortReactErrorType["UNEXPECTED_ERROR"] = "UNEXPECTED_ERROR";
+})(OpenfortReactErrorType || (OpenfortReactErrorType = {}));
+class OpenfortError extends Error {
+    constructor(message, type, data) {
+        if ((data === null || data === void 0 ? void 0 : data.error) instanceof OpenfortError) {
+            super(data.error.message);
+            this.data = Object.freeze(data.error.data);
+            this.type = data.error.type;
+            this.name = data.error.name;
+            return;
+        }
+        if ((data === null || data === void 0 ? void 0 : data.error) instanceof Error) {
+            super(data.error.message);
+        }
+        else {
+            super(message);
+        }
+        this.type = type;
+        this.data = Object.freeze(data !== null && data !== void 0 ? data : {});
+        this.name = 'OpenfortError';
+    }
+}
+
+export { OpenfortError, OpenfortReactErrorType };
+//# sourceMappingURL=types.js.map

package/build/types.js.map

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

package/build/utils/banner.d.ts

@@ -0,0 +1 @@
+export declare function showInitBanner(): void;

package/build/utils/banner.js

@@ -0,0 +1,14 @@
+import { OPENFORT_VERSION } from '../version.js';
+
+// SVG logo via background-image data URI is supported in Chrome/Firefox if desired later.
+let _shown = false;
+function showInitBanner() {
+    if (_shown || process.env.NODE_ENV === 'production')
+        return;
+    _shown = true;
+    // biome-ignore lint/suspicious/noConsole: intentional SDK init banner
+    console.log(`%c \uD83D\uDCE6 Openfort React SDK %c v${OPENFORT_VERSION} %c \u2197 openfort.io/docs`, 'background:#0f0f0f;color:#fff;padding:2px 6px;border-radius:4px 0 0 4px;font-weight:600', 'background:#333;color:#aaa;padding:2px 6px;border-radius:0 4px 4px 0', 'color:#888;padding:2px 4px');
+}
+
+export { showInitBanner };
+//# sourceMappingURL=banner.js.map

package/build/utils/banner.js.map

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

package/build/utils/errorHandling.js

@@ -0,0 +1,331 @@
+/**
+ * Parses common Web3/RPC errors and returns user-friendly error messages
+ * Covers errors from viem, wagmi, and blockchain interactions
+ * Based on viem error types: https://v1.viem.sh/docs/glossary/errors.html
+ */
+function parseTransactionError(error) {
+    if (!error) {
+        return {
+            title: 'Transaction failed',
+            message: 'An unknown error occurred.',
+        };
+    }
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    const errorString = errorMessage.toLowerCase();
+    const errorName = error instanceof Error ? error.name : '';
+    // UserRejectedRequestError - User explicitly denied/rejected the request
+    // https://v1.viem.sh/docs/glossary/errors.html#userrejectedrequesterror
+    if (errorName === 'UserRejectedRequestError' ||
+        errorString.includes('user rejected') ||
+        errorString.includes('user denied') ||
+        errorString.includes('user cancelled') ||
+        errorString.includes('user canceled') ||
+        errorString.includes('rejected the request') ||
+        errorString.includes('transaction was rejected')) {
+        return {
+            title: 'Transaction cancelled',
+            message: 'You cancelled the transaction.',
+        };
+    }
+    // AccountNotFoundError - No account provided to action that requires one
+    // https://v1.viem.sh/docs/glossary/errors.html#accountnotfounderror
+    if (errorName === 'AccountNotFoundError' || errorString.includes('account not found')) {
+        return {
+            title: 'Account not found',
+            message: 'No account is connected.',
+            action: 'Please connect your wallet and try again.',
+        };
+    }
+    // InsufficientFundsError - Not enough funds for gas
+    // https://v1.viem.sh/docs/glossary/errors.html#insufficientfundserror
+    if (errorName === 'InsufficientFundsError' ||
+        errorString.includes('insufficient funds') ||
+        errorString.includes('insufficient balance') ||
+        errorString.includes('exceeds balance') ||
+        errorString.includes('insufficient eth') ||
+        errorString.includes("sender doesn't have enough funds")) {
+        return {
+            title: 'Insufficient funds',
+            message: "You don't have enough ETH to pay for the gas fee.",
+            action: 'Add more ETH to your wallet to cover the transaction fee.',
+        };
+    }
+    // EstimateGasExecutionError - Gas estimation failed
+    // https://v1.viem.sh/docs/glossary/errors.html#estimategasexecutionerror
+    if (errorName === 'EstimateGasExecutionError' ||
+        errorString.includes('gas estimation failed') ||
+        errorString.includes('cannot estimate gas') ||
+        errorString.includes('gas required exceeds allowance') ||
+        errorString.includes('out of gas')) {
+        // Check for specific reasons
+        if (errorString.includes('insufficient funds')) {
+            return {
+                title: 'Insufficient funds',
+                message: "You don't have enough ETH to pay for this transaction.",
+                action: 'Add more ETH to your wallet.',
+            };
+        }
+        return {
+            title: 'Transaction would fail',
+            message: 'This transaction is likely to fail.',
+            action: 'Please check the recipient address and amount, then try again.',
+        };
+    }
+    // IntrinsicGasTooHighError / IntrinsicGasTooLowError - Gas limit issues
+    // https://v1.viem.sh/docs/glossary/errors.html#intrinsicgastoohigherror
+    if (errorName === 'IntrinsicGasTooHighError' ||
+        errorName === 'IntrinsicGasTooLowError' ||
+        errorString.includes('intrinsic gas too high') ||
+        errorString.includes('intrinsic gas too low') ||
+        errorString.includes('gas limit')) {
+        return {
+            title: 'Gas limit error',
+            message: 'The gas limit for this transaction is incorrect.',
+            action: 'Please try again or contact support.',
+        };
+    }
+    // NonceTooLowError / NonceTooHighError - Nonce issues
+    // https://v1.viem.sh/docs/glossary/errors.html#noncetoolowerror
+    if (errorName === 'NonceTooLowError' || errorString.includes('nonce too low')) {
+        return {
+            title: 'Transaction pending',
+            message: 'A transaction is already pending.',
+            action: 'Please wait for your pending transaction to complete.',
+        };
+    }
+    if (errorName === 'NonceTooHighError' ||
+        errorName === 'NonceMaxValueError' ||
+        errorString.includes('nonce too high')) {
+        return {
+            title: 'Transaction error',
+            message: 'Transaction nonce is invalid.',
+            action: 'Please refresh the page and try again.',
+        };
+    }
+    // FeeCapTooHighError / FeeCapTooLowError / TipAboveFeeCapError
+    // https://v1.viem.sh/docs/glossary/errors.html#feecaptoohigherror
+    if (errorName === 'FeeCapTooLowError' ||
+        errorName === 'TipAboveFeeCapError' ||
+        errorString.includes('transaction underpriced') ||
+        errorString.includes('replacement transaction underpriced') ||
+        errorString.includes('fee cap too low')) {
+        return {
+            title: 'Gas fee too low',
+            message: 'The gas fee is too low for this transaction.',
+            action: 'Try again with a higher gas fee.',
+        };
+    }
+    if (errorName === 'FeeCapTooHighError' || errorString.includes('fee cap too high')) {
+        return {
+            title: 'Gas fee too high',
+            message: 'The gas fee is unusually high.',
+            action: 'Please check the fee and try again.',
+        };
+    }
+    // TransactionTypeNotSupportedError
+    // https://v1.viem.sh/docs/glossary/errors.html#transactiontypenotsupportederror
+    if (errorName === 'TransactionTypeNotSupportedError' || errorString.includes('transaction type not supported')) {
+        return {
+            title: 'Transaction not supported',
+            message: 'This transaction type is not supported on this network.',
+            action: 'Please try a different transaction method.',
+        };
+    }
+    // TransactionExecutionError - General transaction execution failure
+    // https://v1.viem.sh/docs/glossary/errors.html#transactionexecutionerror
+    if (errorName === 'TransactionExecutionError') {
+        return {
+            title: 'Transaction failed',
+            message: 'The transaction failed to execute.',
+            action: 'Please check the transaction details and try again.',
+        };
+    }
+    // WaitForTransactionReceiptTimeoutError
+    // https://v1.viem.sh/docs/glossary/errors.html#waitfortransactionreceipttimeouterror
+    if (errorName === 'WaitForTransactionReceiptTimeoutError' || errorString.includes('timeout')) {
+        return {
+            title: 'Transaction timeout',
+            message: 'The transaction is taking longer than expected.',
+            action: 'It may still be processing. Check your wallet or block explorer.',
+        };
+    }
+    // ExecutionRevertedError - Contract execution reverted
+    // https://v1.viem.sh/docs/glossary/errors.html#executionrevertederror
+    if (errorName === 'ExecutionRevertedError' || errorString.includes('execution reverted')) {
+        return {
+            title: 'Transaction failed',
+            message: 'The transaction was rejected by the contract.',
+            action: 'Please check the transaction details and try again.',
+        };
+    }
+    // ContractFunctionExecutionError / ContractFunctionRevertedError / CallExecutionError
+    // https://v1.viem.sh/docs/glossary/errors.html#contractfunctionexecutionerror
+    if (errorName === 'ContractFunctionExecutionError' ||
+        errorName === 'ContractFunctionRevertedError' ||
+        errorName === 'CallExecutionError' ||
+        errorName === 'RawContractError') {
+        return {
+            title: 'Contract error',
+            message: 'The contract rejected this transaction.',
+            action: 'Please verify the transaction parameters and try again.',
+        };
+    }
+    // ContractFunctionZeroDataError - No data returned when expected
+    // https://v1.viem.sh/docs/glossary/errors.html#contractfunctionzerodataerror
+    if (errorName === 'ContractFunctionZeroDataError') {
+        return {
+            title: 'Contract error',
+            message: 'The contract returned no data.',
+            action: 'This contract may not exist on this network.',
+        };
+    }
+    // ABI-related errors
+    // https://v1.viem.sh/docs/glossary/errors.html#abi
+    if (errorName.includes('Abi') || errorString.includes('abi encoding') || errorString.includes('abi decoding')) {
+        return {
+            title: 'Contract error',
+            message: 'Unable to encode or decode the contract data.',
+            action: 'Please contact support if this issue persists.',
+        };
+    }
+    // ChainMismatchError / ChainNotFoundError / InvalidChainIdError
+    // https://v1.viem.sh/docs/glossary/errors.html#chainmismatcherror
+    if (errorName === 'ChainMismatchError' ||
+        errorName === 'ChainNotFoundError' ||
+        errorName === 'InvalidChainIdError' ||
+        (errorString.includes('chain') && (errorString.includes('mismatch') || errorString.includes('wrong')))) {
+        return {
+            title: 'Wrong network',
+            message: 'Your wallet is connected to a different network.',
+            action: 'Please switch to the correct network in your wallet.',
+        };
+    }
+    // SwitchChainError
+    // https://v1.viem.sh/docs/glossary/errors.html#switchchainerror
+    if (errorName === 'SwitchChainError' || errorString.includes('switch chain')) {
+        return {
+            title: 'Network switch failed',
+            message: 'Unable to switch to the requested network.',
+            action: 'Please manually switch networks in your wallet.',
+        };
+    }
+    // ChainDisconnectedError / ProviderDisconnectedError
+    // https://v1.viem.sh/docs/glossary/errors.html#chaindisconnectederror
+    if (errorName === 'ChainDisconnectedError' ||
+        errorName === 'ProviderDisconnectedError' ||
+        errorString.includes('disconnected')) {
+        return {
+            title: 'Connection lost',
+            message: 'Lost connection to the network.',
+            action: 'Please check your internet connection and try again.',
+        };
+    }
+    // HttpRequestError / WebSocketRequestError / RpcRequestError / TimeoutError
+    // https://v1.viem.sh/docs/glossary/errors.html#httprequesterror
+    if (errorName === 'HttpRequestError' ||
+        errorName === 'WebSocketRequestError' ||
+        errorName === 'RpcRequestError' ||
+        errorName === 'TimeoutError' ||
+        errorString.includes('network') ||
+        errorString.includes('timed out') ||
+        errorString.includes('connection') ||
+        errorString.includes('failed to fetch') ||
+        errorString.includes('request failed') ||
+        errorString.includes('could not detect network') ||
+        errorString.includes('bad gateway') ||
+        errorString.includes('service unavailable')) {
+        return {
+            title: 'Network error',
+            message: 'Unable to connect to the network.',
+            action: 'Check your internet connection and try again.',
+        };
+    }
+    // InternalRpcError / UnknownRpcError
+    // https://v1.viem.sh/docs/glossary/errors.html#internalrpcerror
+    if (errorName === 'InternalRpcError' ||
+        errorName === 'UnknownRpcError' ||
+        errorString.includes('internal json-rpc error') ||
+        errorString.includes('internal error')) {
+        return {
+            title: 'Network error',
+            message: 'The network encountered an internal error.',
+            action: 'Please try again in a moment.',
+        };
+    }
+    // MethodNotFoundRpcError / MethodNotSupportedRpcError
+    // https://v1.viem.sh/docs/glossary/errors.html#methodnotfoundrpcerror
+    if (errorName === 'MethodNotFoundRpcError' ||
+        errorName === 'MethodNotSupportedRpcError' ||
+        errorName === 'UnsupportedProviderMethodError' ||
+        (errorString.includes('method') && (errorString.includes('not found') || errorString.includes('not supported')))) {
+        return {
+            title: 'Method not supported',
+            message: 'This operation is not supported by the current network.',
+            action: 'Try switching to a different RPC provider.',
+        };
+    }
+    // InvalidInputRpcError / InvalidParamsRpcError / InvalidRequestRpcError
+    // https://v1.viem.sh/docs/glossary/errors.html#invalidinputrpcerror
+    if (errorName === 'InvalidInputRpcError' ||
+        errorName === 'InvalidParamsRpcError' ||
+        errorName === 'InvalidRequestRpcError') {
+        return {
+            title: 'Invalid request',
+            message: 'The request contains invalid parameters.',
+            action: 'Please check the transaction details and try again.',
+        };
+    }
+    // TransactionRejectedRpcError
+    // https://v1.viem.sh/docs/glossary/errors.html#transactionrejectedrpcerror
+    if (errorName === 'TransactionRejectedRpcError' || errorString.includes('transaction rejected')) {
+        return {
+            title: 'Transaction rejected',
+            message: 'The network rejected this transaction.',
+            action: 'Please check the transaction details and try again.',
+        };
+    }
+    // LimitExceededRpcError / ResourceNotFoundRpcError / ResourceUnavailableRpcError
+    // https://v1.viem.sh/docs/glossary/errors.html#limitexceededrpcerror
+    if (errorName === 'LimitExceededRpcError' ||
+        errorName === 'ResourceNotFoundRpcError' ||
+        errorName === 'ResourceUnavailableRpcError') {
+        return {
+            title: 'Network busy',
+            message: 'The network is currently busy or unavailable.',
+            action: 'Please wait a moment and try again.',
+        };
+    }
+    // UnauthorizedProviderError
+    // https://v1.viem.sh/docs/glossary/errors.html#unauthorizedprovidererror
+    if (errorName === 'UnauthorizedProviderError' || errorString.includes('unauthorized')) {
+        return {
+            title: 'Unauthorized',
+            message: 'This action requires authorization.',
+            action: 'Please connect your wallet and try again.',
+        };
+    }
+    // Wallet/Provider not found
+    if (errorString.includes('wallet') && (errorString.includes('not connected') || errorString.includes('not found'))) {
+        return {
+            title: 'Wallet not connected',
+            message: 'Your wallet is not connected.',
+            action: 'Please connect your wallet and try again.',
+        };
+    }
+    if (errorString.includes('provider') && errorString.includes('not found')) {
+        return {
+            title: 'Wallet not found',
+            message: 'No wallet extension detected.',
+            action: 'Please install a wallet extension and try again.',
+        };
+    }
+    // Generic fallback (never expose raw error messages to users)
+    return {
+        title: 'Transaction failed',
+        message: 'An error occurred while processing your transaction.',
+        action: 'Please try again.',
+    };
+}
+
+export { parseTransactionError };
+//# sourceMappingURL=errorHandling.js.map

package/build/utils/errorHandling.js.map

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

package/build/utils/format.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Format Utilities
+ *
+ * Address formatting utilities for different chain types.
+ */
+import { ChainTypeEnum } from '@openfort/openfort-js';
+/**
+ * Truncate EVM address with configurable separator (regex-based for 0x format).
+ */
+export declare function truncateEthAddress(address?: string, separator?: string): string;
+/**
+ * Truncate Solana address with configurable separator.
+ */
+export declare function truncateSolanaAddress(address?: string, separator?: string): string;
+/**
+ * Format address based on chain type
+ */
+export declare function formatAddress(address: string, chainType: ChainTypeEnum): string;

package/build/utils/format.js

@@ -0,0 +1,59 @@
+import { ChainTypeEnum } from '@openfort/openfort-js';
+
+/**
+ * Format Utilities
+ *
+ * Address formatting utilities for different chain types.
+ */
+const EVM_TRUNCATE_REGEX = /^(0x[a-zA-Z0-9]{4})[a-zA-Z0-9]+([a-zA-Z0-9]{4})$/;
+/**
+ * Format EVM address: 0x1234...abcd
+ */
+function formatEVMAddress(address) {
+    if (!address || address.length < 10)
+        return address;
+    return `${address.slice(0, 6)}...${address.slice(-4)}`;
+}
+/**
+ * Format Solana address: ABC1...XYZ9
+ */
+function formatSolanaAddress(address) {
+    if (!address || address.length < 8)
+        return address;
+    return `${address.slice(0, 4)}...${address.slice(-4)}`;
+}
+/**
+ * Truncate EVM address with configurable separator (regex-based for 0x format).
+ */
+function truncateEthAddress(address, separator = '••••') {
+    if (!address)
+        return '';
+    const match = address.match(EVM_TRUNCATE_REGEX);
+    if (!match)
+        return address;
+    return `${match[1]}${separator}${match[2]}`;
+}
+/**
+ * Truncate Solana address with configurable separator.
+ */
+function truncateSolanaAddress(address, separator = '••••') {
+    if (!address)
+        return '';
+    if (address.length <= 14)
+        return address;
+    return `${address.slice(0, 6)}${separator}${address.slice(-4)}`;
+}
+const addressFormatters = {
+    [ChainTypeEnum.EVM]: formatEVMAddress,
+    [ChainTypeEnum.SVM]: formatSolanaAddress,
+};
+/**
+ * Format address based on chain type
+ */
+function formatAddress(address, chainType) {
+    const formatter = addressFormatters[chainType];
+    return formatter(address);
+}
+
+export { formatAddress, truncateEthAddress, truncateSolanaAddress };
+//# sourceMappingURL=format.js.map

package/build/utils/format.js.map

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

package/build/utils/index.d.ts

@@ -1,5 +1,5 @@
 import React from 'react';
-declare const truncateEthAddress: (address?: string, separator?: string) => string;
+import { truncateEthAddress, truncateSolanaAddress } from './format';
 declare const nFormatter: (num: number, digits?: number) => string;
 declare const detectBrowser: () => "" | import("detect-browser").Browser | "bot" | "node" | "react-native";
 declare const isAndroid: () => boolean;
@@ -8,6 +8,5 @@ type ReactChildArray = ReturnType<typeof React.Children.toArray>;
 declare function flattenChildren(children: React.ReactNode): ReactChildArray;
 export declare const isWalletConnectConnector: (connectorId?: string) => connectorId is "walletConnect";
 export declare const isCoinbaseWalletConnector: (connectorId?: string) => connectorId is "coinbaseWalletSDK";
-export declare const isSafeConnector: (connectorId?: string) => connectorId is "safe";
 export declare const isInjectedConnector: (connectorId?: string) => connectorId is "injected";
-export { nFormatter, truncateEthAddress, isMobile, isAndroid, detectBrowser, flattenChildren };
+export { nFormatter, truncateEthAddress, truncateSolanaAddress, isMobile, isAndroid, detectBrowser, flattenChildren };

package/build/utils/index.js

@@ -0,0 +1,67 @@
+import { detect } from 'detect-browser';
+import React from 'react';
+import { formatWithDynamicDecimals } from '../components/Pages/Buy/utils.js';
+export { truncateEthAddress, truncateSolanaAddress } from './format.js';
+
+const nFormatter = (num, digits = 2) => {
+    // Handle zero case
+    if (num === 0)
+        return '0.00';
+    // Handle very small amounts
+    if (num > 0 && num < 0.000001)
+        return '<0.000001';
+    if (num < 10000)
+        return formatWithDynamicDecimals(num);
+    const lookup = [
+        { value: 1, symbol: '' },
+        { value: 1e3, symbol: 'k' },
+        { value: 1e6, symbol: 'm' },
+        { value: 1e9, symbol: 'b' },
+        { value: 1e12, symbol: 't' },
+        { value: 1e15, symbol: 'p' },
+        { value: 1e18, symbol: 'e' },
+    ];
+    const rx = /\.0+$|(\.[0-9]*[1-9])0+$/;
+    var item = lookup
+        .slice()
+        .reverse()
+        .find((item) => num >= item.value);
+    return item ? (num / item.value).toFixed(digits).replace(rx, '$1') + item.symbol : '0';
+};
+const detectBrowser = () => {
+    var _a;
+    const browser = detect();
+    return (_a = browser === null || browser === void 0 ? void 0 : browser.name) !== null && _a !== void 0 ? _a : '';
+};
+const detectOS = () => {
+    var _a;
+    const browser = detect();
+    return (_a = browser === null || browser === void 0 ? void 0 : browser.os) !== null && _a !== void 0 ? _a : '';
+};
+const isIOS = () => {
+    const os = detectOS();
+    return os.toLowerCase().includes('ios');
+};
+const isAndroid = () => {
+    const os = detectOS();
+    return os.toLowerCase().includes('android');
+};
+const isMobile = () => {
+    return isAndroid() || isIOS();
+};
+function flattenChildren(children) {
+    const childrenArray = React.Children.toArray(children);
+    return childrenArray.reduce((flatChildren, child) => {
+        if (child.type === React.Fragment) {
+            return flatChildren.concat(flattenChildren(child.props.children));
+        }
+        flatChildren.push(child);
+        return flatChildren;
+    }, []);
+}
+const isWalletConnectConnector = (connectorId) => connectorId === 'walletConnect';
+const isCoinbaseWalletConnector = (connectorId) => connectorId === 'coinbaseWalletSDK';
+const isInjectedConnector = (connectorId) => connectorId === 'injected';
+
+export { detectBrowser, flattenChildren, isAndroid, isCoinbaseWalletConnector, isInjectedConnector, isMobile, isWalletConnectConnector, nFormatter };
+//# sourceMappingURL=index.js.map

package/build/utils/index.js.map

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

package/build/utils/logger.js

@@ -0,0 +1,13 @@
+const PREFIX = '[Openfort-React]';
+const logger = {
+    enabled: false,
+    // biome-ignore lint/suspicious/noConsole: allowed for debugging
+    log: (...args) => (logger.enabled ? console.log(PREFIX, ...args) : null),
+    // biome-ignore lint/suspicious/noConsole: allowed for debugging
+    error: (...args) => (logger.enabled ? console.error(PREFIX, ...args) : null),
+    // biome-ignore lint/suspicious/noConsole: allowed for debugging
+    warn: (...args) => (logger.enabled ? console.warn(PREFIX, ...args) : null),
+};
+
+export { logger };
+//# sourceMappingURL=logger.js.map

package/build/utils/logger.js.map

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

package/build/utils/oauthErrorHandler.d.ts

@@ -1,4 +1,4 @@
 /**
  * Utility to handle and provide better error messages for OAuth configuration errors
  */
-export declare function handleOAuthConfigError(error: any): void;
+export declare function handleOAuthConfigError(error: unknown): void;