shogun-button-react 3.0.17 → 3.0.19

package/dist/components/RainbowKitShogunButton.d.ts

@@ -0,0 +1,41 @@
+import React from 'react';
+interface RainbowKitShogunButtonProps {
+    /**
+     * Testo del pulsante quando non connesso
+     */
+    connectText?: string;
+    /**
+     * Testo del pulsante quando connesso ma non autenticato
+     */
+    loginText?: string;
+    /**
+     * Testo del pulsante quando connesso e autenticato
+     */
+    connectedText?: string;
+    /**
+     * Modalità: 'login' per login, 'signup' per registrazione, 'auto' per automatico
+     */
+    mode?: 'login' | 'signup' | 'auto';
+    /**
+     * Callback chiamato quando l'autenticazione ha successo
+     */
+    onSuccess?: (data: any) => void;
+    /**
+     * Callback chiamato quando si verifica un errore
+     */
+    onError?: (error: string) => void;
+    /**
+     * Stile personalizzato per il pulsante
+     */
+    className?: string;
+    /**
+     * Se true, mostra l'indirizzo del wallet quando connesso
+     */
+    showAddress?: boolean;
+}
+/**
+ * Componente che integra RainbowKit con Shogun
+ * Gestisce automaticamente la connessione wallet e l'autenticazione
+ */
+export declare const RainbowKitShogunButton: React.FC<RainbowKitShogunButtonProps>;
+export {};

package/dist/components/RainbowKitShogunButton.js

@@ -0,0 +1,122 @@
+import React, { useState, useEffect } from 'react';
+import { useRainbowKitShogun } from '../hooks/useRainbowKitShogun';
+/**
+ * Componente che integra RainbowKit con Shogun
+ * Gestisce automaticamente la connessione wallet e l'autenticazione
+ */
+export const RainbowKitShogunButton = ({ connectText = "Connect Wallet", loginText = "Login with Wallet", connectedText = "Connected", mode = 'auto', onSuccess, onError, className = "shogun-connect-button", showAddress = true, }) => {
+    const { address, isConnected, isLoggedIn, connectAndLogin, connectAndSignUp, isReady, } = useRainbowKitShogun();
+    const [isLoading, setIsLoading] = useState(false);
+    const [error, setError] = useState(null);
+    // Gestisce automaticamente l'autenticazione quando l'indirizzo cambia
+    useEffect(() => {
+        if (isConnected && address && !isLoggedIn && mode === 'auto') {
+            handleAutoAuth();
+        }
+    }, [isConnected, address, isLoggedIn, mode]);
+    const handleAutoAuth = async () => {
+        var _a;
+        if (!address)
+            return;
+        setIsLoading(true);
+        setError(null);
+        try {
+            // Prova prima il login, se fallisce prova la registrazione
+            let result = await connectAndLogin();
+            if (!result.success && ((_a = result.error) === null || _a === void 0 ? void 0 : _a.includes('not found'))) {
+                // Se l'utente non esiste, prova la registrazione
+                result = await connectAndSignUp();
+            }
+            if (result.success) {
+                onSuccess === null || onSuccess === void 0 ? void 0 : onSuccess(result);
+            }
+            else if (result.error) {
+                setError(result.error);
+                onError === null || onError === void 0 ? void 0 : onError(result.error);
+            }
+        }
+        catch (err) {
+            const errorMsg = err.message || "Authentication failed";
+            setError(errorMsg);
+            onError === null || onError === void 0 ? void 0 : onError(errorMsg);
+        }
+        finally {
+            setIsLoading(false);
+        }
+    };
+    const handleClick = async () => {
+        var _a;
+        if (!isReady) {
+            setError("RainbowKit or Shogun not ready");
+            return;
+        }
+        if (!isConnected) {
+            // Apri il modal di connessione RainbowKit
+            connectAndLogin();
+            return;
+        }
+        if (isLoggedIn) {
+            // Già autenticato, non fare nulla
+            return;
+        }
+        // Connesso ma non autenticato, procedi con l'autenticazione
+        setIsLoading(true);
+        setError(null);
+        try {
+            let result;
+            if (mode === 'login') {
+                result = await connectAndLogin();
+            }
+            else if (mode === 'signup') {
+                result = await connectAndSignUp();
+            }
+            else {
+                // Modalità auto: prova login, se fallisce prova signup
+                result = await connectAndLogin();
+                if (!result.success && ((_a = result.error) === null || _a === void 0 ? void 0 : _a.includes('not found'))) {
+                    result = await connectAndSignUp();
+                }
+            }
+            if (result.success) {
+                onSuccess === null || onSuccess === void 0 ? void 0 : onSuccess(result);
+            }
+            else if (result.error) {
+                setError(result.error);
+                onError === null || onError === void 0 ? void 0 : onError(result.error);
+            }
+        }
+        catch (err) {
+            const errorMsg = err.message || "Authentication failed";
+            setError(errorMsg);
+            onError === null || onError === void 0 ? void 0 : onError(errorMsg);
+        }
+        finally {
+            setIsLoading(false);
+        }
+    };
+    const getButtonText = () => {
+        if (isLoading)
+            return "Connecting...";
+        if (isLoggedIn)
+            return showAddress && address ? `${connectedText} (${address.slice(0, 6)}...${address.slice(-4)})` : connectedText;
+        if (isConnected)
+            return loginText;
+        return connectText;
+    };
+    const getButtonClass = () => {
+        let baseClass = className;
+        if (isLoggedIn)
+            baseClass += " shogun-connected";
+        if (isLoading)
+            baseClass += " shogun-loading";
+        if (error)
+            baseClass += " shogun-error";
+        return baseClass;
+    };
+    if (!isReady) {
+        return (React.createElement("button", { className: className, disabled: true }, "RainbowKit not available"));
+    }
+    return (React.createElement("div", { className: "rainbowkit-shogun-container" },
+        React.createElement("button", { className: getButtonClass(), onClick: handleClick, disabled: isLoading }, getButtonText()),
+        error && (React.createElement("div", { className: "shogun-error-message", style: { marginTop: '8px' } }, error))));
+};

