Error Codes & Troubleshooting

{
  "error": {
    "code": "ERROR_CODE",
    "message": "Human-readable description",
    "details": {
      "field": "Additional context"
    }
  }
}

{
  "error": {
    "code": "UNAUTHORIZED",
    "message": "Invalid or missing API key"
  }
}

{
  "error": {
    "code": "FORBIDDEN",
    "message": "You do not have access to this resource"
  }
}

{
  "error": {
    "code": "POLICY_NOT_FOUND",
    "message": "Policy not found"
  }
}

{
  "error": {
    "code": "CONFLICT",
    "message": "A Swig with this ID already exists"
  }
}

{
  "error": {
    "code": "BAD_REQUEST",
    "message": "Invalid request parameters",
    "details": {
      "policyId": "Policy ID is required",
      "network": "Must be 'mainnet' or 'devnet'"
    }
  }
}

{
  "error": {
    "code": "MISSING_URL",
    "message": "Portal URL is required for this operation"
  }
}

const client = new SwigApiClient({
  apiKey: 'sk_your_api_key',
  portalUrl: 'https://dashboard.onswig.com', // Add this
});

{
  "error": {
    "code": "RATE_LIMITED",
    "message": "Too many requests. Please retry after 60 seconds"
  }
}

{
  "error": {
    "code": "INSUFFICIENT_BALANCE",
    "message": "Paymaster has insufficient balance"
  }
}

{
  "error": {
    "code": "LIMIT_EXCEEDED",
    "message": "Monthly limit exceeded"
  }
}

{
  "error": {
    "code": "SINGLE_TX_LIMIT_EXCEEDED",
    "message": "Transaction exceeds single transaction limit"
  }
}

{
  "error": {
    "code": "SUBSCRIPTION_REQUIRED",
    "message": "This feature requires a paid subscription"
  }
}

import { SwigApiClient, ApiError } from '@swig-wallet/api';

const client = new SwigApiClient({
  apiKey: process.env.SWIG_API_KEY!,
  portalUrl: 'https://dashboard.onswig.com',
});

const { data, error } = await client.policies.get(policyId);

if (error) {
  // error is an ApiError
  console.error('Error code:', error.code);
  console.error('Status:', error.status);
  console.error('Message:', error.message);
  console.error('Details:', error.details);

  switch (error.code) {
    case 'NOT_FOUND':
      // Handle missing resource
      break;
    case 'UNAUTHORIZED':
      // Handle auth error
      break;
    case 'RATE_LIMITED':
      // Implement backoff
      break;
    default:
      // Handle unexpected error
  }
}

import { SwigClient, SwigError } from '@swig-wallet/developer';

const client = new SwigClient({
  apiKey: process.env.SWIG_API_KEY!,
  baseUrl: 'https://dashboard.onswig.com',
});

try {
  const policy = await client.getPolicy(policyId);
} catch (error) {
  if (error instanceof SwigError) {
    // error is a SwigError
    console.error('Error code:', error.code);
    console.error('Status:', error.statusCode);
    console.error('Message:', error.message);
    console.error('Response:', error.response);

    switch (error.code) {
      case 'POLICY_NOT_FOUND':
        // Handle missing policy
        break;
      case 'UNAUTHORIZED':
        // Handle auth error
        break;
      default:
        // Handle unexpected error
    }
  } else {
    // Handle non-API errors
    throw error;
  }
}

async function fetchWithRetry<T>(
  fn: () => Promise<T>,
  maxRetries = 3,
  baseDelay = 1000
): Promise<T> {
  for (let i = 0; i < maxRetries; i++) {
    try {
      return await fn();
    } catch (error) {
      if (i === maxRetries - 1) throw error;

      const delay = baseDelay * Math.pow(2, i);
      await new Promise(resolve => setTimeout(resolve, delay));
    }
  }
  throw new Error('Max retries exceeded');
}

// API SDK
const client = new SwigApiClient({
  apiKey: 'sk_your_api_key',
  retry: {
    maxRetries: 3,
    retryDelay: 1000,
    backoffMultiplier: 2,
  },
});

// Legacy SDK
const client = new SwigClient({
  apiKey: 'sk_your_api_key',
  retryOptions: {
    maxRetries: 3,
    retryDelay: 1000,
    backoffMultiplier: 2,
  },
});

// Log before request
console.log('Request:', { url, method, body });

// Log response
console.log('Response:', { status, data, error });

if (!policyId) {
  throw new Error('Policy ID is required');
}

if (!['mainnet', 'devnet'].includes(network)) {
  throw new Error('Network must be mainnet or devnet');
}

const config = {
  network: 'devnet', // Use devnet for testing
  // ...
};