@treza/react 0.0.4

package/dist/index.js

@@ -0,0 +1,1059 @@
+'use strict';
+
+var React = require('react');
+var sdk = require('@treza/sdk');
+var ethers = require('ethers');
+
+// Context for compliance SDK
+const ComplianceContext = React.createContext({
+    sdk: null,
+    isLoading: true,
+    error: null
+});
+/**
+ * Provider component that initializes the compliance SDK
+ */
+const ComplianceProvider = ({ provider, signer, children }) => {
+    const [sdk$1, setSdk] = React.useState(null);
+    const [isLoading, setIsLoading] = React.useState(true);
+    const [error, setError] = React.useState(null);
+    React.useEffect(() => {
+        try {
+            const config = {
+                zkPassportDomain: "trezalabs.com",
+                zkVerifyEndpoint: "https://api.zkverify.io",
+                trezaTokenAddress: process.env.REACT_APP_TREZA_TOKEN_ADDRESS || "0x8278d4FbfaB7dac14eC0295421D0a2733b4504E5",
+                complianceVerifierAddress: process.env.REACT_APP_COMPLIANCE_VERIFIER_ADDRESS || "0x8c0C6e0Eaf6bc693745A1A3a722e2c9028BBe874",
+                complianceIntegrationAddress: process.env.REACT_APP_COMPLIANCE_INTEGRATION_ADDRESS || "0xf3ecfC409761D715F137Bfe7078Acec6d7F55428",
+                provider,
+                signer
+            };
+            const complianceSDK = new sdk.TrezaComplianceSDK(config);
+            setSdk(complianceSDK);
+            setError(null);
+        }
+        catch (err) {
+            setError(err instanceof Error ? err.message : 'Failed to initialize compliance SDK');
+        }
+        finally {
+            setIsLoading(false);
+        }
+    }, [provider, signer]);
+    return (React.createElement(ComplianceContext.Provider, { value: { sdk: sdk$1, isLoading, error } }, children));
+};
+/**
+ * Hook to use compliance context (for use within ComplianceProvider)
+ */
+const useComplianceContext = () => {
+    const context = React.useContext(ComplianceContext);
+    if (!context) {
+        throw new Error('useComplianceContext must be used within a ComplianceProvider');
+    }
+    return context;
+};
+/**
+ * Main compliance verification component
+ */
+const ComplianceVerification = ({ userAddress, requirements, onVerificationComplete, onError, className = "" }) => {
+    const { sdk } = useComplianceContext();
+    const [verificationUrl, setVerificationUrl] = React.useState("");
+    const [qrCode, setQrCode] = React.useState("");
+    const [isGenerating, setIsGenerating] = React.useState(false);
+    const [status, setStatus] = React.useState('idle');
+    const [error, setError] = React.useState("");
+    const initiateVerification = React.useCallback(async () => {
+        if (!sdk)
+            return;
+        setIsGenerating(true);
+        setStatus('generating');
+        setError("");
+        try {
+            const url = await sdk.initiateVerification(requirements);
+            setVerificationUrl(url);
+            const qr = await sdk.generateQRCode(url);
+            setQrCode(qr);
+            setStatus('waiting');
+        }
+        catch (err) {
+            const errorMessage = err instanceof Error ? err.message : 'Failed to initiate verification';
+            setError(errorMessage);
+            setStatus('error');
+            onError?.(errorMessage);
+        }
+        finally {
+            setIsGenerating(false);
+        }
+    }, [sdk, requirements, onError]);
+    React.useCallback(async (zkPassportResult) => {
+        if (!sdk)
+            return;
+        setStatus('processing');
+        try {
+            const result = await sdk.processVerificationResult(zkPassportResult, userAddress);
+            setStatus('complete');
+            onVerificationComplete?.(result);
+        }
+        catch (err) {
+            const errorMessage = err instanceof Error ? err.message : 'Failed to process verification';
+            setError(errorMessage);
+            setStatus('error');
+            onError?.(errorMessage);
+        }
+    }, [sdk, userAddress, onVerificationComplete, onError]);
+    return (React.createElement("div", { className: `treza-compliance-verification ${className}` },
+        React.createElement("div", { className: "verification-header" },
+            React.createElement("h3", null, "\uD83D\uDEE1\uFE0F Identity Verification"),
+            React.createElement("p", null, "Verify your identity to access TREZA features while keeping your personal data private.")),
+        status === 'idle' && (React.createElement("div", { className: "verification-start" },
+            React.createElement("button", { onClick: initiateVerification, disabled: isGenerating, className: "btn-primary" }, isGenerating ? 'Generating...' : 'Start Verification'))),
+        status === 'generating' && (React.createElement("div", { className: "verification-generating" },
+            React.createElement("div", { className: "spinner" }),
+            React.createElement("p", null, "Generating verification request..."))),
+        status === 'waiting' && (React.createElement("div", { className: "verification-waiting" },
+            React.createElement("div", { className: "qr-code-section" },
+                React.createElement("h4", null, "\uD83D\uDCF1 Scan with ZKPassport App"),
+                qrCode && (React.createElement("img", { src: qrCode, alt: "Verification QR Code", className: "qr-code" })),
+                React.createElement("p", null, "Scan this QR code with the ZKPassport mobile app to verify your identity."),
+                React.createElement("a", { href: verificationUrl, target: "_blank", rel: "noopener noreferrer", className: "verification-link" }, "Or open verification link directly")),
+            React.createElement("div", { className: "verification-instructions" },
+                React.createElement("h5", null, "Instructions:"),
+                React.createElement("ol", null,
+                    React.createElement("li", null, "Download the ZKPassport app if you haven't already"),
+                    React.createElement("li", null, "Scan the QR code above"),
+                    React.createElement("li", null, "Follow the app instructions to verify your government ID"),
+                    React.createElement("li", null, "Your verification will be processed automatically"))))),
+        status === 'processing' && (React.createElement("div", { className: "verification-processing" },
+            React.createElement("div", { className: "spinner" }),
+            React.createElement("p", null, "Processing your verification..."))),
+        status === 'complete' && (React.createElement("div", { className: "verification-complete" },
+            React.createElement("div", { className: "success-icon" }, "\u2705"),
+            React.createElement("h4", null, "Verification Complete!"),
+            React.createElement("p", null, "Your identity has been verified successfully. You now have access to TREZA compliance features."))),
+        status === 'error' && (React.createElement("div", { className: "verification-error" },
+            React.createElement("div", { className: "error-icon" }, "\u274C"),
+            React.createElement("h4", null, "Verification Error"),
+            React.createElement("p", null, error),
+            React.createElement("button", { onClick: () => setStatus('idle'), className: "btn-secondary" }, "Try Again")))));
+};
+/**
+ * Component to display current compliance status
+ */
+const ComplianceStatusDisplay = ({ userAddress, showDetails = false, className = "" }) => {
+    const { sdk } = useComplianceContext();
+    const [status, setStatus] = React.useState(null);
+    const [isLoading, setIsLoading] = React.useState(true);
+    const [error, setError] = React.useState("");
+    React.useEffect(() => {
+        const checkStatus = async () => {
+            if (!sdk || !userAddress)
+                return;
+            setIsLoading(true);
+            try {
+                const complianceStatus = await sdk.checkComplianceStatus(userAddress);
+                setStatus(complianceStatus);
+                setError("");
+            }
+            catch (err) {
+                setError(err instanceof Error ? err.message : 'Failed to check compliance status');
+            }
+            finally {
+                setIsLoading(false);
+            }
+        };
+        checkStatus();
+    }, [sdk, userAddress]);
+    if (isLoading) {
+        return (React.createElement("div", { className: `compliance-status loading ${className}` },
+            React.createElement("div", { className: "spinner" }),
+            React.createElement("span", null, "Checking compliance status...")));
+    }
+    if (error) {
+        return (React.createElement("div", { className: `compliance-status error ${className}` },
+            React.createElement("span", { className: "status-icon" }, "\u26A0\uFE0F"),
+            React.createElement("span", null,
+                "Error: ",
+                error)));
+    }
+    if (!status) {
+        return (React.createElement("div", { className: `compliance-status unknown ${className}` },
+            React.createElement("span", { className: "status-icon" }, "\u2753"),
+            React.createElement("span", null, "Status unknown")));
+    }
+    return (React.createElement("div", { className: `compliance-status ${status.isCompliant ? 'compliant' : 'non-compliant'} ${className}` },
+        React.createElement("div", { className: "status-header" },
+            React.createElement("span", { className: "status-icon" }, status.isCompliant ? '✅' : '❌'),
+            React.createElement("span", { className: "status-text" }, status.isCompliant ? 'Verified' : 'Not Verified')),
+        showDetails && status.isCompliant && (React.createElement("div", { className: "status-details" },
+            React.createElement("div", { className: "detail-item" },
+                React.createElement("span", { className: "label" }, "Level:"),
+                React.createElement("span", { className: "value" }, status.verificationLevel)),
+            React.createElement("div", { className: "detail-item" },
+                React.createElement("span", { className: "label" }, "Expires:"),
+                React.createElement("span", { className: "value" }, new Date(status.expirationTime).toLocaleDateString())),
+            React.createElement("div", { className: "detail-item" },
+                React.createElement("span", { className: "label" }, "Attributes:"),
+                React.createElement("div", { className: "attributes" },
+                    status.attributes.ageVerified && React.createElement("span", { className: "attribute" }, "Age \u2713"),
+                    status.attributes.nationalityVerified && React.createElement("span", { className: "attribute" }, "Nationality \u2713"),
+                    status.attributes.uniquenessVerified && React.createElement("span", { className: "attribute" }, "Uniqueness \u2713")))))));
+};
+/**
+ * Component to display governance eligibility
+ */
+const GovernanceEligibility = ({ userAddress, proposalId, className = "" }) => {
+    const { sdk } = useComplianceContext();
+    const [eligibility, setEligibility] = React.useState(null);
+    const [isLoading, setIsLoading] = React.useState(true);
+    React.useEffect(() => {
+        const checkEligibility = async () => {
+            if (!sdk || !userAddress)
+                return;
+            setIsLoading(true);
+            try {
+                const result = await sdk.checkGovernanceEligibility(userAddress, proposalId);
+                setEligibility(result);
+            }
+            catch (err) {
+                console.error('Error checking governance eligibility:', err);
+            }
+            finally {
+                setIsLoading(false);
+            }
+        };
+        checkEligibility();
+    }, [sdk, userAddress, proposalId]);
+    if (isLoading) {
+        return (React.createElement("div", { className: `governance-eligibility loading ${className}` },
+            React.createElement("div", { className: "spinner" }),
+            React.createElement("span", null, "Checking eligibility...")));
+    }
+    if (!eligibility) {
+        return (React.createElement("div", { className: `governance-eligibility error ${className}` },
+            React.createElement("span", null, "Unable to check eligibility")));
+    }
+    return (React.createElement("div", { className: `governance-eligibility ${eligibility.canParticipate ? 'eligible' : 'ineligible'} ${className}` },
+        React.createElement("div", { className: "eligibility-status" },
+            React.createElement("span", { className: "status-icon" }, eligibility.canParticipate ? '🗳️' : '🚫'),
+            React.createElement("span", { className: "status-text" }, eligibility.canParticipate ? 'Eligible to Vote' : 'Not Eligible')),
+        eligibility.canParticipate && (React.createElement("div", { className: "voting-details" },
+            React.createElement("div", { className: "voting-weight" },
+                React.createElement("span", { className: "label" }, "Voting Weight:"),
+                React.createElement("span", { className: "value" },
+                    eligibility.votingWeight,
+                    "x")),
+            React.createElement("div", { className: "compliance-level" },
+                React.createElement("span", { className: "label" }, "Compliance Level:"),
+                React.createElement("span", { className: "value" }, eligibility.complianceLevel))))));
+};
+// CSS styles (you would typically put this in a separate CSS file)
+const complianceStyles = `
+.treza-compliance-verification {
+    max-width: 500px;
+    margin: 0 auto;
+    padding: 20px;
+    border: 1px solid #e0e0e0;
+    border-radius: 8px;
+    background: #fff;
+}
+
+.verification-header h3 {
+    margin: 0 0 10px 0;
+    color: #333;
+}
+
+.verification-header p {
+    margin: 0 0 20px 0;
+    color: #666;
+    font-size: 14px;
+}
+
+.btn-primary, .btn-secondary {
+    padding: 12px 24px;
+    border: none;
+    border-radius: 6px;
+    font-size: 16px;
+    cursor: pointer;
+    transition: background-color 0.2s;
+}
+
+.btn-primary {
+    background: #007bff;
+    color: white;
+}
+
+.btn-primary:hover {
+    background: #0056b3;
+}
+
+.btn-primary:disabled {
+    background: #ccc;
+    cursor: not-allowed;
+}
+
+.btn-secondary {
+    background: #6c757d;
+    color: white;
+}
+
+.qr-code {
+    max-width: 200px;
+    height: auto;
+    margin: 10px 0;
+}
+
+.spinner {
+    width: 20px;
+    height: 20px;
+    border: 2px solid #f3f3f3;
+    border-top: 2px solid #007bff;
+    border-radius: 50%;
+    animation: spin 1s linear infinite;
+    display: inline-block;
+    margin-right: 10px;
+}
+
+@keyframes spin {
+    0% { transform: rotate(0deg); }
+    100% { transform: rotate(360deg); }
+}
+
+.compliance-status {
+    display: flex;
+    align-items: center;
+    padding: 10px;
+    border-radius: 6px;
+    margin: 10px 0;
+}
+
+.compliance-status.compliant {
+    background: #d4edda;
+    color: #155724;
+    border: 1px solid #c3e6cb;
+}
+
+.compliance-status.non-compliant {
+    background: #f8d7da;
+    color: #721c24;
+    border: 1px solid #f5c6cb;
+}
+
+.status-icon {
+    margin-right: 8px;
+    font-size: 18px;
+}
+
+.status-details {
+    margin-top: 10px;
+    font-size: 14px;
+}
+
+.detail-item {
+    margin: 5px 0;
+}
+
+.label {
+    font-weight: bold;
+    margin-right: 8px;
+}
+
+.attributes {
+    display: flex;
+    gap: 8px;
+    flex-wrap: wrap;
+}
+
+.attribute {
+    background: #e9ecef;
+    padding: 2px 6px;
+    border-radius: 4px;
+    font-size: 12px;
+}
+`;
+
+class ComplianceService {
+    constructor(config = {}) {
+        this.sdk = null;
+        this.config = {
+            zkPassportDomain: "trezalabs.com",
+            zkVerifyEndpoint: "https://api.zkverify.io",
+            trezaTokenAddress: process.env.REACT_APP_TREZA_TOKEN_ADDRESS || "0x8278d4FbfaB7dac14eC0295421D0a2733b4504E5",
+            complianceVerifierAddress: process.env.REACT_APP_COMPLIANCE_VERIFIER_ADDRESS || "0x8c0C6e0Eaf6bc693745A1A3a722e2c9028BBe874",
+            complianceIntegrationAddress: process.env.REACT_APP_COMPLIANCE_INTEGRATION_ADDRESS || "0xf3ecfC409761D715F137Bfe7078Acec6d7F55428",
+            ...config
+        };
+    }
+    /**
+     * Initialize the compliance SDK with provider and signer
+     */
+    async initialize(provider, signer) {
+        try {
+            this.sdk = new sdk.TrezaComplianceSDK({
+                zkPassportDomain: this.config.zkPassportDomain,
+                zkVerifyEndpoint: this.config.zkVerifyEndpoint,
+                zkVerifyApiKey: this.config.zkVerifyApiKey,
+                trezaTokenAddress: this.config.trezaTokenAddress,
+                complianceVerifierAddress: this.config.complianceVerifierAddress,
+                complianceIntegrationAddress: this.config.complianceIntegrationAddress,
+                provider,
+                signer
+            });
+        }
+        catch (error) {
+            console.error('Failed to initialize compliance service:', error);
+            throw error;
+        }
+    }
+    /**
+     * Get the initialized SDK instance
+     */
+    getSDK() {
+        if (!this.sdk) {
+            throw new Error('Compliance service not initialized. Call initialize() first.');
+        }
+        return this.sdk;
+    }
+    /**
+     * Check if the service is initialized
+     */
+    isInitialized() {
+        return this.sdk !== null;
+    }
+    /**
+     * Initiate verification with React-friendly error handling
+     */
+    async initiateVerification(requirements) {
+        try {
+            if (!this.sdk) {
+                throw new Error('Service not initialized');
+            }
+            const url = await this.sdk.initiateVerification(requirements);
+            return { success: true, url };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+            return { success: false, error: errorMessage };
+        }
+    }
+    /**
+     * Process verification result with React-friendly error handling
+     */
+    async processVerificationResult(zkPassportResult, userAddress) {
+        try {
+            if (!this.sdk) {
+                throw new Error('Service not initialized');
+            }
+            const result = await this.sdk.processVerificationResult(zkPassportResult, userAddress);
+            return { success: true, result };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+            return { success: false, error: errorMessage };
+        }
+    }
+    /**
+     * Check compliance status with React-friendly error handling
+     */
+    async checkComplianceStatus(userAddress) {
+        try {
+            if (!this.sdk) {
+                throw new Error('Service not initialized');
+            }
+            const status = await this.sdk.checkComplianceStatus(userAddress);
+            return { success: true, status };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+            return { success: false, error: errorMessage };
+        }
+    }
+    /**
+     * Generate QR code for verification URL
+     */
+    async generateQRCode(url) {
+        try {
+            if (!this.sdk) {
+                throw new Error('Service not initialized');
+            }
+            const qrCode = await this.sdk.generateQRCode(url);
+            return { success: true, qrCode };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+            return { success: false, error: errorMessage };
+        }
+    }
+    /**
+     * Batch check compliance for multiple users
+     */
+    async batchCheckCompliance(userAddresses) {
+        try {
+            if (!this.sdk) {
+                throw new Error('Service not initialized');
+            }
+            const results = await this.sdk.batchCheckCompliance(userAddresses);
+            return { success: true, results };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+            return { success: false, error: errorMessage };
+        }
+    }
+    /**
+     * Check governance eligibility
+     */
+    async checkGovernanceEligibility(userAddress, proposalId) {
+        try {
+            if (!this.sdk) {
+                throw new Error('Service not initialized');
+            }
+            if (!proposalId) {
+                throw new Error('Proposal ID is required');
+            }
+            const proposalIdNum = parseInt(proposalId, 10);
+            if (isNaN(proposalIdNum)) {
+                throw new Error('Invalid proposal ID: must be a number');
+            }
+            const eligibility = await this.sdk.checkGovernanceEligibility(userAddress, proposalIdNum);
+            return { success: true, eligibility };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+            return { success: false, error: errorMessage };
+        }
+    }
+    /**
+     * Cleanup resources
+     */
+    destroy() {
+        this.sdk = null;
+    }
+}
+// Singleton instance for React apps
+let complianceServiceInstance = null;
+/**
+ * Get or create the global compliance service instance
+ */
+function getComplianceService(config) {
+    if (!complianceServiceInstance) {
+        complianceServiceInstance = new ComplianceService(config);
+    }
+    return complianceServiceInstance;
+}
+/**
+ * Reset the global compliance service instance
+ */
+function resetComplianceService() {
+    if (complianceServiceInstance) {
+        complianceServiceInstance.destroy();
+        complianceServiceInstance = null;
+    }
+}
+
+class WalletService {
+    constructor() {
+        this.provider = null;
+        this.signer = null;
+        this.currentAddress = null;
+    }
+    /**
+     * Connect to MetaMask or other Web3 wallet
+     */
+    async connectWallet() {
+        try {
+            // Check if Web3 is available
+            if (typeof window === 'undefined' || !window.ethereum) {
+                return {
+                    success: false,
+                    error: 'Web3 wallet not found. Please install MetaMask or another Web3 wallet.'
+                };
+            }
+            // Request account access
+            await window.ethereum.request({ method: 'eth_requestAccounts' });
+            // Create provider and signer
+            const provider = new ethers.ethers.BrowserProvider(window.ethereum);
+            const signer = await provider.getSigner();
+            const address = await signer.getAddress();
+            const network = await provider.getNetwork();
+            // Store references
+            this.provider = provider;
+            this.signer = signer;
+            this.currentAddress = address;
+            return {
+                success: true,
+                provider,
+                signer,
+                address,
+                chainId: Number(network.chainId)
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Failed to connect wallet';
+            return {
+                success: false,
+                error: errorMessage
+            };
+        }
+    }
+    /**
+     * Disconnect wallet
+     */
+    disconnect() {
+        this.provider = null;
+        this.signer = null;
+        this.currentAddress = null;
+    }
+    /**
+     * Get current wallet info
+     */
+    async getWalletInfo() {
+        if (!this.provider || !this.currentAddress) {
+            return null;
+        }
+        try {
+            const balance = await this.provider.getBalance(this.currentAddress);
+            const network = await this.provider.getNetwork();
+            return {
+                address: this.currentAddress,
+                chainId: Number(network.chainId),
+                balance: ethers.ethers.formatEther(balance),
+                isConnected: true
+            };
+        }
+        catch (error) {
+            console.error('Failed to get wallet info:', error);
+            return null;
+        }
+    }
+    /**
+     * Switch to a specific network
+     */
+    async switchNetwork(chainId) {
+        try {
+            if (!window.ethereum) {
+                return { success: false, error: 'Web3 wallet not found' };
+            }
+            await window.ethereum.request({
+                method: 'wallet_switchEthereumChain',
+                params: [{ chainId: `0x${chainId.toString(16)}` }],
+            });
+            return { success: true };
+        }
+        catch (error) {
+            // If the chain hasn't been added to MetaMask
+            if (error.code === 4902) {
+                return { success: false, error: 'Network not added to wallet' };
+            }
+            const errorMessage = error instanceof Error ? error.message : 'Failed to switch network';
+            return { success: false, error: errorMessage };
+        }
+    }
+    /**
+     * Add a custom network to the wallet
+     */
+    async addNetwork(networkConfig) {
+        try {
+            if (!window.ethereum) {
+                return { success: false, error: 'Web3 wallet not found' };
+            }
+            await window.ethereum.request({
+                method: 'wallet_addEthereumChain',
+                params: [{
+                        chainId: `0x${networkConfig.chainId.toString(16)}`,
+                        chainName: networkConfig.chainName,
+                        rpcUrls: networkConfig.rpcUrls,
+                        nativeCurrency: networkConfig.nativeCurrency,
+                        blockExplorerUrls: networkConfig.blockExplorerUrls
+                    }],
+            });
+            return { success: true };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Failed to add network';
+            return { success: false, error: errorMessage };
+        }
+    }
+    /**
+     * Sign a message
+     */
+    async signMessage(message) {
+        try {
+            if (!this.signer) {
+                return { success: false, error: 'Wallet not connected' };
+            }
+            const signature = await this.signer.signMessage(message);
+            return { success: true, signature };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Failed to sign message';
+            return { success: false, error: errorMessage };
+        }
+    }
+    /**
+     * Get current provider
+     */
+    getProvider() {
+        return this.provider;
+    }
+    /**
+     * Get current signer
+     */
+    getSigner() {
+        return this.signer;
+    }
+    /**
+     * Get current address
+     */
+    getCurrentAddress() {
+        return this.currentAddress;
+    }
+    /**
+     * Check if wallet is connected
+     */
+    isConnected() {
+        return this.provider !== null && this.signer !== null && this.currentAddress !== null;
+    }
+    /**
+     * Listen for account changes
+     */
+    onAccountsChanged(callback) {
+        if (window.ethereum) {
+            window.ethereum.on('accountsChanged', callback);
+        }
+    }
+    /**
+     * Listen for chain changes
+     */
+    onChainChanged(callback) {
+        if (window.ethereum) {
+            window.ethereum.on('chainChanged', callback);
+        }
+    }
+    /**
+     * Remove event listeners
+     */
+    removeAllListeners() {
+        if (window.ethereum) {
+            window.ethereum.removeAllListeners('accountsChanged');
+            window.ethereum.removeAllListeners('chainChanged');
+        }
+    }
+}
+// Singleton instance for React apps
+let walletServiceInstance = null;
+/**
+ * Get or create the global wallet service instance
+ */
+function getWalletService() {
+    if (!walletServiceInstance) {
+        walletServiceInstance = new WalletService();
+    }
+    return walletServiceInstance;
+}
+/**
+ * Reset the global wallet service instance
+ */
+function resetWalletService() {
+    if (walletServiceInstance) {
+        walletServiceInstance.removeAllListeners();
+        walletServiceInstance.disconnect();
+        walletServiceInstance = null;
+    }
+}
+
+/**
+ * Hook for wallet connection and management
+ */
+function useWallet() {
+    const [isConnected, setIsConnected] = React.useState(false);
+    const [isConnecting, setIsConnecting] = React.useState(false);
+    const [walletInfo, setWalletInfo] = React.useState(null);
+    const [provider, setProvider] = React.useState(null);
+    const [signer, setSigner] = React.useState(null);
+    const [address, setAddress] = React.useState(null);
+    const [error, setError] = React.useState(null);
+    const walletService = React.useRef(getWalletService());
+    const connect = React.useCallback(async () => {
+        setIsConnecting(true);
+        setError(null);
+        try {
+            const result = await walletService.current.connectWallet();
+            if (result.success) {
+                setIsConnected(true);
+                setProvider(result.provider || null);
+                setSigner(result.signer || null);
+                setAddress(result.address || null);
+                // Get wallet info
+                const info = await walletService.current.getWalletInfo();
+                setWalletInfo(info);
+            }
+            else {
+                setError(result.error || 'Failed to connect wallet');
+            }
+        }
+        catch (err) {
+            setError(err instanceof Error ? err.message : 'Failed to connect wallet');
+        }
+        finally {
+            setIsConnecting(false);
+        }
+    }, []);
+    const disconnect = React.useCallback(() => {
+        walletService.current.disconnect();
+        setIsConnected(false);
+        setProvider(null);
+        setSigner(null);
+        setAddress(null);
+        setWalletInfo(null);
+        setError(null);
+    }, []);
+    const switchNetwork = React.useCallback(async (chainId) => {
+        setError(null);
+        try {
+            const result = await walletService.current.switchNetwork(chainId);
+            if (!result.success) {
+                setError(result.error || 'Failed to switch network');
+            }
+        }
+        catch (err) {
+            setError(err instanceof Error ? err.message : 'Failed to switch network');
+        }
+    }, []);
+    // Set up event listeners
+    React.useEffect(() => {
+        const handleAccountsChanged = (accounts) => {
+            if (accounts.length === 0) {
+                disconnect();
+            }
+            else {
+                setAddress(accounts[0]);
+            }
+        };
+        const handleChainChanged = () => {
+            // Reload wallet info when chain changes
+            if (isConnected) {
+                walletService.current.getWalletInfo().then(setWalletInfo);
+            }
+        };
+        walletService.current.onAccountsChanged(handleAccountsChanged);
+        walletService.current.onChainChanged(handleChainChanged);
+        return () => {
+            walletService.current.removeAllListeners();
+        };
+    }, [isConnected, disconnect]);
+    return {
+        isConnected,
+        isConnecting,
+        walletInfo,
+        provider,
+        signer,
+        address,
+        error,
+        connect,
+        disconnect,
+        switchNetwork
+    };
+}
+/**
+ * Hook for compliance operations
+ */
+function useCompliance(provider, signer) {
+    const [isInitialized, setIsInitialized] = React.useState(false);
+    const [isLoading, setIsLoading] = React.useState(false);
+    const [error, setError] = React.useState(null);
+    const complianceService = React.useRef(getComplianceService());
+    // Initialize service when provider/signer changes
+    React.useEffect(() => {
+        if (provider) {
+            setIsLoading(true);
+            complianceService.current.initialize(provider, signer)
+                .then(() => {
+                setIsInitialized(true);
+                setError(null);
+            })
+                .catch((err) => {
+                setError(err instanceof Error ? err.message : 'Failed to initialize compliance');
+                setIsInitialized(false);
+            })
+                .finally(() => {
+                setIsLoading(false);
+            });
+        }
+        else {
+            setIsInitialized(false);
+        }
+    }, [provider, signer]);
+    const initiateVerification = React.useCallback(async (requirements) => {
+        setError(null);
+        const result = await complianceService.current.initiateVerification(requirements);
+        if (result.success) {
+            return result.url || null;
+        }
+        else {
+            setError(result.error || 'Failed to initiate verification');
+            return null;
+        }
+    }, []);
+    const processVerification = React.useCallback(async (zkPassportResult, userAddress) => {
+        setError(null);
+        const result = await complianceService.current.processVerificationResult(zkPassportResult, userAddress);
+        if (result.success) {
+            return result.result || null;
+        }
+        else {
+            setError(result.error || 'Failed to process verification');
+            return null;
+        }
+    }, []);
+    const checkCompliance = React.useCallback(async (userAddress) => {
+        setError(null);
+        const result = await complianceService.current.checkComplianceStatus(userAddress);
+        if (result.success) {
+            return result.status || null;
+        }
+        else {
+            setError(result.error || 'Failed to check compliance');
+            return null;
+        }
+    }, []);
+    const generateQRCode = React.useCallback(async (url) => {
+        setError(null);
+        const result = await complianceService.current.generateQRCode(url);
+        if (result.success) {
+            return result.qrCode || null;
+        }
+        else {
+            setError(result.error || 'Failed to generate QR code');
+            return null;
+        }
+    }, []);
+    return {
+        isInitialized,
+        isLoading,
+        error,
+        initiateVerification,
+        processVerification,
+        checkCompliance,
+        generateQRCode
+    };
+}
+/**
+ * Combined hook for wallet and compliance functionality
+ */
+function useTreza() {
+    const wallet = useWallet();
+    const compliance = useCompliance(wallet.provider || undefined, wallet.signer || undefined);
+    const isReady = wallet.isConnected && compliance.isInitialized;
+    return {
+        wallet,
+        compliance,
+        isReady
+    };
+}
+/**
+ * Hook for managing the complete verification flow
+ */
+function useVerificationFlow(provider, signer) {
+    const [status, setStatus] = React.useState('idle');
+    const [verificationUrl, setVerificationUrl] = React.useState(null);
+    const [qrCode, setQrCode] = React.useState(null);
+    const [result, setResult] = React.useState(null);
+    const [error, setError] = React.useState(null);
+    const [currentUserAddress, setCurrentUserAddress] = React.useState(null);
+    const compliance = useCompliance(provider, signer);
+    const startVerification = React.useCallback(async (userAddress, requirements) => {
+        setStatus('generating');
+        setError(null);
+        setResult(null);
+        setCurrentUserAddress(userAddress);
+        try {
+            const url = await compliance.initiateVerification(requirements);
+            if (url) {
+                setVerificationUrl(url);
+                const qr = await compliance.generateQRCode(url);
+                if (qr) {
+                    setQrCode(qr);
+                    setStatus('waiting');
+                }
+                else {
+                    throw new Error('Failed to generate QR code');
+                }
+            }
+            else {
+                throw new Error('Failed to initiate verification');
+            }
+        }
+        catch (err) {
+            setError(err instanceof Error ? err.message : 'Verification failed');
+            setStatus('error');
+        }
+    }, [compliance]);
+    const processResult = React.useCallback(async (zkPassportResult) => {
+        if (!currentUserAddress) {
+            setError('No user address set');
+            setStatus('error');
+            return;
+        }
+        setStatus('processing');
+        setError(null);
+        try {
+            const verificationResult = await compliance.processVerification(zkPassportResult, currentUserAddress);
+            if (verificationResult) {
+                setResult(verificationResult);
+                setStatus('completed');
+            }
+            else {
+                throw new Error('Failed to process verification result');
+            }
+        }
+        catch (err) {
+            setError(err instanceof Error ? err.message : 'Processing failed');
+            setStatus('error');
+        }
+    }, [compliance, currentUserAddress]);
+    const reset = React.useCallback(() => {
+        setStatus('idle');
+        setVerificationUrl(null);
+        setQrCode(null);
+        setResult(null);
+        setError(null);
+        setCurrentUserAddress(null);
+    }, []);
+    return {
+        status,
+        verificationUrl,
+        qrCode,
+        result,
+        error,
+        startVerification,
+        processResult,
+        reset
+    };
+}
+
+/**
+ * @treza/react - React components for TREZA SDK
+ *
+ * Privacy-first DeFi UI components with zero-knowledge compliance
+ */
+// Component exports
+// Version
+const VERSION = '1.0.0';
+
+exports.ComplianceProvider = ComplianceProvider;
+exports.ComplianceService = ComplianceService;
+exports.ComplianceStatusDisplay = ComplianceStatusDisplay;
+exports.ComplianceVerification = ComplianceVerification;
+exports.GovernanceEligibility = GovernanceEligibility;
+exports.VERSION = VERSION;
+exports.WalletService = WalletService;
+exports.complianceStyles = complianceStyles;
+exports.getComplianceService = getComplianceService;
+exports.getWalletService = getWalletService;
+exports.resetComplianceService = resetComplianceService;
+exports.resetWalletService = resetWalletService;
+exports.useCompliance = useCompliance;
+exports.useComplianceContext = useComplianceContext;
+exports.useTreza = useTreza;
+exports.useVerificationFlow = useVerificationFlow;
+exports.useWallet = useWallet;
+//# sourceMappingURL=index.js.map