all the changes

Author: 97115104

.env.example

@@ -0,0 +1,3 @@
+UPSTASH_REDIS_REST_URL=your_upstash_redis_rest_url_here
+UPSTASH_REDIS_REST_TOKEN=your_upstash_redis_rest_token_here
+STRIPE_SECRET_KEY=your_stripe_secret_key_here

.gitignore

@@ -1 +1,5 @@
-.DS_Store
+.DS_Store
+.env.local
+.env
+node_modules/
+.vercel

api/create-checkout.js

@@ -0,0 +1,62 @@
+import Stripe from 'stripe';
+import { getRedisClient } from './lib/redis.js';
+
+const stripe = new Stripe(process.env.STRIPE_SECRET_KEY);
+
+export default async function handler(req, res) {
+  if (req.method !== 'POST') {
+    return res.status(405).json({ error: 'Method not allowed' });
+  }
+
+  try {
+    const { email, attestationData } = req.body;
+    
+    if (!email) {
+      return res.status(400).json({ error: 'Email is required' });
+    }
+
+    const redis = getRedisClient();
+    
+    // Check if user already has lifetime access
+    const existingKey = await redis.get(`api_key:email:${email}`);
+    if (existingKey) {
+      return res.status(200).json({ 
+        alreadyPurchased: true, 
+        apiKey: existingKey,
+        message: 'You already have lifetime access!' 
+      });
+    }
+
+    // Create Stripe checkout session
+    const session = await stripe.checkout.sessions.create({
+      payment_method_types: ['card'],
+      line_items: [
+        {
+          price_data: {
+            currency: 'usd',
+            product_data: {
+              name: 'attest.ink Lifetime Short URLs',
+              description: 'Create unlimited permanent short URLs for your AI attestations',
+              images: ['https://attest.ink/assets/logo/circular-2-ai.svg'],
+            },
+            unit_amount: 2000, // $20.00
+          },
+          quantity: 1,
+        },
+      ],
+      mode: 'payment',
+      success_url: `${process.env.VERCEL_URL || 'https://attest.ink'}/payment-success?session_id={CHECKOUT_SESSION_ID}`,
+      cancel_url: `${process.env.VERCEL_URL || 'https://attest.ink'}/create/`,
+      customer_email: email,
+      metadata: {
+        email: email,
+        attestationData: attestationData ? JSON.stringify(attestationData) : ''
+      },
+    });
+
+    res.status(200).json({ checkoutUrl: session.url });
+  } catch (error) {
+    console.error('Error creating checkout session:', error);
+    res.status(500).json({ error: 'Failed to create checkout session' });
+  }
+}

api/lib/redis.js

@@ -0,0 +1,21 @@
+import { Redis } from '@upstash/redis';
+
+let redis;
+
+export function getRedisClient() {
+  if (!redis) {
+    const url = process.env.UPSTASH_REDIS_REST_URL;
+    const token = process.env.UPSTASH_REDIS_REST_TOKEN;
+    
+    if (!url || !token) {
+      throw new Error('Missing UPSTASH_REDIS_REST_URL or UPSTASH_REDIS_REST_TOKEN environment variables');
+    }
+    
+    redis = new Redis({
+      url,
+      token,
+    });
+  }
+  
+  return redis;
+}

api/package.json

@@ -0,0 +1,10 @@
+{
+  "name": "attest-ink-api",
+  "version": "1.0.0",
+  "type": "module",
+  "dependencies": {
+    "@upstash/redis": "^1.28.0",
+    "nanoid": "^5.0.4",
+    "stripe": "^14.14.0"
+  }
+}

api/s/[id].js

@@ -0,0 +1,27 @@
+import { getRedisClient } from '../lib/redis.js';
+
+export default async function handler(req, res) {
+  if (req.method !== 'GET') {
+    return res.status(405).json({ error: 'Method not allowed' });
+  }
+
+  try {
+    const { id } = req.query;
+    
+    if (!id) {
+      return res.status(400).json({ error: 'Missing short ID' });
+    }
+
+    const redis = getRedisClient();
+    const dataUrl = await redis.get(`url:${id}`);
+    
+    if (!dataUrl) {
+      return res.status(404).json({ error: 'Short URL not found' });
+    }
+    
+    res.status(200).json({ dataUrl });
+  } catch (error) {
+    console.error('Error retrieving URL:', error);
+    res.status(500).json({ error: 'Failed to retrieve URL' });
+  }
+}

api/shorten.js

