IntegrityGuard Documentation

# Download your tier-specific package from customer portal
# https://integrityguard-license-api.onrender.com/portal

# Extract the downloaded package
unzip integrityguard-professional-v1.0.0.zip
cd integrityguard

# Install dependencies (Professional/Enterprise tiers)
npm install

# For Developer tier - direct integration
const IntegrityGuard = require('./integrityguard.js');

const express = require('express');
const IntegrityGuard = require('./integrityguard.js');

const app = express();

// Initialize with your license key (received via email)
const guard = new IntegrityGuard({
    licenseKey: 'IG-DEV-YOURAPP-20241201-a1b2c3d4',
    difficulty: 65536,  // Standard difficulty
    challengeExpiry: 300000 // 5 minutes
});

// Protect expensive endpoints
app.use('/api/expensive-operation', guard.middleware());

app.get('/api/expensive-operation', (req, res) => {
    res.json({ 
        message: 'Protected endpoint accessed!',
        proof: req.integrityProof // Proof details available
    });
});

app.listen(3000);

const express = require('express');
const { IntegrityGuard } = require('./src/integrityguard.source.js');

const app = express();

// Advanced configuration with dynamic features
const guard = new IntegrityGuard({
    licenseKey: 'IG-PRO-YOURAPP-20241201-x9y8z7w6',
    
    // Dynamic difficulty adjustment based on solve times
    dynamicDifficulty: true,
    baseThreshold: 29273, // Threshold-based (more precise than leading zeros)
    adjustmentFactor: 0.1,
    
    // Built-in rate limiting
    rateLimiting: {
        windowMs: 60000, // 1 minute
        maxAttempts: 10
    },
    
    // Metrics collection
    metrics: true,
    
    // Event handlers
    onChallengeSolved: (challenge, proof, solvetime) => {
        console.log(`Challenge solved in ${solvetime}ms`);
    },
    onAbuseDetected: (ip, pattern) => {
        console.log(`Potential abuse from ${ip}: ${pattern}`);
    }
});

// Protect endpoints with different rules
app.use('/api/ai/*', guard.middleware({
    threshold: 50000, // Higher difficulty for AI endpoints
    bypassPremium: true // Premium users skip proof-of-work
}));

app.listen(3000);

const express = require('express');
const { IntegrityGuard } = require('@integrity-guard/core');

const app = express();

// Apply authentication middleware first
app.use('/api/*', authenticateToken);

// Initialize IntegrityGuard after authentication
const guard = new IntegrityGuard({
    licenseKey: process.env.INTEGRITY_GUARD_LICENSE,
    tiers: {
        anonymous: { 
            difficulty: 500000, 
            description: 'Anonymous users',
            estimatedTime: '30-120 seconds' 
        },
        authenticated: { 
            difficulty: 200000, 
            description: 'Free registered users',
            estimatedTime: '15-60 seconds' 
        },
        premium: { 
            difficulty: 25000, 
            description: 'Premium subscribers',
            estimatedTime: '1-3 seconds' 
        }
    },
    getUserTier: (req) => {
        // Your user tier logic
        if (req.user?.subscription === 'premium') return 'premium';
        if (req.user) return 'authenticated';
        return 'anonymous';
    }
});

// Protect specific routes
app.use('/api/expensive-ai-call', guard.middleware());
app.use('/api/resource-intensive', guard.middleware());

// Dynamic difficulty based on server load
const guard = new IntegrityGuard({
    licenseKey: process.env.INTEGRITY_GUARD_LICENSE,
    tiers: {
        anonymous: { 
            difficulty: () => {
                const load = getServerLoad();
                return Math.max(250000, load * 10000);
            }
        },
        premium: { difficulty: 25000 }
    },
    getUserTier: (req) => {
        // Custom tier detection
        const tier = req.user?.subscription || 'anonymous';
        
        // Support for test tokens
        if (req.headers.authorization) {
            const token = req.headers.authorization.split(' ')[1];
            if (isTestToken(token)) {
                return getTestTier(token);
            }
        }
        
        return tier === 'premium' ? 'premium' : 'anonymous';
    },
    onChallengeSolved: (req, proof, tier) => {
        console.log(`Challenge solved by ${tier} user in ${proof.computeTime}ms`);
    }
});