package/dist/components/ShogunButtonWithRainbowKit.d.ts

@@ -0,0 +1,16 @@
+import React from 'react';
+import { ShogunConnectorOptions } from '../interfaces/connector-options';
+interface ShogunButtonWithRainbowKitProps {
+    core: any;
+    options: ShogunConnectorOptions;
+    onLoginSuccess?: (data: any) => void;
+    onSignupSuccess?: (data: any) => void;
+    onError?: (error: string) => void;
+}
+/**
+ * Componente wrapper che integra RainbowKit con ShogunButton
+ * Quando RainbowKit è disponibile, il pulsante MetaMask utilizzerà RainbowKit
+ * invece della connessione diretta a MetaMask
+ */
+export declare const ShogunButtonWithRainbowKit: React.FC<ShogunButtonWithRainbowKitProps>;
+export {};

package/dist/components/ShogunButtonWithRainbowKit.js

@@ -0,0 +1,24 @@
+import React from 'react';
+import { ShogunButton, ShogunButtonProvider } from './ShogunButton';
+import { useRainbowKitShogun } from '../hooks/useRainbowKitShogun';
+/**
+ * Componente wrapper che integra RainbowKit con ShogunButton
+ * Quando RainbowKit è disponibile, il pulsante MetaMask utilizzerà RainbowKit
+ * invece della connessione diretta a MetaMask
+ */
+export const ShogunButtonWithRainbowKit = ({ core, options, onLoginSuccess, onSignupSuccess, onError, }) => {
+    const rainbowKit = useRainbowKitShogun();
+    // Merge RainbowKit integration with options
+    const enhancedOptions = {
+        ...options,
+        rainbowKitIntegration: rainbowKit.isReady ? {
+            openConnectModal: rainbowKit.openConnectModal,
+            openAccountModal: rainbowKit.openAccountModal,
+            openChainModal: rainbowKit.openChainModal,
+            isConnected: rainbowKit.isConnected,
+            address: rainbowKit.address,
+        } : undefined,
+    };
+    return (React.createElement(ShogunButtonProvider, { core: core, options: enhancedOptions, onLoginSuccess: onLoginSuccess, onSignupSuccess: onSignupSuccess, onError: onError },
+        React.createElement(ShogunButton, null)));
+};

package/dist/hooks/useRainbowKitShogun.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Hook personalizzato per integrare RainbowKit con Shogun
+ * Questo hook gestisce la connessione wallet tramite RainbowKit
+ * e l'autenticazione tramite Shogun utilizzando il ShogunButton esistente
+ */
+export declare const useRainbowKitShogun: () => {
+    address: any;
+    isConnected: any;
+    openConnectModal: any;
+    openAccountModal: any;
+    openChainModal: any;
+    isLoggedIn: boolean;
+    connectAndLogin: () => Promise<any>;
+    connectAndSignUp: () => Promise<any>;
+    loginWithAddress: (walletAddress: string) => Promise<any>;
+    signUpWithAddress: (walletAddress: string) => Promise<any>;
+    isReady: boolean;
+};

