@varity-labs/client-js 2.0.0-alpha.1

package/dist/react/hooks.js

@@ -0,0 +1,398 @@
+"use strict";
+/**
+ * React Hooks for Varity Client
+ *
+ * Provides easy-to-use React hooks for blockchain interactions
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useVarityClient = useVarityClient;
+exports.useVarityWallet = useVarityWallet;
+exports.useVarityBalance = useVarityBalance;
+exports.useVarityContract = useVarityContract;
+exports.useVarityAuth = useVarityAuth;
+exports.useVarityStorage = useVarityStorage;
+exports.useVarityChain = useVarityChain;
+const react_1 = require("react");
+const VarityClient_1 = require("../VarityClient");
+/**
+ * useVarityClient - Create and manage Varity client instance
+ *
+ * @example
+ * ```typescript
+ * function App() {
+ *   const client = useVarityClient({ chain: 'varity-l3' });
+ *
+ *   return <div>Chain: {client.getChainName()}</div>;
+ * }
+ * ```
+ */
+function useVarityClient(config) {
+    const clientRef = (0, react_1.useRef)(null);
+    if (!clientRef.current) {
+        clientRef.current = new VarityClient_1.VarityClient(config);
+    }
+    (0, react_1.useEffect)(() => {
+        return () => {
+            clientRef.current?.dispose();
+        };
+    }, []);
+    return clientRef.current;
+}
+/**
+ * useVarityWallet - Manage wallet connection and state
+ *
+ * @example
+ * ```typescript
+ * function WalletButton() {
+ *   const { connect, disconnect, isConnected, account, balance } = useVarityWallet(client);
+ *
+ *   if (isConnected) {
+ *     return <button onClick={disconnect}>Disconnect ({balance})</button>;
+ *   }
+ *
+ *   return <button onClick={() => connect({ walletType: 'metamask' })}>Connect</button>;
+ * }
+ * ```
+ */
+function useVarityWallet(client) {
+    const [isConnected, setIsConnected] = (0, react_1.useState)(false);
+    const [account, setAccount] = (0, react_1.useState)(null);
+    const [walletInfo, setWalletInfo] = (0, react_1.useState)(null);
+    const [isConnecting, setIsConnecting] = (0, react_1.useState)(false);
+    const [error, setError] = (0, react_1.useState)(null);
+    const connect = (0, react_1.useCallback)(async (options) => {
+        setIsConnecting(true);
+        setError(null);
+        try {
+            const connectedAccount = await client.wallet.connect(options);
+            setAccount(connectedAccount);
+            setIsConnected(true);
+            // Get wallet info
+            const info = await client.wallet.getWalletInfo();
+            setWalletInfo(info);
+        }
+        catch (err) {
+            setError(err);
+            throw err;
+        }
+        finally {
+            setIsConnecting(false);
+        }
+    }, [client]);
+    const disconnect = (0, react_1.useCallback)(() => {
+        client.wallet.disconnect();
+        setAccount(null);
+        setIsConnected(false);
+        setWalletInfo(null);
+    }, [client]);
+    const refreshBalance = (0, react_1.useCallback)(async () => {
+        if (isConnected) {
+            const info = await client.wallet.getWalletInfo();
+            setWalletInfo(info);
+        }
+    }, [client, isConnected]);
+    return {
+        connect,
+        disconnect,
+        isConnected,
+        isConnecting,
+        account,
+        walletInfo,
+        address: walletInfo?.address || null,
+        balance: walletInfo?.balanceFormatted || '0',
+        chainId: walletInfo?.chainId || null,
+        refreshBalance,
+        error,
+    };
+}
+/**
+ * useVarityBalance - Track wallet balance with auto-refresh
+ *
+ * @example
+ * ```typescript
+ * function BalanceDisplay() {
+ *   const { balance, isLoading, refresh } = useVarityBalance(client);
+ *
+ *   return (
+ *     <div>
+ *       Balance: {balance}
+ *       <button onClick={refresh}>Refresh</button>
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
+function useVarityBalance(client, autoRefresh = true, refreshInterval = 10000) {
+    const [balance, setBalance] = (0, react_1.useState)('0');
+    const [isLoading, setIsLoading] = (0, react_1.useState)(false);
+    const [error, setError] = (0, react_1.useState)(null);
+    const fetchBalance = (0, react_1.useCallback)(async () => {
+        if (!client.wallet.isConnected()) {
+            setBalance('0');
+            return;
+        }
+        setIsLoading(true);
+        setError(null);
+        try {
+            const info = await client.wallet.getWalletInfo();
+            setBalance(info.balanceFormatted);
+        }
+        catch (err) {
+            setError(err);
+        }
+        finally {
+            setIsLoading(false);
+        }
+    }, [client]);
+    (0, react_1.useEffect)(() => {
+        fetchBalance();
+        if (autoRefresh) {
+            const interval = setInterval(fetchBalance, refreshInterval);
+            return () => clearInterval(interval);
+        }
+    }, [fetchBalance, autoRefresh, refreshInterval]);
+    return {
+        balance,
+        isLoading,
+        error,
+        refresh: fetchBalance,
+    };
+}
+/**
+ * useVarityContract - Interact with smart contracts
+ *
+ * @example
+ * ```typescript
+ * function TokenBalance() {
+ *   const { read, write, isLoading } = useVarityContract(client, account);
+ *
+ *   const balance = read({
+ *     address: '0x...',
+ *     abi: ERC20_ABI,
+ *     functionName: 'balanceOf',
+ *     args: ['0x...']
+ *   });
+ *
+ *   return <div>Balance: {balance}</div>;
+ * }
+ * ```
+ */
+function useVarityContract(client, account) {
+    const [isLoading, setIsLoading] = (0, react_1.useState)(false);
+    const [error, setError] = (0, react_1.useState)(null);
+    const read = (0, react_1.useCallback)(async (options) => {
+        setIsLoading(true);
+        setError(null);
+        try {
+            const result = await client.contracts.read(options);
+            return result;
+        }
+        catch (err) {
+            setError(err);
+            throw err;
+        }
+        finally {
+            setIsLoading(false);
+        }
+    }, [client]);
+    const write = (0, react_1.useCallback)(async (options) => {
+        if (!account) {
+            throw new Error('No wallet connected');
+        }
+        setIsLoading(true);
+        setError(null);
+        try {
+            const result = await client.contracts.write(options, account);
+            return result;
+        }
+        catch (err) {
+            setError(err);
+            throw err;
+        }
+        finally {
+            setIsLoading(false);
+        }
+    }, [client, account]);
+    return {
+        read,
+        write,
+        isLoading,
+        error,
+    };
+}
+/**
+ * useVarityAuth - Manage SIWE authentication
+ *
+ * @example
+ * ```typescript
+ * function AuthButton() {
+ *   const { signIn, signOut, isAuthenticated, session } = useVarityAuth(client, account);
+ *
+ *   if (isAuthenticated) {
+ *     return <button onClick={signOut}>Sign Out</button>;
+ *   }
+ *
+ *   return <button onClick={signIn}>Sign In with Ethereum</button>;
+ * }
+ * ```
+ */
+function useVarityAuth(client, account) {
+    const [isAuthenticated, setIsAuthenticated] = (0, react_1.useState)(false);
+    const [session, setSession] = (0, react_1.useState)(null);
+    const [isLoading, setIsLoading] = (0, react_1.useState)(false);
+    const [error, setError] = (0, react_1.useState)(null);
+    const signIn = (0, react_1.useCallback)(async (statement) => {
+        if (!account) {
+            throw new Error('No wallet connected');
+        }
+        setIsLoading(true);
+        setError(null);
+        try {
+            // Generate SIWE message
+            const message = await client.auth.generateMessage({
+                address: account.address,
+                statement: statement || 'Sign in to Varity',
+            });
+            // Sign message
+            const result = await client.auth.signMessage(message, account);
+            // Create session
+            const newSession = await client.auth.createSession(result);
+            setSession(newSession);
+            setIsAuthenticated(true);
+            return newSession;
+        }
+        catch (err) {
+            setError(err);
+            throw err;
+        }
+        finally {
+            setIsLoading(false);
+        }
+    }, [client, account]);
+    const signOut = (0, react_1.useCallback)(() => {
+        if (account) {
+            client.auth.deleteSession(account.address);
+        }
+        setSession(null);
+        setIsAuthenticated(false);
+    }, [client, account]);
+    // Check for existing session on mount
+    (0, react_1.useEffect)(() => {
+        if (account) {
+            const existingSession = client.auth.getSession(account.address);
+            if (existingSession) {
+                setSession(existingSession);
+                setIsAuthenticated(true);
+            }
+        }
+    }, [client, account]);
+    return {
+        signIn,
+        signOut,
+        isAuthenticated,
+        session,
+        isLoading,
+        error,
+    };
+}
+/**
+ * useVarityStorage - Upload and download from IPFS
+ *
+ * @example
+ * ```typescript
+ * function FileUpload() {
+ *   const { upload, isUploading, uploadProgress } = useVarityStorage(client);
+ *
+ *   const handleUpload = async (file: File) => {
+ *     const result = await upload(file);
+ *     console.log('Uploaded to:', result.gateway);
+ *   };
+ *
+ *   return <input type="file" onChange={(e) => handleUpload(e.target.files[0])} />;
+ * }
+ * ```
+ */
+function useVarityStorage(client) {
+    const [isUploading, setIsUploading] = (0, react_1.useState)(false);
+    const [uploadProgress, setUploadProgress] = (0, react_1.useState)(0);
+    const [error, setError] = (0, react_1.useState)(null);
+    const upload = (0, react_1.useCallback)(async (file, options) => {
+        setIsUploading(true);
+        setUploadProgress(0);
+        setError(null);
+        try {
+            const result = await client.storage.upload(file, {
+                ...options,
+                onProgress: (progress) => {
+                    setUploadProgress(progress);
+                    options?.onProgress?.(progress);
+                },
+            });
+            setUploadProgress(100);
+            return result;
+        }
+        catch (err) {
+            setError(err);
+            throw err;
+        }
+        finally {
+            setIsUploading(false);
+        }
+    }, [client]);
+    const download = (0, react_1.useCallback)(async (cid) => {
+        setError(null);
+        try {
+            const data = await client.storage.download(cid);
+            return data;
+        }
+        catch (err) {
+            setError(err);
+            throw err;
+        }
+    }, [client]);
+    const uploadJSON = (0, react_1.useCallback)(async (data, options) => {
+        setIsUploading(true);
+        setError(null);
+        try {
+            const result = await client.storage.uploadJSON(data, options);
+            return result;
+        }
+        catch (err) {
+            setError(err);
+            throw err;
+        }
+        finally {
+            setIsUploading(false);
+        }
+    }, [client]);
+    return {
+        upload,
+        download,
+        uploadJSON,
+        isUploading,
+        uploadProgress,
+        error,
+    };
+}
+/**
+ * useVarityChain - Monitor chain information
+ *
+ * @example
+ * ```typescript
+ * function ChainInfo() {
+ *   const { chainId, chainName, isVarityL3 } = useVarityChain(client);
+ *
+ *   return <div>Connected to: {chainName} (ID: {chainId})</div>;
+ * }
+ * ```
+ */
+function useVarityChain(client) {
+    const config = (0, react_1.useMemo)(() => client.getConfig(), [client]);
+    return {
+        chainId: config.chainId,
+        chainName: config.chainName,
+        rpcUrl: config.rpcUrl,
+        nativeCurrency: config.nativeCurrency,
+        isVarityL3: config.isVarityL3,
+    };
+}

