Build with Fairside

const API_BASE_URL = 'https://api.fairside.io/v1';
const API_KEY = 'your-api-key';
const POLLING_INTERVAL = 10000; // 10 seconds

// 1. Get payment estimates for all supported currencies
async function getPaymentEstimates(coverAmount) {
  const response = await fetch(`${API_BASE_URL}/nowpayments/estimates`, {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
      'api-key': API_KEY,
    },
    body: JSON.stringify({ coverAmount }),
  });
  
  const data = await response.json();
  // Returns: { coverAmount, ethAmount, estimates: [{ currency, network, estimatedAmount }] }
  return data;
}

// 2. Create payment intention with selected currency
async function createPayment(token, params) {
  const response = await fetch(`${API_BASE_URL}/nowpayments/payments`, {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
      'api-key': API_KEY,
      'Authorization': `Bearer ${token}`,
    },
    body: JSON.stringify({
      coverAmount: params.coverAmount,
      membershipTypeId: '0', // MainNet
      paymentCurrency: params.currency,  // e.g., 'usdt', 'btc'
      paymentNetwork: params.network,    // e.g., 'erc20', 'bitcoin'
      paymentType: 'new_purchase',       // or 'topup'
    }),
  });
  
  const data = await response.json();
  // Returns: { paymentId, paymentAddress, paymentAmount, expiresAt, ... }
  return data;
}

// 3. Poll payment status until complete
async function pollPaymentStatus(token, paymentId, onStatusUpdate) {
  const checkStatus = async () => {
    const response = await fetch(
      `${API_BASE_URL}/nowpayments/payments/${paymentId}`,
      {
        headers: {
          'api-key': API_KEY,
          'Authorization': `Bearer ${token}`,
        },
      }
    );
    
    const status = await response.json();
    onStatusUpdate(status);
    
    // Payment statuses: waiting, confirming, confirmed, sending, finished, failed, expired
    if (status.paymentStatus === 'finished') {
      console.log('Payment complete! Tx:', status.membershipPurchaseTxHash);
      return status;
    }
    
    if (status.paymentStatus === 'failed' || status.paymentStatus === 'expired') {
      throw new Error(`Payment ${status.paymentStatus}`);
    }
    
    // Continue polling
    await new Promise(resolve => setTimeout(resolve, POLLING_INTERVAL));
    return checkStatus();
  };
  
  return checkStatus();
}

// Complete Crypto Payment Flow
async function purchaseWithCrypto(token, coverAmount, preferredCurrency = 'usdt') {
  // Step 1: Get estimates
  const estimates = await getPaymentEstimates(coverAmount);
  console.log('Available currencies:', estimates.estimates);
  
  // Step 2: Find preferred currency
  const selected = estimates.estimates.find(
    e => e.currency === preferredCurrency
  );
  
  if (!selected) {
    throw new Error(`Currency ${preferredCurrency} not available`);
  }
  
  // Step 3: Create payment
  const payment = await createPayment(token, {
    coverAmount,
    currency: selected.currency,
    network: selected.network,
  });
  
  console.log('Send exactly', payment.paymentAmount, selected.currency);
  console.log('To address:', payment.paymentAddress);
  console.log('Expires at:', payment.expiresAt);
  
  // Step 4: Poll until user sends payment and it's confirmed
  // Fairside handles the on-chain membership purchase automatically
  const finalStatus = await pollPaymentStatus(token, payment.paymentId, (status) => {
    console.log('Status:', status.paymentStatus);
  });
  
  return finalStatus;
}

// Usage
purchaseWithCrypto(authToken, 5, 'usdt')
  .then(status => console.log('Membership created:', status.membershipPurchaseTxHash))
  .catch(err => console.error('Payment failed:', err));

import { ethers } from 'ethers';

const NETWORK_CONTRACT = '0x17aD4490A9181cf01F2Be059765d4f2d8Ee6d8a0';

// FairSideNetwork ABI (minimal)
const FairSideNetworkABI = [
  'function purchaseMembership(uint256 costShareBenefit, address coverAddress, uint256 membershipType) external payable',
  'function estimateCost(uint256 costShareBenefit, uint256 accountDuration, uint256 membershipTypeId) external view returns (uint256)',
  'function getAccountMembership(address account) external view returns (uint256[])',
];

async function purchaseMembership(coverAmountETH) {
  const provider = new ethers.BrowserProvider(window.ethereum);
  const signer = await provider.getSigner();
  const walletAddress = await signer.getAddress();
  
  const networkContract = new ethers.Contract(
    NETWORK_CONTRACT,
    FairSideNetworkABI,
    signer
  );

  // Check if user already has membership
  const coverIds = await networkContract.getAccountMembership(walletAddress);
  if (coverIds.length >= 1) {
    throw new Error('User already has a membership');
  }

  // Calculate cost
  const amountWei = ethers.parseEther(coverAmountETH.toString());
  const fee = await networkContract.estimateCost(amountWei, 0, 0);

  // Purchase
  const tx = await networkContract.purchaseMembership(
    amountWei,
    walletAddress,
    0, // MainNet type
    { value: fee }
  );

  const receipt = await tx.wait();
  console.log('Transaction hash:', receipt.hash);
  
  return receipt;
}

// Usage
purchaseMembership(5); // 5 ETH coverage

const API_BASE_URL = 'https://api.fairside.io/v1';
const API_KEY = 'your-api-key';

async function checkCoverageStatus(walletAddress) {
  const response = await fetch(
    `${API_BASE_URL}/membership/check-cover/${walletAddress}`,
    {
      headers: {
        'api-key': API_KEY,
      },
    }
  );

  const data = await response.json();
  
  return {
    hasCoverage: data.hasCover,
    isActive: data.isActive,
    coverAmount: data.coverAmount,
    validUntil: new Date(data.validUntil),
    hasActiveClaims: data.activeClaims.length > 0,
  };
}

// Usage
const status = await checkCoverageStatus('0x...');

if (status.hasCoverage && status.isActive) {
  console.log(`Protected with ${status.coverAmount} ETH until ${status.validUntil}`);
} else if (status.hasCoverage && !status.isActive) {
  console.log('Coverage expired - renewal needed');
} else {
  console.log('No coverage - purchase needed');
}