package/dist/hooks/useRainbowKitShogun.js

@@ -0,0 +1,120 @@
+import { useConnectModal, useAccountModal, useChainModal } from '@rainbow-me/rainbowkit';
+import { useAccount } from 'wagmi';
+import { useShogun } from '../components/ShogunButton';
+/**
+ * Hook personalizzato per integrare RainbowKit con Shogun
+ * Questo hook gestisce la connessione wallet tramite RainbowKit
+ * e l'autenticazione tramite Shogun utilizzando il ShogunButton esistente
+ */
+export const useRainbowKitShogun = () => {
+    const { openConnectModal } = useConnectModal();
+    const { openAccountModal } = useAccountModal();
+    const { openChainModal } = useChainModal();
+    const { address, isConnected } = useAccount();
+    const { login, signUp, core, isLoggedIn } = useShogun();
+    /**
+     * Connette il wallet tramite RainbowKit e autentica con Shogun
+     */
+    const connectAndLogin = async () => {
+        try {
+            // Se non c'è connessione, apri il modal di RainbowKit
+            if (!isConnected) {
+                openConnectModal === null || openConnectModal === void 0 ? void 0 : openConnectModal();
+                return { success: false, needsConnection: true };
+            }
+            // Se c'è già una connessione, procedi con l'autenticazione Shogun
+            if (address) {
+                const result = await login("web3", address);
+                return result;
+            }
+            throw new Error("No address available");
+        }
+        catch (error) {
+            console.error("RainbowKit Shogun connection failed:", error);
+            return {
+                success: false,
+                error: error.message || "Connection failed"
+            };
+        }
+    };
+    /**
+     * Registra un nuovo utente tramite RainbowKit e Shogun
+     */
+    const connectAndSignUp = async () => {
+        try {
+            // Se non c'è connessione, apri il modal di RainbowKit
+            if (!isConnected) {
+                openConnectModal === null || openConnectModal === void 0 ? void 0 : openConnectModal();
+                return { success: false, needsConnection: true };
+            }
+            // Se c'è già una connessione, procedi con la registrazione Shogun
+            if (address) {
+                const result = await signUp("web3", address);
+                return result;
+            }
+            throw new Error("No address available");
+        }
+        catch (error) {
+            console.error("RainbowKit Shogun signup failed:", error);
+            return {
+                success: false,
+                error: error.message || "Signup failed"
+            };
+        }
+    };
+    /**
+     * Autentica direttamente con un indirizzo (utile quando l'indirizzo è già noto)
+     */
+    const loginWithAddress = async (walletAddress) => {
+        try {
+            if (!walletAddress) {
+                throw new Error("Address is required");
+            }
+            const result = await login("web3", walletAddress);
+            return result;
+        }
+        catch (error) {
+            console.error("Login with address failed:", error);
+            return {
+                success: false,
+                error: error.message || "Login failed"
+            };
+        }
+    };
+    /**
+     * Registra direttamente con un indirizzo (utile quando l'indirizzo è già noto)
+     */
+    const signUpWithAddress = async (walletAddress) => {
+        try {
+            if (!walletAddress) {
+                throw new Error("Address is required");
+            }
+            const result = await signUp("web3", walletAddress);
+            return result;
+        }
+        catch (error) {
+            console.error("Signup with address failed:", error);
+            return {
+                success: false,
+                error: error.message || "Signup failed"
+            };
+        }
+    };
+    return {
+        // RainbowKit state
+        address,
+        isConnected,
+        openConnectModal,
+        openAccountModal,
+        openChainModal,
+        // Shogun state
+        isLoggedIn,
+        // Actions
+        connectAndLogin,
+        connectAndSignUp,
+        loginWithAddress,
+        signUpWithAddress,
+        // Utilities
+        isReady: !!core && !!openConnectModal,
+    };
+};

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "shogun-button-react",
   "description": "Shogun connector button",
-  "version": "3.0.17",
+  "version": "3.0.19",
   "files": [
     "dist",
     "src/styles/index.css"
@@ -34,7 +34,7 @@
     "ethers": "^6.13.5",
     "prettier": "^3.5.3",
     "rxjs": "^7.8.1",
-    "shogun-core": "^3.0.18"
+    "shogun-core": "^3.0.19"
   },
   "peerDependencies": {
     "react": "^18.0.0",