import { Connection } from '@solana/web3.js';

// ✅ Use your proxy URL (no API key exposed!)
const connection = new Connection(
  'https://fortiblox-proxy.your-subdomain.workers.dev',
  'confirmed'
);

// Make RPC calls as normal
const slot = await connection.getSlot();
const health = await connection.getHealth();

// Send transactions
const signature = await connection.sendTransaction(transaction, [signer]);

from solana.rpc.api import Client

# ✅ Use your proxy URL (no API key exposed!)
client = Client("https://fortiblox-proxy.your-subdomain.workers.dev")

# Make RPC calls as normal
slot = client.get_slot()
health = client.get_health()

# Send transactions
signature = client.send_transaction(transaction)

import { Connection } from '@solana/web3.js';
import { useMemo } from 'react';

function App() {
  // ✅ Use your proxy URL (no API key exposed!)
  const connection = useMemo(
    () => new Connection(
      'https://fortiblox-proxy.your-subdomain.workers.dev',
      'confirmed'
    ),
    []
  );

  async function fetchData() {
    const slot = await connection.getSlot();
    console.log('Current slot:', slot);
  }

  return (
    <div>
      <button onClick={fetchData}>Fetch Slot</button>
    </div>
  );
}

import { Connection } from '@solana/web3.js';
import { ref, onMounted } from 'vue';

export default {
  setup() {
    // ✅ Use your proxy URL (no API key exposed!)
    const connection = new Connection(
      'https://fortiblox-proxy.your-subdomain.workers.dev',
      'confirmed'
    );

    const slot = ref(null);

    async function fetchSlot() {
      slot.value = await connection.getSlot();
    }

    onMounted(fetchSlot);

    return { slot, fetchSlot };
  }
};

// server.js
const express = require('express');
const fetch = require('node-fetch');
require('dotenv').config();

const app = express();
app.use(express.json());

// CORS
app.use((req, res, next) => {
  res.header('Access-Control-Allow-Origin', 'https://yourdomain.com');
  res.header('Access-Control-Allow-Methods', 'POST');
  res.header('Access-Control-Allow-Headers', 'Content-Type');
  next();
});

// Proxy endpoint
app.post('/rpc', async (req, res) => {
  try {
    const response = await fetch(
      `https://nexus.fortiblox.com/rpc?api-key=${process.env.FORTIBLOX_API_KEY}`,
      {
        method: 'POST',
        headers: { 'Content-Type': 'application/json' },
        body: JSON.stringify(req.body)
      }
    );

    const data = await response.json();
    res.json(data);
  } catch (error) {
    res.status(500).json({ error: 'Proxy error' });
  }
});

app.listen(3000, () => console.log('Proxy running on port 3000'));

// src/index.js
export default {
  async fetch(request, env) {
    // CORS preflight
    if (request.method === 'OPTIONS') {
      return new Response(null, {
        headers: {
          'Access-Control-Allow-Origin': 'https://yourdomain.com',
          'Access-Control-Allow-Methods': 'POST',
          'Access-Control-Allow-Headers': 'Content-Type'
        }
      });
    }

    // Only allow POST
    if (request.method !== 'POST') {
      return new Response('Method not allowed', { status: 405 });
    }

    try {
      // Forward to FortiBlox
      const response = await fetch(
        `https://nexus.fortiblox.com/rpc?api-key=${env.FORTIBLOX_API_KEY}`,
        {
          method: 'POST',
          headers: { 'Content-Type': 'application/json' },
          body: await request.text()
        }
      );

      // Return response with CORS
      return new Response(await response.text(), {
        headers: {
          'Content-Type': 'application/json',
          'Access-Control-Allow-Origin': 'https://yourdomain.com'
        }
      });
    } catch (error) {
      return new Response(
        JSON.stringify({ error: 'Proxy error' }),
        { status: 500, headers: { 'Content-Type': 'application/json' } }
      );
    }
  }
};