@@ -0,0 +1,66 @@
+import { getRedisClient } from './lib/redis.js';
+import { customAlphabet } from 'nanoid';
+
+const nanoid = customAlphabet('1234567890abcdefghijklmnopqrstuvwxyz', 8);
+
+export default async function handler(req, res) {
+  if (req.method !== 'POST') {
+    return res.status(405).json({ error: 'Method not allowed' });
+  }
+
+  try {
+    const { dataUrl, apiKey, email } = req.body;
+    
+    if (!dataUrl || !dataUrl.startsWith('data:')) {
+      return res.status(400).json({ error: 'Invalid data URL' });
+    }
+
+    const redis = getRedisClient();
+    
+    // Verify API key or email
+    let validUser = null;
+    
+    if (apiKey) {
+      // Check if API key is valid
+      const keyData = await redis.get(`api_key:${apiKey}`);
+      if (keyData) {
+        validUser = JSON.parse(keyData).email;
+      }
+    } else if (email) {
+      // Check if email has an API key
+      const existingKey = await redis.get(`api_key:email:${email}`);
+      if (existingKey) {
+        validUser = email;
+      }
+    }
+    
+    if (!validUser) {
+      return res.status(403).json({ 
+        error: 'Payment required',
+        requiresPayment: true,
+        message: 'Please purchase lifetime access to create permanent short URLs'
+      });
+    }
+    
+    // Generate a unique short ID
+    let shortId;
+    let exists = true;
+    
+    while (exists) {
+      shortId = nanoid();
+      exists = await redis.exists(`url:${shortId}`);
+    }
+    
+    // Store the mapping permanently (no expiration)
+    await redis.set(`url:${shortId}`, dataUrl);
+    await redis.set(`url:${shortId}:owner`, validUser);
+    
+    // Return the short URL
+    const shortUrl = `${process.env.VERCEL_URL || 'https://attest.ink'}/s/${shortId}`;
+    
+    res.status(200).json({ shortUrl, shortId });
+  } catch (error) {
+    console.error('Error shortening URL:', error);
+    res.status(500).json({ error: 'Failed to shorten URL' });
+  }
+}

api/verify-payment.js

@@ -0,0 +1,87 @@
+import Stripe from 'stripe';
+import { getRedisClient } from './lib/redis.js';
+import { customAlphabet } from 'nanoid';
+
+const stripe = new Stripe(process.env.STRIPE_SECRET_KEY);
+const generateApiKey = customAlphabet('1234567890abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ', 32);
+
+export default async function handler(req, res) {
+  if (req.method !== 'POST') {
+    return res.status(405).json({ error: 'Method not allowed' });
+  }
+
+  try {
+    const { sessionId } = req.body;
+    
+    if (!sessionId) {
+      return res.status(400).json({ error: 'Session ID is required' });
+    }
+
+    // Retrieve the session from Stripe
+    const session = await stripe.checkout.sessions.retrieve(sessionId);
+    
+    if (session.payment_status !== 'paid') {
+      return res.status(400).json({ error: 'Payment not completed' });
+    }
+
+    const email = session.customer_email || session.customer_details?.email;
+    if (!email) {
+      return res.status(400).json({ error: 'No email found in session' });
+    }
+
+    const redis = getRedisClient();
+    
+    // Check if API key already exists for this email
+    let apiKey = await redis.get(`api_key:email:${email}`);
+    
+    if (!apiKey) {
+      // Generate new API key
+      apiKey = `ak_${generateApiKey()}`;
+      
+      // Store the API key mappings (never expire)
+      await redis.set(`api_key:email:${email}`, apiKey);
+      await redis.set(`api_key:${apiKey}`, JSON.stringify({
+        email,
+        created: new Date().toISOString(),
+        stripeSessionId: sessionId
+      }));
+    }
+    
+    // If there was attestation data in the metadata, create the short URL
+    let shortUrl = null;
+    if (session.metadata?.attestationData) {
+      try {
+        const attestationData = JSON.parse(session.metadata.attestationData);
+        const dataUrl = `data:application/json;base64,${btoa(JSON.stringify(attestationData))}`;
+        
+        // Generate short ID
+        const shortIdGenerator = customAlphabet('1234567890abcdefghijklmnopqrstuvwxyz', 8);
+        let shortId;
+        let exists = true;
+        
+        while (exists) {
+          shortId = shortIdGenerator();
+          exists = await redis.exists(`url:${shortId}`);
+        }
+        
+        // Store permanently (no expiration)
+        await redis.set(`url:${shortId}`, dataUrl);
+        await redis.set(`url:${shortId}:owner`, email);
+        
+        shortUrl = `${process.env.VERCEL_URL || 'https://attest.ink'}/s/${shortId}`;
+      } catch (error) {
+        console.error('Error creating short URL from attestation data:', error);
+      }
+    }
+    
+    res.status(200).json({ 
+      success: true, 
+      apiKey,
+      email,
+      shortUrl
+    });
+  } catch (error) {
+    console.error('Error verifying payment:', error);
+    res.status(500).json({ error: 'Failed to verify payment' });
+  }
+}