@fernolab/wallet-adapter-svelte 0.1.0

package/dist/wallet/wallet.svelte.js

@@ -0,0 +1,672 @@
+import { getWallets } from '@wallet-standard/app';
+import { PUBLIC_SOLANA_RPC_ENDPOINT } from '../config.js';
+import { browser } from '../environment.js';
+import { MOBILE_DEEPLINK_WALLETS, MOBILE_WALLETS, SolanaSignMessage, StandardConnect, StandardDisconnect, StandardEvents, adaptStandardWallets, adaptWallet, createWalletController, createMobileWalletBrowseUrl, dedupeStandardWallets, detectInjectedWallets, detectMobileRuntime, isSolanaWallet, resolveSolanaChainFromEndpoint } from '@fernolab/wallet-adapter-core';
+export { adaptWallet, dedupeStandardWallets, isSolanaWallet };
+// ============================================================================
+// Constants
+// ============================================================================
+const LAST_WALLET_KEY = 'lastConnectedWallet';
+const SolanaMobileWalletAdapterWalletName = 'Mobile Wallet Adapter';
+const MOBILE_WALLET_ADAPTER_DISPLAY_NAME = 'Use Installed Wallet';
+const INJECTED_WALLET_ICON = 'data:image/svg+xml,%3Csvg%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%20width%3D%2248%22%20height%3D%2248%22%20viewBox%3D%220%200%2048%2048%22%20fill%3D%22none%22%3E%3Crect%20width%3D%2248%22%20height%3D%2248%22%20rx%3D%2210%22%20fill%3D%22%23111827%22%2F%3E%3Cpath%20d%3D%22M14%2018h20M14%2024h20M14%2030h20%22%20stroke%3D%22white%22%20stroke-width%3D%222.5%22%20stroke-linecap%3D%22round%22%2F%3E%3C%2Fsvg%3E';
+export const RUNTIME_DEBUG_MODES = [
+    'auto',
+    'desktop',
+    'ios',
+    'android',
+    'phantom',
+    'solflare',
+    'jupiter',
+    'backpack'
+];
+const RUNTIME_DEBUG_QUERY_KEYS = ['wallet_mobile', 'wallet_runtime'];
+const MOBILE_WALLET_NAMES = [
+    SolanaMobileWalletAdapterWalletName,
+    'Phantom',
+    'Solflare',
+    'Jupiter Mobile',
+    'Jupiter',
+    'Jupiter Wallet',
+    'Backpack'
+];
+const PREFERRED_WALLET_ORDER = [...MOBILE_WALLET_NAMES];
+const DESKTOP_RUNTIME = {
+    isMobile: false,
+    isWalletBrowser: false,
+    platform: 'desktop',
+    supportsMobileWalletAdapter: false,
+    walletBrowser: null
+};
+// ============================================================================
+// Wallet Detection & Adaptation
+// ============================================================================
+function getRuntimeDebugWalletId(mode) {
+    switch (mode) {
+        case 'phantom':
+        case 'solflare':
+        case 'jupiter':
+        case 'backpack':
+            return mode;
+        default:
+            return null;
+    }
+}
+function normalizeRuntimeDebugMode(value) {
+    const normalized = value?.trim().toLowerCase();
+    if (normalized === 'mobile') {
+        return 'android';
+    }
+    return RUNTIME_DEBUG_MODES.includes(normalized)
+        ? normalized
+        : 'auto';
+}
+function readRuntimeDebugMode() {
+    if (!browser || typeof location === 'undefined') {
+        return 'auto';
+    }
+    const url = new URL(location.href);
+    const hashParams = url.hash.includes('=')
+        ? new URLSearchParams(url.hash.replace(/^#/, ''))
+        : new URLSearchParams();
+    for (const key of RUNTIME_DEBUG_QUERY_KEYS) {
+        const mode = normalizeRuntimeDebugMode(url.searchParams.get(key) ?? hashParams.get(key));
+        if (mode !== 'auto') {
+            return mode;
+        }
+    }
+    return 'auto';
+}
+function writeRuntimeDebugMode(mode) {
+    if (!browser || typeof history === 'undefined' || typeof location === 'undefined') {
+        return;
+    }
+    const url = new URL(location.href);
+    for (const key of RUNTIME_DEBUG_QUERY_KEYS) {
+        url.searchParams.delete(key);
+    }
+    if (mode !== 'auto') {
+        url.searchParams.set(RUNTIME_DEBUG_QUERY_KEYS[0], mode);
+    }
+    history.replaceState(history.state, '', url);
+}
+function bytesFromString(input, length) {
+    const bytes = new Uint8Array(length);
+    let hash = 0x811c9dc5;
+    for (let index = 0; index < length; index += 1) {
+        for (let charIndex = 0; charIndex < input.length; charIndex += 1) {
+            hash ^= input.charCodeAt(charIndex) + index;
+            hash = Math.imul(hash, 0x01000193);
+        }
+        hash ^= hash >>> 13;
+        hash = Math.imul(hash, 0x85ebca6b);
+        bytes[index] = hash & 0xff;
+    }
+    return bytes;
+}
+function createDebugInjectedWallet(id) {
+    const wallet = MOBILE_WALLETS.find((candidate) => candidate.id === id);
+    const signature = bytesFromString(`wallet-debug:${id}:signature`, 64);
+    const publicKey = '11111111111111111111111111111111';
+    const publicKeyBytes = new Uint8Array(32);
+    const provider = {
+        connect: async () => ({ publicKey: { toBytes: () => publicKeyBytes, toString: () => publicKey } }),
+        disconnect: async () => undefined,
+        isBackpack: id === 'backpack',
+        isJupiter: id === 'jupiter',
+        isPhantom: id === 'phantom',
+        isSolflare: id === 'solflare',
+        signMessage: async () => signature
+    };
+    return {
+        id,
+        name: wallet?.name ?? id,
+        provider
+    };
+}
+function normalizeInjectedSignature(result) {
+    if (result instanceof Uint8Array) {
+        return result;
+    }
+    if (!result.signature) {
+        throw new Error('Injected wallet did not return a signature');
+    }
+    return result.signature instanceof Uint8Array ? result.signature : new Uint8Array(result.signature);
+}
+function getInjectedPublicKeyBytes(publicKey) {
+    const bytes = publicKey?.toBytes?.() ?? publicKey?.toBuffer?.();
+    return bytes ? new Uint8Array(bytes) : new Uint8Array(32);
+}
+function createInjectedAccount(address, chain, provider, publicKey) {
+    return {
+        address,
+        publicKey: getInjectedPublicKeyBytes(publicKey),
+        chains: [chain],
+        features: provider.signMessage ? [SolanaSignMessage] : []
+    };
+}
+function createInjectedStandardWallet(detectedWallet, chain) {
+    const { name, provider } = detectedWallet;
+    let accounts = [];
+    const listeners = new Set();
+    function emitChange() {
+        const payload = { accounts };
+        listeners.forEach((listener) => listener(payload));
+    }
+    const wallet = {
+        version: '1.0.0',
+        name,
+        icon: INJECTED_WALLET_ICON,
+        chains: [chain],
+        get accounts() {
+            return accounts;
+        },
+        features: {
+            [StandardConnect]: {
+                version: '1.0.0',
+                connect: async () => {
+                    if (!provider.connect) {
+                        throw new Error(`${name} does not expose a connect method`);
+                    }
+                    const response = await provider.connect();
+                    const address = response.publicKey?.toString();
+                    if (!address) {
+                        throw new Error(`${name} did not return a public key`);
+                    }
+                    accounts = [createInjectedAccount(address, chain, provider, response.publicKey)];
+                    emitChange();
+                    return { accounts };
+                }
+            },
+            [StandardDisconnect]: {
+                version: '1.0.0',
+                disconnect: async () => {
+                    await provider.disconnect?.();
+                    accounts = [];
+                    emitChange();
+                }
+            },
+            [StandardEvents]: {
+                version: '1.0.0',
+                on: ((event, listener) => {
+                    if (event === 'change') {
+                        listeners.add(listener);
+                    }
+                    return () => listeners.delete(listener);
+                })
+            },
+            ...(provider.signMessage
+                ? {
+                    [SolanaSignMessage]: {
+                        version: '1.1.0',
+                        signMessage: async (...inputs) => await Promise.all(inputs.map(async ({ account, message }) => {
+                            const currentAccount = accounts[0];
+                            if (!currentAccount || account.address !== currentAccount.address) {
+                                throw new Error(`${name} account mismatch`);
+                            }
+                            if (!provider.signMessage) {
+                                throw new Error(`${name} does not support message signing`);
+                            }
+                            return {
+                                signature: normalizeInjectedSignature(await provider.signMessage(message, 'utf8')),
+                                signedMessage: message,
+                                signatureType: 'ed25519'
+                            };
+                        }))
+                    }
+                }
+                : {})
+        }
+    };
+    return {
+        name,
+        icon: wallet.icon ?? INJECTED_WALLET_ICON,
+        wallet
+    };
+}
+function createInjectedStandardWallets(chain, detectedWallets) {
+    if (!browser) {
+        return [];
+    }
+    return detectedWallets.map((wallet) => createInjectedStandardWallet(wallet, chain));
+}
+async function getStandardWallets(chain, detectedInjectedWallets) {
+    const registered = getWallets().get();
+    const adapted = adaptStandardWallets(registered);
+    const injectedWallets = createInjectedStandardWallets(chain, detectedInjectedWallets);
+    const unique = dedupeStandardWallets([...adapted, ...injectedWallets], PREFERRED_WALLET_ORDER);
+    return unique;
+}
+/**
+ * Listen for newly registered wallets
+ */
+function onWalletRegistered(callback) {
+    const wallets = getWallets();
+    return wallets.on('register', (...newWallets) => {
+        for (const wallet of newWallets) {
+            const adapted = adaptWallet(wallet);
+            if (adapted) {
+                callback(adapted);
+            }
+        }
+    });
+}
+// ============================================================================
+// Utility Functions
+// ============================================================================
+/**
+ * Determine Solana chain identifier from RPC endpoint
+ */
+export function resolveChainFromEndpoint(endpoint) {
+    return resolveSolanaChainFromEndpoint(endpoint);
+}
+function getRuntimeForDebugMode(mode) {
+    switch (mode) {
+        case 'desktop':
+            return DESKTOP_RUNTIME;
+        case 'ios':
+            return {
+                isMobile: true,
+                isWalletBrowser: false,
+                platform: 'ios',
+                supportsMobileWalletAdapter: false,
+                walletBrowser: null
+            };
+        case 'android':
+            return {
+                isMobile: true,
+                isWalletBrowser: false,
+                platform: 'android',
+                supportsMobileWalletAdapter: true,
+                walletBrowser: null
+            };
+        case 'phantom':
+        case 'solflare':
+        case 'jupiter':
+        case 'backpack':
+            return {
+                isMobile: true,
+                isWalletBrowser: true,
+                platform: 'ios',
+                supportsMobileWalletAdapter: false,
+                walletBrowser: mode
+            };
+        default:
+            return null;
+    }
+}
+function getCurrentRuntime(mode) {
+    if (!browser || typeof navigator === 'undefined') {
+        return DESKTOP_RUNTIME;
+    }
+    const debugRuntime = getRuntimeForDebugMode(mode);
+    if (debugRuntime) {
+        return debugRuntime;
+    }
+    return detectMobileRuntime({ maxTouchPoints: navigator.maxTouchPoints });
+}
+function createCurrentMobileWalletLinks() {
+    if (!browser || typeof location === 'undefined') {
+        return [];
+    }
+    const targetUrl = location.href;
+    const referrerUrl = location.origin;
+    const jupiterWallet = MOBILE_WALLETS.find((wallet) => wallet.id === 'jupiter');
+    const links = MOBILE_DEEPLINK_WALLETS.map((wallet) => ({
+        name: wallet.name,
+        url: createMobileWalletBrowseUrl(wallet, targetUrl, referrerUrl)
+    }));
+    if (jupiterWallet) {
+        links.push({ name: jupiterWallet.name, url: jupiterWallet.websiteUrl });
+    }
+    return links;
+}
+function getDetectedWalletBrowserName(runtime, injectedWallets) {
+    const userAgentWallet = MOBILE_WALLETS.find((wallet) => wallet.id === runtime.walletBrowser);
+    if (userAgentWallet) {
+        return userAgentWallet.name;
+    }
+    const injectedWallet = injectedWallets[0];
+    if (runtime.isMobile && injectedWallet) {
+        return injectedWallet.name;
+    }
+    return null;
+}
+function getRuntimeLabel(runtime, injectedWallets) {
+    const walletBrowserName = getDetectedWalletBrowserName(runtime, injectedWallets);
+    if (walletBrowserName) {
+        return `${walletBrowserName} browser`;
+    }
+    if (runtime.supportsMobileWalletAdapter) {
+        return 'Android Chrome';
+    }
+    if (runtime.platform === 'ios') {
+        return 'iOS browser';
+    }
+    if (runtime.isMobile) {
+        return 'Mobile browser';
+    }
+    return 'Desktop browser';
+}
+/**
+ * Get typed feature from wallet
+ */
+function getWalletFeature(wallet, featureName) {
+    const features = wallet.features;
+    return features[featureName] ?? null;
+}
+// ============================================================================
+// Wallet Store
+// ============================================================================
+export function createWalletStore() {
+    // State
+    let rpcEndpoint = $state(PUBLIC_SOLANA_RPC_ENDPOINT);
+    let availableWallets = $state([]);
+    let standardWallet = $state(null);
+    let standardAccount = $state(null);
+    let publicKey = $state(null);
+    let connected = $state(false);
+    let connecting = $state(false);
+    let signing = $state(false);
+    let isInitialized = $state(false);
+    let error = $state(null);
+    let useMWA = $state(false);
+    let mobileRuntime = $state(DESKTOP_RUNTIME);
+    let runtimeDebugMode = $state(readRuntimeDebugMode());
+    let injectedWallets = $state([]);
+    let mobileWalletLinks = $state([]);
+    let walletChangeCallbacks = new Set();
+    let walletRegistrationOff = null;
+    const controller = createWalletController();
+    // Derived state
+    const shortAddress = $derived(publicKey ? `${publicKey.slice(0, 4)}...${publicKey.slice(-4)}` : '');
+    const connectionStatus = $derived(connecting ? 'connecting' : connected ? 'connected' : 'disconnected');
+    const detectedWalletBrowserName = $derived(getDetectedWalletBrowserName(mobileRuntime, injectedWallets));
+    const runtimeLabel = $derived(getRuntimeLabel(mobileRuntime, injectedWallets));
+    const mobileWalletAdapterWallet = $derived(availableWallets.find((wallet) => wallet.name === SolanaMobileWalletAdapterWalletName) ?? null);
+    // ============================================================================
+    // Event System
+    // ============================================================================
+    function notifyWalletChange(wallet) {
+        walletChangeCallbacks.forEach((callback) => {
+            try {
+                callback(wallet);
+            }
+            catch {
+            }
+        });
+    }
+    function onWalletChange(callback) {
+        walletChangeCallbacks.add(callback);
+        return () => {
+            walletChangeCallbacks.delete(callback);
+        };
+    }
+    controller.subscribe((state) => {
+        const previousWallet = standardWallet;
+        availableWallets = [...state.availableWallets];
+        standardWallet = state.standardWallet;
+        standardAccount = state.standardAccount;
+        publicKey = state.publicKey;
+        connected = state.connected;
+        connecting = state.connecting;
+        signing = state.signing;
+        error = state.error;
+        if (previousWallet !== state.standardWallet) {
+            if (browser) {
+                if (state.standardWallet) {
+                    localStorage.setItem(LAST_WALLET_KEY, state.standardWallet.name);
+                }
+                else {
+                    localStorage.removeItem(LAST_WALLET_KEY);
+                }
+            }
+            notifyWalletChange(state.standardWallet);
+        }
+    });
+    // ============================================================================
+    // Internal Helper Functions
+    // ============================================================================
+    function setError(err) {
+        error = err;
+    }
+    function getDetectedInjectedWallets() {
+        const debugWalletId = getRuntimeDebugWalletId(runtimeDebugMode);
+        if (debugWalletId) {
+            return [createDebugInjectedWallet(debugWalletId)];
+        }
+        return browser ? detectInjectedWallets() : [];
+    }
+    function refreshRuntimeState() {
+        mobileRuntime = getCurrentRuntime(runtimeDebugMode);
+        injectedWallets = getDetectedInjectedWallets();
+        mobileWalletLinks = createCurrentMobileWalletLinks();
+        useMWA = Boolean(mobileWalletAdapterWallet);
+    }
+    async function refreshAvailableWallets() {
+        if (!browser) {
+            return;
+        }
+        refreshRuntimeState();
+        const chain = resolveChainFromEndpoint(rpcEndpoint);
+        const detectedInjectedWallets = injectedWallets;
+        const wallets = await getStandardWallets(chain, detectedInjectedWallets);
+        controller.setAvailableWallets(wallets);
+        refreshRuntimeState();
+    }
+    function getWalletByNames(names) {
+        return availableWallets.find((wallet) => names.includes(wallet.name)) ?? null;
+    }
+    function getWalletBrowserNames() {
+        const detectedWallet = injectedWallets[0];
+        const walletId = detectedWallet?.id ?? mobileRuntime.walletBrowser;
+        switch (walletId) {
+            case 'phantom':
+                return ['Phantom'];
+            case 'solflare':
+                return ['Solflare'];
+            case 'jupiter':
+                return ['Jupiter Mobile', 'Jupiter', 'Jupiter Wallet'];
+            case 'backpack':
+                return ['Backpack'];
+            default:
+                return [];
+        }
+    }
+    // ============================================================================
+    // Public API
+    // ============================================================================
+    /**
+     * Initialize the wallet store
+     * @param endpoint - Solana RPC endpoint URL
+     */
+    async function initialize(endpoint = PUBLIC_SOLANA_RPC_ENDPOINT) {
+        try {
+            rpcEndpoint = endpoint;
+            if (!browser) {
+                return;
+            }
+            await refreshAvailableWallets();
+            const wallets = availableWallets;
+            // Attempt to restore last connected wallet
+            const lastWallet = localStorage.getItem(LAST_WALLET_KEY);
+            if (lastWallet) {
+                const existing = wallets.find((wallet) => wallet.name === lastWallet);
+                if (existing) {
+                    try {
+                        await connectStandard(existing);
+                    }
+                    catch (err) {
+                        localStorage.removeItem(LAST_WALLET_KEY);
+                        setError(err instanceof Error ? err : new Error(String(err)));
+                    }
+                }
+            }
+            // Listen for newly registered wallets
+            if (!walletRegistrationOff) {
+                walletRegistrationOff = onWalletRegistered((wallet) => {
+                    controller.setAvailableWallets(dedupeStandardWallets([...availableWallets, wallet], PREFERRED_WALLET_ORDER));
+                    refreshRuntimeState();
+                });
+            }
+            isInitialized = true;
+            setError(null);
+        }
+        catch (err) {
+            isInitialized = false;
+            setError(err instanceof Error ? err : new Error('Failed to initialize wallet store'));
+            throw err;
+        }
+    }
+    async function setRuntimeDebugMode(mode) {
+        runtimeDebugMode = normalizeRuntimeDebugMode(mode);
+        writeRuntimeDebugMode(runtimeDebugMode);
+        await refreshAvailableWallets();
+    }
+    /**
+     * Connect to a wallet using the Wallet Standard
+     * @param wallet - The wallet to connect to
+     */
+    async function connectStandard(wallet) {
+        try {
+            await controller.connectStandard(wallet);
+        }
+        catch (err) {
+            const error = err instanceof Error ? err : new Error('Failed to connect wallet');
+            setError(error);
+            throw error;
+        }
+    }
+    async function connectMobileWalletAdapter() {
+        const mobileWallet = getWalletByNames([SolanaMobileWalletAdapterWalletName]);
+        if (!mobileWallet) {
+            throw new Error('Mobile Wallet Adapter is not available in this browser');
+        }
+        await connectStandard(mobileWallet);
+    }
+    async function connectWalletBrowser() {
+        const names = getWalletBrowserNames();
+        const walletBrowserName = detectedWalletBrowserName ?? 'Wallet browser';
+        const wallet = getWalletByNames(names);
+        if (!wallet) {
+            throw new Error(`${walletBrowserName} is not available in this browser`);
+        }
+        await connectStandard(wallet);
+    }
+    /**
+     * Disconnect the currently connected wallet
+     */
+    async function disconnect() {
+        try {
+            await controller.disconnect();
+            setError(null);
+        }
+        catch (err) {
+            const error = err instanceof Error ? err : new Error('Failed to disconnect');
+            setError(error);
+            throw error;
+        }
+    }
+    /**
+     * Sign a message with the connected wallet
+     * @param message - UTF-8 string or raw bytes to sign
+     * @returns Wallet Standard signature result
+     */
+    async function signMessage(message) {
+        try {
+            return await controller.signMessage(message);
+        }
+        catch (err) {
+            const error = err instanceof Error ? err : new Error('Failed to sign message');
+            setError(error);
+            throw error;
+        }
+    }
+    // ============================================================================
+    // Return Public Interface
+    // ============================================================================
+    return {
+        // State getters
+        get rpcEndpoint() {
+            return rpcEndpoint;
+        },
+        get availableWallets() {
+            return availableWallets;
+        },
+        get standardWallet() {
+            return standardWallet;
+        },
+        get standardAccount() {
+            return standardAccount;
+        },
+        get publicKey() {
+            return publicKey;
+        },
+        get connected() {
+            return connected;
+        },
+        get connecting() {
+            return connecting;
+        },
+        get signing() {
+            return signing;
+        },
+        get connectionStatus() {
+            return connectionStatus;
+        },
+        get useMWA() {
+            return useMWA;
+        },
+        get shortAddress() {
+            return shortAddress;
+        },
+        get isInitialized() {
+            return isInitialized;
+        },
+        get error() {
+            return error;
+        },
+        get mobileRuntime() {
+            return mobileRuntime;
+        },
+        get runtimeLabel() {
+            return runtimeLabel;
+        },
+        get runtimeDebugMode() {
+            return runtimeDebugMode;
+        },
+        get runtimeDebugModes() {
+            return RUNTIME_DEBUG_MODES;
+        },
+        get detectedInjectedWallets() {
+            return injectedWallets;
+        },
+        get detectedWalletBrowserName() {
+            return detectedWalletBrowserName;
+        },
+        get mobileWalletLinks() {
+            return mobileWalletLinks;
+        },
+        get mobileWalletAdapterWallet() {
+            return mobileWalletAdapterWallet;
+        },
+        get mobileWalletAdapterName() {
+            return SolanaMobileWalletAdapterWalletName;
+        },
+        get mobileWalletAdapterDisplayName() {
+            return MOBILE_WALLET_ADAPTER_DISPLAY_NAME;
+        },
+        // Methods
+        initialize,
+        refreshAvailableWallets,
+        setRuntimeDebugMode,
+        connectStandard,
+        connectMobileWalletAdapter,
+        connectWalletBrowser,
+        disconnect,
+        signMessage,
+        onWalletChange,
+        clearError: () => setError(null)
+    };
+}
+export const wallet = createWalletStore();