package/dist/storage/StorageManager.d.ts

@@ -0,0 +1,122 @@
+/**
+ * Storage Manager - Handle IPFS storage operations via Thirdweb
+ */
+import type { ThirdwebClient } from 'thirdweb';
+import type { StorageUploadOptions, StorageUploadResult, StorageDownloadOptions } from '../types';
+/**
+ * StorageManager - Manage IPFS storage operations
+ *
+ * @example
+ * ```typescript
+ * // Upload file
+ * const result = await storageManager.upload(file);
+ * console.log('IPFS CID:', result.cid);
+ *
+ * // Download file
+ * const data = await storageManager.download(result.cid);
+ * ```
+ */
+export declare class StorageManager {
+    private readonly client;
+    private readonly defaultGateway;
+    constructor(client: ThirdwebClient);
+    /**
+     * Upload file to IPFS
+     * @param file File to upload (File, Blob, or Buffer)
+     * @param options Upload options
+     * @returns Upload result with CID and URL
+     */
+    upload(file: File | Blob | Buffer | string, options?: StorageUploadOptions): Promise<StorageUploadResult>;
+    /**
+     * Upload multiple files to IPFS
+     * @param files Array of files to upload
+     * @param options Upload options
+     * @returns Array of upload results
+     */
+    uploadBatch(files: (File | Blob | Buffer | string)[], options?: StorageUploadOptions): Promise<StorageUploadResult[]>;
+    /**
+     * Upload JSON data to IPFS
+     * @param data JSON data to upload
+     * @param options Upload options
+     * @returns Upload result
+     */
+    uploadJSON(data: any, options?: StorageUploadOptions): Promise<StorageUploadResult>;
+    /**
+     * Download file from IPFS
+     * @param cid IPFS CID or full URI
+     * @param options Download options
+     * @returns Downloaded data
+     */
+    download(cid: string, options?: StorageDownloadOptions): Promise<any>;
+    /**
+     * Download JSON from IPFS
+     * @param cid IPFS CID or full URI
+     * @param options Download options
+     * @returns Parsed JSON data
+     */
+    downloadJSON(cid: string, options?: StorageDownloadOptions): Promise<any>;
+    /**
+     * Get IPFS gateway URL for CID
+     * @param cid IPFS CID
+     * @param gateway Custom gateway URL (optional)
+     * @returns Gateway URL
+     */
+    getGatewayUrl(cid: string, gateway?: string): string;
+    /**
+     * Get IPFS URI from CID
+     * @param cid IPFS CID
+     * @returns IPFS URI
+     */
+    getIPFSUri(cid: string): string;
+    /**
+     * Upload metadata for NFT
+     * @param metadata NFT metadata object
+     * @returns Upload result with metadata URI
+     */
+    uploadNFTMetadata(metadata: {
+        name: string;
+        description: string;
+        image: string;
+        attributes?: Array<{
+            trait_type: string;
+            value: any;
+        }>;
+        [key: string]: any;
+    }): Promise<StorageUploadResult>;
+    /**
+     * Upload directory to IPFS
+     * @param files Array of files with names
+     * @returns Upload result with directory CID
+     */
+    uploadDirectory(files: Array<{
+        name: string;
+        content: File | Blob | Buffer | string;
+    }>): Promise<StorageUploadResult>;
+    /**
+     * Check if CID is valid
+     * @param cid CID to validate
+     * @returns True if valid
+     */
+    isValidCID(cid: string): boolean;
+    /**
+     * Pin CID to ensure persistence
+     * Note: This requires a pinning service integration
+     * @param cid CID to pin
+     */
+    pin(cid: string): Promise<void>;
+    /**
+     * Unpin CID
+     * Note: This requires a pinning service integration
+     * @param cid CID to unpin
+     */
+    unpin(cid: string): Promise<void>;
+    /**
+     * Get storage statistics
+     * @returns Storage statistics
+     */
+    getStats(): Promise<{
+        totalUploads: number;
+        totalSize: number;
+    }>;
+}
+export default StorageManager;