getBridgeStatus

import { getBridgeStatus } from '@silentswap/sdk';

import { getBridgeStatus } from '@silentswap/sdk';
 
// After executing a bridge transaction, you get a requestId
const status = await getBridgeStatus(
  'request-id-from-execution', // Request ID from executeBridgeTransaction
  quoteResult.provider // Use the provider from your quote result
);
 
console.log('Status:', status.status); // 'pending' | 'success' | 'failed' | 'refund' | 'fallback'
console.log('Transaction Hashes:', status.txHashes);
console.log('Details:', status.details);

function getBridgeStatus(
  requestId: string,
  provider: BridgeProvider
): Promise<BridgeStatus>

interface BridgeStatus {
  status: 'pending' | 'success' | 'failed' | 'refund' | 'fallback';
  txHashes?: Hex[];
  details?: string;
  requestId?: string;
}

import { getBridgeStatus, type BridgeProvider, type BridgeStatus } from '@silentswap/sdk';
 
async function pollBridgeStatus(
  requestId: string,
  provider: BridgeProvider,
  maxAttempts: number = 60,
  intervalMs: number = 5000
): Promise<BridgeStatus> {
  for (let i = 0; i < maxAttempts; i++) {
    const status = await getBridgeStatus(requestId, provider);
    
    if (status.status === 'success') {
      console.log('Bridge completed successfully!');
      return status;
    }
    
    if (status.status === 'failed' || status.status === 'refund') {
      console.log('Bridge failed or refunded');
      return status;
    }
    
    // Still pending, wait and retry
    console.log(`Attempt ${i + 1}/${maxAttempts}: Still pending...`);
    await new Promise(resolve => setTimeout(resolve, intervalMs));
  }
  
  throw new Error('Bridge status polling timeout');
}
 
// Usage
const status = await pollBridgeStatus(
  'request-id-123',
  quoteResult.provider, // Use provider from quote
  60, // Max 60 attempts
  5000 // 5 second intervals
);

import { getBridgeStatus } from '@silentswap/sdk';
 
try {
  const status = await getBridgeStatus(requestId, provider);
  
  switch (status.status) {
    case 'success':
      console.log('Bridge completed:', status.txHashes);
      break;
    case 'pending':
      console.log('Still processing...');
      break;
    case 'failed':
      console.error('Bridge failed:', status.details);
      break;
    case 'refund':
      console.warn('Transaction refunded:', status.details);
      break;
    case 'fallback':
      console.info('Used fallback route:', status.details);
      break;
  }
} catch (err) {
  if (err.message.includes('API error')) {
    console.error('Provider API error:', err);
  } else {
    console.error('Status check error:', err);
  }
}

import { getBridgeStatus, type BridgeProvider } from '@silentswap/sdk';
 
// Store bridge requests in database
interface BridgeRequest {
  id: string;
  requestId: string;
  provider: BridgeProvider;
  status: string;
  createdAt: Date;
}
 
async function checkPendingBridges() {
  const pendingBridges = await db.getPendingBridges();
  
  for (const bridge of pendingBridges) {
    try {
      const status = await getBridgeStatus(bridge.requestId, bridge.provider);
      
      // Update database
      await db.updateBridgeStatus(bridge.id, status.status, {
        txHashes: status.txHashes,
        details: status.details,
      });
      
      // Notify user if completed
      if (status.status === 'success') {
        await notifyUser(bridge.userId, 'Bridge completed successfully!');
      }
    } catch (err) {
      console.error(`Failed to check bridge ${bridge.id}:`, err);
    }
  }
}
 
// Run every 30 seconds
setInterval(checkPendingBridges, 30000);