Examples

import express from 'express';
import { AttestSDK, StellarConfig, SolanaConfig } from '@attestprotocol/sdk';

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

let stellarSDK: any;
let solanaSDK: any;

async function initializeSDKs() {
  stellarSDK = await AttestSDK.initializeStellar({
    secretKeyOrCustomSigner: process.env.STELLAR_SECRET_KEY!,
    publicKey: process.env.STELLAR_PUBLIC_KEY!
  });

  solanaSDK = await AttestSDK.initializeSolana({
    walletOrSecretKey: JSON.parse(process.env.SOLANA_SECRET_KEY!)
  });
}

app.post('/api/attest', async (req, res) => {
  const { chain, schemaUID, subject, data, reference } = req.body;

  try {
    let result;
    if (chain === 'stellar') {
      result = await stellarSDK.attest({
        schemaUID,
        subject,
        value: data,
        reference
      });
    } else if (chain === 'solana') {
      const balanceResult = await solanaSDK.getWalletBalance();
      result = await solanaSDK.attest({
        schemaData: new anchor.web3.PublicKey(schemaUID),
        data,
        accounts: {
          recipient: new anchor.web3.PublicKey(subject),
          levyReceipent: balanceResult.data!.address,
          mintAccount: new anchor.web3.PublicKey('So11111111111111111111111111111111111111112')
        }
      });
    } else {
      return res.status(400).json({ error: 'Unsupported chain' });
    }

    if (result.error) {
      return res.status(500).json({ error: result.error });
    }

    res.json({ 
      success: true, 
      attestationId: result.data,
      chain 
    });
  } catch (error) {
    res.status(500).json({ error: error.message });
  }
});

app.get('/api/verify/:chain/:schema/:subject', async (req, res) => {
  const { chain, schema, subject } = req.params;

  try {
    let result;
    if (chain === 'stellar') {
      result = await stellarSDK.fetchAttestation({
        schemaUID: schema,
        subject: subject
      });
    } else if (chain === 'solana') {
      result = await solanaSDK.fetchAttestation(subject);
    } else {
      return res.status(400).json({ error: 'Unsupported chain' });
    }

    if (result.error) {
      return res.status(500).json({ error: result.error });
    }

    res.json({
      verified: !!result.data && !result.data.revoked,
      attestation: result.data,
      chain
    });
  } catch (error) {
    res.status(500).json({ error: error.message });
  }
});

initializeSDKs().then(() => {
  app.listen(3000);
});

import React, { useState, useEffect } from 'react';
import { AttestSDK } from '@attestprotocol/sdk';

interface AttestationFormProps {
  chain: 'stellar' | 'solana';
}

// Custom hook for AttestSDK
export function useAttestSDK(chain: 'stellar' | 'solana') {
  const [sdk, setSdk] = useState<any>(null);
  const [loading, setLoading] = useState(true);
  const [error, setError] = useState<string | null>(null);

  useEffect(() => {
    async function init() {
      try {
        let instance;
        if (chain === 'stellar') {
          instance = await AttestSDK.initializeStellar(stellarConfig);
        } else {
          instance = await AttestSDK.initializeSolana(solanaConfig);
        }
        setSdk(instance);
      } catch (err) {
        setError(err.message);
      } finally {
        setLoading(false);
      }
    }
    init();
  }, [chain]);

  return { sdk, loading, error };
}

interface EnvironmentConfig {
  stellar: StellarConfig;
  solana: SolanaConfig;
}

function getConfig(): EnvironmentConfig {
  const requiredEnvVars = [
    'STELLAR_SECRET_KEY',
    'STELLAR_PUBLIC_KEY', 
    'SOLANA_SECRET_KEY'
  ];

  for (const envVar of requiredEnvVars) {
    if (!process.env[envVar]) {
      throw new Error(`Missing required environment variable: ${envVar}`);
    }
  }

  return {
    stellar: {
      secretKeyOrCustomSigner: process.env.STELLAR_SECRET_KEY!,
      publicKey: process.env.STELLAR_PUBLIC_KEY!,
      url: process.env.STELLAR_RPC_URL || 'https://soroban-testnet.stellar.org'
    },
    solana: {
      walletOrSecretKey: JSON.parse(process.env.SOLANA_SECRET_KEY!),
      url: process.env.SOLANA_RPC_URL || 'https://api.devnet.solana.com',
      programId: process.env.SOLANA_PROGRAM_ID
    }
  };
}

// Usage
const config = getConfig();
const stellarSDK = await AttestSDK.initializeStellar(config.stellar);
const solanaSDK = await AttestSDK.initializeSolana(config.solana);

async function withRetry<T>(
  operation: () => Promise<AttestSDKResponse<T>>,
  maxRetries: number = 3
): Promise<AttestSDKResponse<T>> {
  let lastError: any;
  
  for (let attempt = 1; attempt <= maxRetries; attempt++) {
    const result = await operation();
    
    if (!result.error) {
      return result;
    }
    
    lastError = result.error;
    
    const errorStr = result.error.toString().toLowerCase();
    if (errorStr.includes('unauthorized') || 
        errorStr.includes('invalid') ||
        errorStr.includes('already exists')) {
      break;
    }
    
    if (attempt < maxRetries) {
      const delay = 1000 * Math.pow(2, attempt - 1);
      await new Promise(resolve => setTimeout(resolve, delay));
    }
  }
  
  return { error: lastError };
}

// Usage
const result = await withRetry(
  () => sdk.attest(attestConfig),
  3 // max retries
);